Update README.md

XhmikosR · XhmikosR · commit 6ea626920f7d · 2016-02-02T23:37:04.000+02:00
[ci skip]
diff --git a/README.md b/README.md
@@ -51,13 +51,17 @@ The constructor accepts an options object that specifies additional features the
 * `strict` - set to true to disable error recovery and stop on the first syntax error. Default is false.
 
 Here's an example with some options set:
+
 ```js
 var parser = new parserlib.css.Parser({ starHack: true, underscoreHack: true });
 ```
+
 You can then parse a string of CSS code by passing into the `parse()` method:
+
 ```js
 parser.parse(someCSSText);
 ```
+
 The `parse()` method throws an error if a non-recoverable syntax error occurs, otherwise it finishes silently. This method does not return a value nor does it build up an abstract syntax tree (AST) for you, it simply parses the CSS text and fires events at important moments along the parse.
 
 Note: The `parseStyleSheet()` method is provided for compatibility with SAC-based APIs but does the exact same thing as `parse()`.
@@ -80,9 +84,11 @@ The `parserlib.css.MediaQuery` type represents all parts of a media query. Each
 * `features` - an array of `parserlib.css.MediaFeature` objects
 
 For example, consider the following media query:
+
 ```css
 only screen and (max-device-width: 768px) and (orientation:portrait)
 ```
+
 A corresponding object would have the following values:
 
 * `modifier` = "only"
@@ -93,9 +99,9 @@ A corresponding object would have the following values:
 
 The `parserlib.css.PropertyName` type represents a property name. Each instance has the following properties:
 
-* `hack` - if star or underscore hacks are allowed, either "*" or "_" if present (`null` if not present or hacks are not allowed)
+* `hack` - if star or underscore hacks are allowed, either `*` or `_` if present (`null` if not present or hacks are not allowed)
 
-When star hacks are allowed, the `text` property becomes the actual property name, so `*width` has `hack` equal to "*" and `text` equal to "width". If no hacks are allowed, then `*width` causes a syntax error while `_width` has `hack` equal to `null` and `text` equal to "_width".
+When star hacks are allowed, the `text` property becomes the actual property name, so `*width` has `hack` equal to `*` and `text` equal to "width". If no hacks are allowed, then `*width` causes a syntax error while `_width` has `hack` equal to `null` and `text` equal to "_width".
 
 The `parserlib.css.PropertyValue` type represents a property value. Since property values in CSS are complex, this type of object wraps the various parts into a single interface. Each instance has the following properties:
 
@@ -108,17 +114,21 @@ The `parserlib.css.PropertyValuePart` type represents an individual part of a pr
 * `type` - the type of value part ("unknown", "dimension", "percentage", "integer", "number", "color", "uri",  "string", "identifier" or "operator")
 
 A part is considered any atomic piece of a property value not including white space. Consider the following:
+
 ```css
 font: 1em/1.5em "Times New Roman", Times, serif;
 ```
-The `PropertyName` is "font" and the `PropertyValue' represents everything after the colon. The parts are "1em" (dimension), "/" (operator), "1.5em" (dimension), "\"Times New Roman\"" (string), "," (operator), "Times" (identifier), "," (operator), and "serif" (identifier).
+
+The `PropertyName` is "font" and the `PropertyValue` represents everything after the colon. The parts are "1em" (dimension), "/" (operator), "1.5em" (dimension), "Times New Roman" (string), "," (operator), "Times" (identifier), "," (operator), and "serif" (identifier).
 
 ### Selectors
 
 The `parserlib.css.Selector` type represents a single selector. Each instance has a `parts` property, which is an array of `parserlib.css.SelectorPart` objects, which represent atomic parts of the selector, and `parserlib.css.Combinator` objects, which represent combinators in the selector. Consider the following selector:
+
 ```css
 li.selected > a:hover
 ```
+
 This selector has three parts: `li.selected`, `>`, and `a:hover`. The first part is a `SelectorPart`, the second is a `Combinator`, and the third is a `SelectorPart`. Each `SelectorPart` is made up of an optional element name followed by an ID, class, attribute condition, pseudo class, and/or pseudo element.
 
 Each instance of `parserlib.css.SelectorPart` has an `elementName` property, which represents the element name as a `parserlib.css.SelectorSubPart` object or `null` if there isn't one, and a `modifiers` property, which is an array of `parserlib.css.SelectorSubPart` objects. Each `SelectorSubPart` object represents the smallest individual piece of a selector and has a `type` property indicating the type of subpart, "elementName", "class", "attribute", "pseudo", "id", "not". If the `type` is "not", then the `args` property contains an array of `SelectorPart` arguments that were passed to `not()`.
@@ -143,6 +153,7 @@ You should assign your event handlers before calling the `parse()` method.
 ### `startstylesheet` and `endstylesheet` events
 
 The `startstylesheet` event fires just before parsing of the CSS text begins and the `endstylesheet` event fires just after all of the CSS text has been parsed. There is no additional information provided for these events. Example:
+
 ```js
 parser.addListener("startstylesheet", function(){
     console.log("Starting to parse style sheet");
@@ -152,33 +163,41 @@ parser.addListener("endstylesheet", function(){
     console.log("Finished parsing style sheet");
 });
 ```
+
 ### `charset` event
 
 The `charset` event fires when the `@charset` directive is found in a style sheet. Since `@charset` is required to appear first in a style sheet, any other occurances cause a syntax error. The `charset` event provides an `event` object with a property called `charset`, which contains the name of the character set for the style sheet. Example:
+
 ```js
 parser.addListener("charset", function(event){
     console.log("Character set is " + event.charset);
 });
 ```
+
 ### `namespace` event
 
 The `namespace` event fires when the `@namespace` directive is found in a style sheet. The `namespace` event provides an `event` object with two properties: `prefix`, which is the namespace prefix, and `uri`, which is the namespace URI. Example:
+
 ```js
 parser.addListener("namespace", function(event){
     console.log("Namespace with prefix=" + event.prefix + " and URI=" + event.uri);
 });
 ```
+
 ### `import` event
 
 The `import` event fires when the `@import` directive is found in a style sheet. The `import` event provides an `event` object with two properties: `uri`, which is the URI to import, and `media`, which is an array of media queries for which this URI applies. The `media` array contains zero or more `parserlib.css.MediaQuery` objects. Example:
+
 ```js
 parser.addListener("import", function(event){
     console.log("Importing " + event.uri + " for media types [" + event.media + "]");
 });
 ```
+
 ### `startfontface` and `endfontface` events
 
 The `startfontface` event fires when `@font-face` is encountered and the `endfontface` event fires just after the closing right brace (`}`) is encountered after `@font-face`. There is no additional information available on the `event` object. Example:
+
 ```js
 parser.addListener("startfontface", function(event){
     console.log("Starting font face");
@@ -188,9 +207,11 @@ parser.addListener("endfontface", function(event){
     console.log("Ending font face");
 });
 ```
+
 ### `startpage` and `endpage` events
 
 The `startpage` event fires when `@page` is encountered and the `endpage` event fires just after the closing right brace (`}`) is encountered after `@page`. The `event` object has two properties: `id`, which is the page ID, and `pseudo`, which is the page pseudo class. Example:
+
 ```js
 parser.addListener("startpage", function(event){
     console.log("Starting page with ID=" + event.id + " and pseudo=" + event.pseudo);
@@ -200,48 +221,53 @@ parser.addListener("endpage", function(event){
     console.log("Ending page with ID=" + event.id + " and pseudo=" + event.pseudo);
 });
 ```
+
 ### `startpagemargin` and `endpagemargin` events
 
 The `startpagemargin` event fires when a page margin directive (such as `@top-left`) is encountered and the `endfontface` event fires just after the closing right brace (`}`) is encountered after the page margin. The `event` object has a `margin` property, which contains the actual page margin encountered. Example:
+
 ```js
 parser.addListener("startpagemargin", function(event){
     console.log("Starting page margin " + event.margin);
 });
 
-
 parser.addListener("endpagemargin", function(event){
     console.log("Ending page margin " + event.margin);
 });
 ```
+
 ### `startmedia` and `endmedia` events
 
 The `startmedia` event fires when `@media` is encountered and the `endmedia` event fires just after the closing right brace (`}`) is encountered after `@media`. The `event` object has one property, `media`, which is an array of `parserlib.css.MediaQuery` objects. Example:
+
 ```js
 parser.addListener("startpagemargin", function(event){
     console.log("Starting page margin " + event.margin);
 });
 
-
 parser.addListener("endpagemargin", function(event){
     console.log("Ending page margin " + event.margin);
 });
 ```
+
 ### `startkeyframes` and `endkeyframes` events
 
 The `startkeyframes` event fires when `@keyframes` (or any vendor prefixed version) is encountered and the `endkeyframes` event fires just after the closing right brace (`}`) is encountered after `@keyframes`. The `event` object has one property, `name`, which is the name of the animation. Example:
+
 ```js
 parser.addListener("startkeyframes", function(event){
     console.log("Starting animation definition " + event.name);
 });
 
-
 parser.addListener("endkeyframes", function(event){
     console.log("Ending animation definition " + event.name);
 });
 ```
+
 ### `startrule` and `endrule` events
 
 The `startrule` event fires just after all selectors on a rule have been parsed and the `endrule` event fires just after the closing right brace (`}`) is encountered for the rule. The `event` object has one additional property, `selectors`, which is an array of `parserlib.css.Selector` objects. Example:
+
 ```js
 parser.addListener("startrule", function(event){
     console.log("Starting rule with " + event.selectors.length + " selector(s)");
@@ -271,17 +297,21 @@ parser.addListener("endrule", function(event){
     console.log("Ending rule with selectors [" + event.selectors + "]");
 });
 ```
+
 ### `property` event
 
 The `property` event fires whenever a CSS property (`name:value`) is encountered, which may be inside of a rule, a media block, a page block, etc. The `event` object has three additional properties: `property`, which is the name of the property as a `parserlib.css.PropertyName` object, `value`, which is an instance of `parserlib.css.PropertyValue`(both types inherit from `parserlib.util.SyntaxUnit`), and `important`, which is a Boolean value indicating if the property is flagged with `!important`. Example:
+
 ```js
 parser.addListener("property", function(event){
     console.log("Property '" + event.property + "' has a value of '" + event.value + "' and " + (event.important ? "is" : "isn't") + " important. (" + event.property.line + "," + event.property.col + ")");
 });
 ```
+
 ### `error` event
 
 The `error` event fires whenever a recoverable error occurs during parsing. When in strict mode, this event does not fire. The `event` object contains three additional properties: `message`, which is the error message, `line`, which is the line on which the error occurred, and `col`, which is the column on that line in which the error occurred. Example:
+
 ```js
 parser.addListener("error", function(event){
     console.log("Parse error: " + event.message + " (" + event.line + "," + event.col + ")", "error");
@@ -293,21 +323,25 @@ parser.addListener("error", function(event){
 The CSS parser's goal is to be on-par with error recovery of CSS parsers in browsers. To that end, the following error recovery mechanisms are in place:
 
 * **Properties** - a syntactically incorrect property definition will be skipped over completely. For instance, the second property below is dropped:
+
 ```css
 a:hover {
     color: red;
     font:: Helvetica;    /*dropped!*/
     text-decoration: underline;
 }
 ```
+
 * **Selectors** - if there's a syntax error in *any* selector, the entire rule is skipped over. For instance, the following rule is completely skipped:
+
 ```css
 a:hover, foo ... bar {
     color: red;
     font: Helvetica;
     text-decoration: underline;
 }
 ```
+
 * **@ Rules** - there are certain @ rules that are only valid in certain contexts. The parser will skip over `@charset`, `@namespace`, and `@import` if they're found anywhere other than the beginning of the input.
 
 * **Unknown @ Rules** - any @ rules that isn't recognized is automatically skipped, meaning the entire block after it is not parsed.
