enmi-conf.org: comparison wp/wp-includes/js/codemirror/csslint.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/codemirror/csslint.js

changeset 7	cf61fcea0001
child 16	a86126ab1dd4

equal deleted inserted replaced

-:490d5cc509ed
+:cf61fcea0001
+/*!
+CSSLint v1.0.4
+Copyright (c) 2016 Nicole Sullivan and Nicholas C. Zakas. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the 'Software'), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+var CSSLint = (function(){
+var module = module || {},
+exports = exports || {};
+/*!
+Parser-Lib
+Copyright (c) 2009-2016 Nicholas C. Zakas. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+/* Version v1.1.0, Build time: 6-December-2016 10:31:29 */
+var parserlib = (function () {
+var require;
+require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+"use strict";
+/* exported Colors */
+var Colors = module.exports = {
+__proto__       :null,
+aliceblue       :"#f0f8ff",
+antiquewhite    :"#faebd7",
+aqua            :"#00ffff",
+aquamarine      :"#7fffd4",
+azure           :"#f0ffff",
+beige           :"#f5f5dc",
+bisque          :"#ffe4c4",
+black           :"#000000",
+blanchedalmond  :"#ffebcd",
+blue            :"#0000ff",
+blueviolet      :"#8a2be2",
+brown           :"#a52a2a",
+burlywood       :"#deb887",
+cadetblue       :"#5f9ea0",
+chartreuse      :"#7fff00",
+chocolate       :"#d2691e",
+coral           :"#ff7f50",
+cornflowerblue  :"#6495ed",
+cornsilk        :"#fff8dc",
+crimson         :"#dc143c",
+cyan            :"#00ffff",
+darkblue        :"#00008b",
+darkcyan        :"#008b8b",
+darkgoldenrod   :"#b8860b",
+darkgray        :"#a9a9a9",
+darkgrey        :"#a9a9a9",
+darkgreen       :"#006400",
+darkkhaki       :"#bdb76b",
+darkmagenta     :"#8b008b",
+darkolivegreen  :"#556b2f",
+darkorange      :"#ff8c00",
+darkorchid      :"#9932cc",
+darkred         :"#8b0000",
+darksalmon      :"#e9967a",
+darkseagreen    :"#8fbc8f",
+darkslateblue   :"#483d8b",
+darkslategray   :"#2f4f4f",
+darkslategrey   :"#2f4f4f",
+darkturquoise   :"#00ced1",
+darkviolet      :"#9400d3",
+deeppink        :"#ff1493",
+deepskyblue     :"#00bfff",
+dimgray         :"#696969",
+dimgrey         :"#696969",
+dodgerblue      :"#1e90ff",
+firebrick       :"#b22222",
+floralwhite     :"#fffaf0",
+forestgreen     :"#228b22",
+fuchsia         :"#ff00ff",
+gainsboro       :"#dcdcdc",
+ghostwhite      :"#f8f8ff",
+gold            :"#ffd700",
+goldenrod       :"#daa520",
+gray            :"#808080",
+grey            :"#808080",
+green           :"#008000",
+greenyellow     :"#adff2f",
+honeydew        :"#f0fff0",
+hotpink         :"#ff69b4",
+indianred       :"#cd5c5c",
+indigo          :"#4b0082",
+ivory           :"#fffff0",
+khaki           :"#f0e68c",
+lavender        :"#e6e6fa",
+lavenderblush   :"#fff0f5",
+lawngreen       :"#7cfc00",
+lemonchiffon    :"#fffacd",
+lightblue       :"#add8e6",
+lightcoral      :"#f08080",
+lightcyan       :"#e0ffff",
+lightgoldenrodyellow  :"#fafad2",
+lightgray       :"#d3d3d3",
+lightgrey       :"#d3d3d3",
+lightgreen      :"#90ee90",
+lightpink       :"#ffb6c1",
+lightsalmon     :"#ffa07a",
+lightseagreen   :"#20b2aa",
+lightskyblue    :"#87cefa",
+lightslategray  :"#778899",
+lightslategrey  :"#778899",
+lightsteelblue  :"#b0c4de",
+lightyellow     :"#ffffe0",
+lime            :"#00ff00",
+limegreen       :"#32cd32",
+linen           :"#faf0e6",
+magenta         :"#ff00ff",
+maroon          :"#800000",
+mediumaquamarine:"#66cdaa",
+mediumblue      :"#0000cd",
+mediumorchid    :"#ba55d3",
+mediumpurple    :"#9370d8",
+mediumseagreen  :"#3cb371",
+mediumslateblue :"#7b68ee",
+mediumspringgreen   :"#00fa9a",
+mediumturquoise :"#48d1cc",
+mediumvioletred :"#c71585",
+midnightblue    :"#191970",
+mintcream       :"#f5fffa",
+mistyrose       :"#ffe4e1",
+moccasin        :"#ffe4b5",
+navajowhite     :"#ffdead",
+navy            :"#000080",
+oldlace         :"#fdf5e6",
+olive           :"#808000",
+olivedrab       :"#6b8e23",
+orange          :"#ffa500",
+orangered       :"#ff4500",
+orchid          :"#da70d6",
+palegoldenrod   :"#eee8aa",
+palegreen       :"#98fb98",
+paleturquoise   :"#afeeee",
+palevioletred   :"#d87093",
+papayawhip      :"#ffefd5",
+peachpuff       :"#ffdab9",
+peru            :"#cd853f",
+pink            :"#ffc0cb",
+plum            :"#dda0dd",
+powderblue      :"#b0e0e6",
+purple          :"#800080",
+red             :"#ff0000",
+rosybrown       :"#bc8f8f",
+royalblue       :"#4169e1",
+saddlebrown     :"#8b4513",
+salmon          :"#fa8072",
+sandybrown      :"#f4a460",
+seagreen        :"#2e8b57",
+seashell        :"#fff5ee",
+sienna          :"#a0522d",
+silver          :"#c0c0c0",
+skyblue         :"#87ceeb",
+slateblue       :"#6a5acd",
+slategray       :"#708090",
+slategrey       :"#708090",
+snow            :"#fffafa",
+springgreen     :"#00ff7f",
+steelblue       :"#4682b4",
+tan             :"#d2b48c",
+teal            :"#008080",
+thistle         :"#d8bfd8",
+tomato          :"#ff6347",
+turquoise       :"#40e0d0",
+violet          :"#ee82ee",
+wheat           :"#f5deb3",
+white           :"#ffffff",
+whitesmoke      :"#f5f5f5",
+yellow          :"#ffff00",
+yellowgreen     :"#9acd32",
+//'currentColor' color keyword https://www.w3.org/TR/css3-color/#currentcolor
+currentColor        :"The value of the 'color' property.",
+//CSS2 system colors https://www.w3.org/TR/css3-color/#css2-system
+activeBorder        :"Active window border.",
+activecaption       :"Active window caption.",
+appworkspace        :"Background color of multiple document interface.",
+background          :"Desktop background.",
+buttonface          :"The face background color for 3-D elements that appear 3-D due to one layer of surrounding border.",
+buttonhighlight     :"The color of the border facing the light source for 3-D elements that appear 3-D due to one layer of surrounding border.",
+buttonshadow        :"The color of the border away from the light source for 3-D elements that appear 3-D due to one layer of surrounding border.",
+buttontext          :"Text on push buttons.",
+captiontext         :"Text in caption, size box, and scrollbar arrow box.",
+graytext            :"Grayed (disabled) text. This color is set to #000 if the current display driver does not support a solid gray color.",
+greytext            :"Greyed (disabled) text. This color is set to #000 if the current display driver does not support a solid grey color.",
+highlight           :"Item(s) selected in a control.",
+highlighttext       :"Text of item(s) selected in a control.",
+inactiveborder      :"Inactive window border.",
+inactivecaption     :"Inactive window caption.",
+inactivecaptiontext :"Color of text in an inactive caption.",
+infobackground      :"Background color for tooltip controls.",
+infotext            :"Text color for tooltip controls.",
+menu                :"Menu background.",
+menutext            :"Text in menus.",
+scrollbar           :"Scroll bar gray area.",
+threeddarkshadow    :"The color of the darker (generally outer) of the two borders away from the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
+threedface          :"The face background color for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
+threedhighlight     :"The color of the lighter (generally outer) of the two borders facing the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
+threedlightshadow   :"The color of the darker (generally inner) of the two borders facing the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
+threedshadow        :"The color of the lighter (generally inner) of the two borders away from the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
+window              :"Window background.",
+windowframe         :"Window frame.",
+windowtext          :"Text in windows."
+};
+},{}],2:[function(require,module,exports){
+"use strict";
+module.exports = Combinator;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents a selector combinator (whitespace, +, >).
+* @namespace parserlib.css
+* @class Combinator
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {String} text The text representation of the unit.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function Combinator(text, line, col) {
+SyntaxUnit.call(this, text, line, col, Parser.COMBINATOR_TYPE);
+/**
+* The type of modifier.
+* @type String
+* @property type
+*/
+this.type = "unknown";
+//pretty simple
+if (/^\s+$/.test(text)) {
+this.type = "descendant";
+} else if (text === ">") {
+this.type = "child";
+} else if (text === "+") {
+this.type = "adjacent-sibling";
+} else if (text === "~") {
+this.type = "sibling";
+}
+}
+Combinator.prototype = new SyntaxUnit();
+Combinator.prototype.constructor = Combinator;
+},{"../util/SyntaxUnit":26,"./Parser":6}],3:[function(require,module,exports){
+"use strict";
+module.exports = Matcher;
+var StringReader = require("../util/StringReader");
+var SyntaxError = require("../util/SyntaxError");
+/**
+* This class implements a combinator library for matcher functions.
+* The combinators are described at:
+* https://developer.mozilla.org/en-US/docs/Web/CSS/Value_definition_syntax#Component_value_combinators
+*/
+function Matcher(matchFunc, toString) {
+this.match = function(expression) {
+// Save/restore marks to ensure that failed matches always restore
+// the original location in the expression.
+var result;
+expression.mark();
+result = matchFunc(expression);
+if (result) {
+expression.drop();
+} else {
+expression.restore();
+}
+return result;
+};
+this.toString = typeof toString === "function" ? toString : function() {
+return toString;
+};
+}
+/** Precedence table of combinators. */
+Matcher.prec = {
+MOD:    5,
+SEQ:    4,
+ANDAND: 3,
+OROR:   2,
+ALT:    1
+};
+/** Simple recursive-descent grammar to build matchers from strings. */
+Matcher.parse = function(str) {
+var reader, eat, expr, oror, andand, seq, mod, term, result;
+reader = new StringReader(str);
+eat = function(matcher) {
+var result = reader.readMatch(matcher);
+if (result === null) {
+throw new SyntaxError(
+"Expected "+matcher, reader.getLine(), reader.getCol());
+}
+return result;
+};
+expr = function() {
+// expr = oror (" | " oror)*
+var m = [ oror() ];
+while (reader.readMatch(" | ") !== null) {
+m.push(oror());
+}
+return m.length === 1 ? m[0] : Matcher.alt.apply(Matcher, m);
+};
+oror = function() {
+// oror = andand ( " || " andand)*
+var m = [ andand() ];
+while (reader.readMatch(" || ") !== null) {
+m.push(andand());
+}
+return m.length === 1 ? m[0] : Matcher.oror.apply(Matcher, m);
+};
+andand = function() {
+// andand = seq ( " && " seq)*
+var m = [ seq() ];
+while (reader.readMatch(" && ") !== null) {
+m.push(seq());
+}
+return m.length === 1 ? m[0] : Matcher.andand.apply(Matcher, m);
+};
+seq = function() {
+// seq = mod ( " " mod)*
+var m = [ mod() ];
+while (reader.readMatch(/^ (?![&|\]])/) !== null) {
+m.push(mod());
+}
+return m.length === 1 ? m[0] : Matcher.seq.apply(Matcher, m);
+};
+mod = function() {
+// mod = term ( "?" | "*" | "+" | "#" | "{<num>,<num>}" )?
+var m = term();
+if (reader.readMatch("?") !== null) {
+return m.question();
+} else if (reader.readMatch("*") !== null) {
+return m.star();
+} else if (reader.readMatch("+") !== null) {
+return m.plus();
+} else if (reader.readMatch("#") !== null) {
+return m.hash();
+} else if (reader.readMatch(/^\{\s*/) !== null) {
+var min = eat(/^\d+/);
+eat(/^\s*,\s*/);
+var max = eat(/^\d+/);
+eat(/^\s*\}/);
+return m.braces(+min, +max);
+}
+return m;
+};
+term = function() {
+// term = <nt> | literal | "[ " expression " ]"
+if (reader.readMatch("[ ") !== null) {
+var m = expr();
+eat(" ]");
+return m;
+}
+return Matcher.fromType(eat(/^[^ ?*+#{]+/));
+};
+result = expr();
+if (!reader.eof()) {
+throw new SyntaxError(
+"Expected end of string", reader.getLine(), reader.getCol());
+}
+return result;
+};
+/**
+* Convert a string to a matcher (parsing simple alternations),
+* or do nothing if the argument is already a matcher.
+*/
+Matcher.cast = function(m) {
+if (m instanceof Matcher) {
+return m;
+}
+return Matcher.parse(m);
+};
+/**
+* Create a matcher for a single type.
+*/
+Matcher.fromType = function(type) {
+// Late require of ValidationTypes to break a dependency cycle.
+var ValidationTypes = require("./ValidationTypes");
+return new Matcher(function(expression) {
+return expression.hasNext() && ValidationTypes.isType(expression, type);
+}, type);
+};
+/**
+* Create a matcher for one or more juxtaposed words, which all must
+* occur, in the given order.
+*/
+Matcher.seq = function() {
+var ms = Array.prototype.slice.call(arguments).map(Matcher.cast);
+if (ms.length === 1) {
+return ms[0];
+}
+return new Matcher(function(expression) {
+var i, result = true;
+for (i = 0; result && i < ms.length; i++) {
+result = ms[i].match(expression);
+}
+return result;
+}, function(prec) {
+var p = Matcher.prec.SEQ;
+var s = ms.map(function(m) {
+return m.toString(p);
+}).join(" ");
+if (prec > p) {
+s = "[ " + s + " ]";
+}
+return s;
+});
+};
+/**
+* Create a matcher for one or more alternatives, where exactly one
+* must occur.
+*/
+Matcher.alt = function() {
+var ms = Array.prototype.slice.call(arguments).map(Matcher.cast);
+if (ms.length === 1) {
+return ms[0];
+}
+return new Matcher(function(expression) {
+var i, result = false;
+for (i = 0; !result && i < ms.length; i++) {
+result = ms[i].match(expression);
+}
+return result;
+}, function(prec) {
+var p = Matcher.prec.ALT;
+var s = ms.map(function(m) {
+return m.toString(p);
+}).join(" | ");
+if (prec > p) {
+s = "[ " + s + " ]";
+}
+return s;
+});
+};
+/**
+* Create a matcher for two or more options.  This implements the
+* double bar (||) and double ampersand (&&) operators, as well as
+* variants of && where some of the alternatives are optional.
+* This will backtrack through even successful matches to try to
+* maximize the number of items matched.
+*/
+Matcher.many = function(required) {
+var ms = Array.prototype.slice.call(arguments, 1).reduce(function(acc, v) {
+if (v.expand) {
+// Insert all of the options for the given complex rule as
+// individual options.
+var ValidationTypes = require("./ValidationTypes");
+acc.push.apply(acc, ValidationTypes.complex[v.expand].options);
+} else {
+acc.push(Matcher.cast(v));
+}
+return acc;
+}, []);
+if (required === true) {
+required = ms.map(function() {
+return true;
+});
+}
+var result = new Matcher(function(expression) {
+var seen = [], max = 0, pass = 0;
+var success = function(matchCount) {
+if (pass === 0) {
+max = Math.max(matchCount, max);
+return matchCount === ms.length;
+} else {
+return matchCount === max;
+}
+};
+var tryMatch = function(matchCount) {
+for (var i = 0; i < ms.length; i++) {
+if (seen[i]) {
+continue;
+}
+expression.mark();
+if (ms[i].match(expression)) {
+seen[i] = true;
+// Increase matchCount iff this was a required element
+// (or if all the elements are optional)
+if (tryMatch(matchCount + ((required === false || required[i]) ? 1 : 0))) {
+expression.drop();
+return true;
+}
+// Backtrack: try *not* matching using this rule, and
+// let's see if it leads to a better overall match.
+expression.restore();
+seen[i] = false;
+} else {
+expression.drop();
+}
+}
+return success(matchCount);
+};
+if (!tryMatch(0)) {
+// Couldn't get a complete match, retrace our steps to make the
+// match with the maximum # of required elements.
+pass++;
+tryMatch(0);
+}
+if (required === false) {
+return max > 0;
+}
+// Use finer-grained specification of which matchers are required.
+for (var i = 0; i < ms.length; i++) {
+if (required[i] && !seen[i]) {
+return false;
+}
+}
+return true;
+}, function(prec) {
+var p = required === false ? Matcher.prec.OROR : Matcher.prec.ANDAND;
+var s = ms.map(function(m, i) {
+if (required !== false && !required[i]) {
+return m.toString(Matcher.prec.MOD) + "?";
+}
+return m.toString(p);
+}).join(required === false ? " || " : " && ");
+if (prec > p) {
+s = "[ " + s + " ]";
+}
+return s;
+});
+result.options = ms;
+return result;
+};
+/**
+* Create a matcher for two or more options, where all options are
+* mandatory but they may appear in any order.
+*/
+Matcher.andand = function() {
+var args = Array.prototype.slice.call(arguments);
+args.unshift(true);
+return Matcher.many.apply(Matcher, args);
+};
+/**
+* Create a matcher for two or more options, where options are
+* optional and may appear in any order, but at least one must be
+* present.
+*/
+Matcher.oror = function() {
+var args = Array.prototype.slice.call(arguments);
+args.unshift(false);
+return Matcher.many.apply(Matcher, args);
+};
+/** Instance methods on Matchers. */
+Matcher.prototype = {
+constructor: Matcher,
+// These are expected to be overridden in every instance.
+match: function() { throw new Error("unimplemented"); },
+toString: function() { throw new Error("unimplemented"); },
+// This returns a standalone function to do the matching.
+func: function() { return this.match.bind(this); },
+// Basic combinators
+then: function(m) { return Matcher.seq(this, m); },
+or: function(m) { return Matcher.alt(this, m); },
+andand: function(m) { return Matcher.many(true, this, m); },
+oror: function(m) { return Matcher.many(false, this, m); },
+// Component value multipliers
+star: function() { return this.braces(0, Infinity, "*"); },
+plus: function() { return this.braces(1, Infinity, "+"); },
+question: function() { return this.braces(0, 1, "?"); },
+hash: function() {
+return this.braces(1, Infinity, "#", Matcher.cast(","));
+},
+braces: function(min, max, marker, optSep) {
+var m1 = this, m2 = optSep ? optSep.then(this) : this;
+if (!marker) {
+marker = "{" + min + "," + max + "}";
+}
+return new Matcher(function(expression) {
+var result = true, i;
+for (i = 0; i < max; i++) {
+if (i > 0 && optSep) {
+result = m2.match(expression);
+} else {
+result = m1.match(expression);
+}
+if (!result) {
+break;
+}
+}
+return i >= min;
+}, function() {
+return m1.toString(Matcher.prec.MOD) + marker;
+});
+}
+};
+},{"../util/StringReader":24,"../util/SyntaxError":25,"./ValidationTypes":21}],4:[function(require,module,exports){
+"use strict";
+module.exports = MediaFeature;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents a media feature, such as max-width:500.
+* @namespace parserlib.css
+* @class MediaFeature
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {SyntaxUnit} name The name of the feature.
+* @param {SyntaxUnit} value The value of the feature or null if none.
+*/
+function MediaFeature(name, value) {
+SyntaxUnit.call(this, "(" + name + (value !== null ? ":" + value : "") + ")", name.startLine, name.startCol, Parser.MEDIA_FEATURE_TYPE);
+/**
+* The name of the media feature
+* @type String
+* @property name
+*/
+this.name = name;
+/**
+* The value for the feature or null if there is none.
+* @type SyntaxUnit
+* @property value
+*/
+this.value = value;
+}
+MediaFeature.prototype = new SyntaxUnit();
+MediaFeature.prototype.constructor = MediaFeature;
+},{"../util/SyntaxUnit":26,"./Parser":6}],5:[function(require,module,exports){
+"use strict";
+module.exports = MediaQuery;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents an individual media query.
+* @namespace parserlib.css
+* @class MediaQuery
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {String} modifier The modifier "not" or "only" (or null).
+* @param {String} mediaType The type of media (i.e., "print").
+* @param {Array} parts Array of selectors parts making up this selector.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function MediaQuery(modifier, mediaType, features, line, col) {
+SyntaxUnit.call(this, (modifier ? modifier + " ": "") + (mediaType ? mediaType : "") + (mediaType && features.length > 0 ? " and " : "") + features.join(" and "), line, col, Parser.MEDIA_QUERY_TYPE);
+/**
+* The media modifier ("not" or "only")
+* @type String
+* @property modifier
+*/
+this.modifier = modifier;
+/**
+* The mediaType (i.e., "print")
+* @type String
+* @property mediaType
+*/
+this.mediaType = mediaType;
+/**
+* The parts that make up the selector.
+* @type Array
+* @property features
+*/
+this.features = features;
+}
+MediaQuery.prototype = new SyntaxUnit();
+MediaQuery.prototype.constructor = MediaQuery;
+},{"../util/SyntaxUnit":26,"./Parser":6}],6:[function(require,module,exports){
+"use strict";
+module.exports = Parser;
+var EventTarget = require("../util/EventTarget");
+var SyntaxError = require("../util/SyntaxError");
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Combinator = require("./Combinator");
+var MediaFeature = require("./MediaFeature");
+var MediaQuery = require("./MediaQuery");
+var PropertyName = require("./PropertyName");
+var PropertyValue = require("./PropertyValue");
+var PropertyValuePart = require("./PropertyValuePart");
+var Selector = require("./Selector");
+var SelectorPart = require("./SelectorPart");
+var SelectorSubPart = require("./SelectorSubPart");
+var TokenStream = require("./TokenStream");
+var Tokens = require("./Tokens");
+var Validation = require("./Validation");
+/**
+* A CSS3 parser.
+* @namespace parserlib.css
+* @class Parser
+* @constructor
+* @param {Object} options (Optional) Various options for the parser:
+*      starHack (true|false) to allow IE6 star hack as valid,
+*      underscoreHack (true|false) to interpret leading underscores
+*      as IE6-7 targeting for known properties, ieFilters (true|false)
+*      to indicate that IE < 8 filters should be accepted and not throw
+*      syntax errors.
+*/
+function Parser(options) {
+//inherit event functionality
+EventTarget.call(this);
+this.options = options || {};
+this._tokenStream = null;
+}
+//Static constants
+Parser.DEFAULT_TYPE = 0;
+Parser.COMBINATOR_TYPE = 1;
+Parser.MEDIA_FEATURE_TYPE = 2;
+Parser.MEDIA_QUERY_TYPE = 3;
+Parser.PROPERTY_NAME_TYPE = 4;
+Parser.PROPERTY_VALUE_TYPE = 5;
+Parser.PROPERTY_VALUE_PART_TYPE = 6;
+Parser.SELECTOR_TYPE = 7;
+Parser.SELECTOR_PART_TYPE = 8;
+Parser.SELECTOR_SUB_PART_TYPE = 9;
+Parser.prototype = function() {
+var proto = new EventTarget(),  //new prototype
+prop,
+additions =  {
+__proto__: null,
+//restore constructor
+constructor: Parser,
+//instance constants - yuck
+DEFAULT_TYPE : 0,
+COMBINATOR_TYPE : 1,
+MEDIA_FEATURE_TYPE : 2,
+MEDIA_QUERY_TYPE : 3,
+PROPERTY_NAME_TYPE : 4,
+PROPERTY_VALUE_TYPE : 5,
+PROPERTY_VALUE_PART_TYPE : 6,
+SELECTOR_TYPE : 7,
+SELECTOR_PART_TYPE : 8,
+SELECTOR_SUB_PART_TYPE : 9,
+//-----------------------------------------------------------------
+// Grammar
+//-----------------------------------------------------------------
+_stylesheet: function() {
+/*
+* stylesheet
+*  : [ CHARSET_SYM S* STRING S* ';' ]?
+*    [S|CDO|CDC]* [ import [S|CDO|CDC]* ]*
+*    [ namespace [S|CDO|CDC]* ]*
+*    [ [ ruleset | media | page | font_face | keyframes_rule | supports_rule ] [S|CDO|CDC]* ]*
+*  ;
+*/
+var tokenStream = this._tokenStream,
+count,
+token,
+tt;
+this.fire("startstylesheet");
+//try to read character set
+this._charset();
+this._skipCruft();
+//try to read imports - may be more than one
+while (tokenStream.peek() === Tokens.IMPORT_SYM) {
+this._import();
+this._skipCruft();
+}
+//try to read namespaces - may be more than one
+while (tokenStream.peek() === Tokens.NAMESPACE_SYM) {
+this._namespace();
+this._skipCruft();
+}
+//get the next token
+tt = tokenStream.peek();
+//try to read the rest
+while (tt > Tokens.EOF) {
+try {
+switch (tt) {
+case Tokens.MEDIA_SYM:
+this._media();
+this._skipCruft();
+break;
+case Tokens.PAGE_SYM:
+this._page();
+this._skipCruft();
+break;
+case Tokens.FONT_FACE_SYM:
+this._font_face();
+this._skipCruft();
+break;
+case Tokens.KEYFRAMES_SYM:
+this._keyframes();
+this._skipCruft();
+break;
+case Tokens.VIEWPORT_SYM:
+this._viewport();
+this._skipCruft();
+break;
+case Tokens.DOCUMENT_SYM:
+this._document();
+this._skipCruft();
+break;
+case Tokens.SUPPORTS_SYM:
+this._supports();
+this._skipCruft();
+break;
+case Tokens.UNKNOWN_SYM:  //unknown @ rule
+tokenStream.get();
+if (!this.options.strict) {
+//fire error event
+this.fire({
+type:       "error",
+error:      null,
+message:    "Unknown @ rule: " + tokenStream.LT(0).value + ".",
+line:       tokenStream.LT(0).startLine,
+col:        tokenStream.LT(0).startCol
+});
+//skip braces
+count=0;
+while (tokenStream.advance([Tokens.LBRACE, Tokens.RBRACE]) === Tokens.LBRACE) {
+count++;    //keep track of nesting depth
+}
+while (count) {
+tokenStream.advance([Tokens.RBRACE]);
+count--;
+}
+} else {
+//not a syntax error, rethrow it
+throw new SyntaxError("Unknown @ rule.", tokenStream.LT(0).startLine, tokenStream.LT(0).startCol);
+}
+break;
+case Tokens.S:
+this._readWhitespace();
+break;
+default:
+if (!this._ruleset()) {
+//error handling for known issues
+switch (tt) {
+case Tokens.CHARSET_SYM:
+token = tokenStream.LT(1);
+this._charset(false);
+throw new SyntaxError("@charset not allowed here.", token.startLine, token.startCol);
+case Tokens.IMPORT_SYM:
+token = tokenStream.LT(1);
+this._import(false);
+throw new SyntaxError("@import not allowed here.", token.startLine, token.startCol);
+case Tokens.NAMESPACE_SYM:
+token = tokenStream.LT(1);
+this._namespace(false);
+throw new SyntaxError("@namespace not allowed here.", token.startLine, token.startCol);
+default:
+tokenStream.get();  //get the last token
+this._unexpectedToken(tokenStream.token());
+}
+}
+}
+} catch (ex) {
+if (ex instanceof SyntaxError && !this.options.strict) {
+this.fire({
+type:       "error",
+error:      ex,
+message:    ex.message,
+line:       ex.line,
+col:        ex.col
+});
+} else {
+throw ex;
+}
+}
+tt = tokenStream.peek();
+}
+if (tt !== Tokens.EOF) {
+this._unexpectedToken(tokenStream.token());
+}
+this.fire("endstylesheet");
+},
+_charset: function(emit) {
+var tokenStream = this._tokenStream,
+charset,
+token,
+line,
+col;
+if (tokenStream.match(Tokens.CHARSET_SYM)) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.STRING);
+token = tokenStream.token();
+charset = token.value;
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.SEMICOLON);
+if (emit !== false) {
+this.fire({
+type:   "charset",
+charset:charset,
+line:   line,
+col:    col
+});
+}
+}
+},
+_import: function(emit) {
+/*
+* import
+*   : IMPORT_SYM S*
+*    [STRING|URI] S* media_query_list? ';' S*
+*/
+var tokenStream = this._tokenStream,
+uri,
+importToken,
+mediaList   = [];
+//read import symbol
+tokenStream.mustMatch(Tokens.IMPORT_SYM);
+importToken = tokenStream.token();
+this._readWhitespace();
+tokenStream.mustMatch([Tokens.STRING, Tokens.URI]);
+//grab the URI value
+uri = tokenStream.token().value.replace(/^(?:url\()?["']?([^"']+?)["']?\)?$/, "$1");
+this._readWhitespace();
+mediaList = this._media_query_list();
+//must end with a semicolon
+tokenStream.mustMatch(Tokens.SEMICOLON);
+this._readWhitespace();
+if (emit !== false) {
+this.fire({
+type:   "import",
+uri:    uri,
+media:  mediaList,
+line:   importToken.startLine,
+col:    importToken.startCol
+});
+}
+},
+_namespace: function(emit) {
+/*
+* namespace
+*   : NAMESPACE_SYM S* [namespace_prefix S*]? [STRING|URI] S* ';' S*
+*/
+var tokenStream = this._tokenStream,
+line,
+col,
+prefix,
+uri;
+//read import symbol
+tokenStream.mustMatch(Tokens.NAMESPACE_SYM);
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+//it's a namespace prefix - no _namespace_prefix() method because it's just an IDENT
+if (tokenStream.match(Tokens.IDENT)) {
+prefix = tokenStream.token().value;
+this._readWhitespace();
+}
+tokenStream.mustMatch([Tokens.STRING, Tokens.URI]);
+/*if (!tokenStream.match(Tokens.STRING)){
+tokenStream.mustMatch(Tokens.URI);
+}*/
+//grab the URI value
+uri = tokenStream.token().value.replace(/(?:url\()?["']([^"']+)["']\)?/, "$1");
+this._readWhitespace();
+//must end with a semicolon
+tokenStream.mustMatch(Tokens.SEMICOLON);
+this._readWhitespace();
+if (emit !== false) {
+this.fire({
+type:   "namespace",
+prefix: prefix,
+uri:    uri,
+line:   line,
+col:    col
+});
+}
+},
+_supports: function(emit) {
+/*
+* supports_rule
+*  : SUPPORTS_SYM S* supports_condition S* group_rule_body
+*  ;
+*/
+var tokenStream = this._tokenStream,
+line,
+col;
+if (tokenStream.match(Tokens.SUPPORTS_SYM)) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+this._supports_condition();
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.LBRACE);
+this._readWhitespace();
+if (emit !== false) {
+this.fire({
+type:   "startsupports",
+line:   line,
+col:    col
+});
+}
+while (true) {
+if (!this._ruleset()) {
+break;
+}
+}
+tokenStream.mustMatch(Tokens.RBRACE);
+this._readWhitespace();
+this.fire({
+type:   "endsupports",
+line:   line,
+col:    col
+});
+}
+},
+_supports_condition: function() {
+/*
+* supports_condition
+*  : supports_negation | supports_conjunction | supports_disjunction |
+*    supports_condition_in_parens
+*  ;
+*/
+var tokenStream = this._tokenStream,
+ident;
+if (tokenStream.match(Tokens.IDENT)) {
+ident = tokenStream.token().value.toLowerCase();
+if (ident === "not") {
+tokenStream.mustMatch(Tokens.S);
+this._supports_condition_in_parens();
+} else {
+tokenStream.unget();
+}
+} else {
+this._supports_condition_in_parens();
+this._readWhitespace();
+while (tokenStream.peek() === Tokens.IDENT) {
+ident = tokenStream.LT(1).value.toLowerCase();
+if (ident === "and" || ident === "or") {
+tokenStream.mustMatch(Tokens.IDENT);
+this._readWhitespace();
+this._supports_condition_in_parens();
+this._readWhitespace();
+}
+}
+}
+},
+_supports_condition_in_parens: function() {
+/*
+* supports_condition_in_parens
+*  : ( '(' S* supports_condition S* ')' ) | supports_declaration_condition |
+*    general_enclosed
+*  ;
+*/
+var tokenStream = this._tokenStream,
+ident;
+if (tokenStream.match(Tokens.LPAREN)) {
+this._readWhitespace();
+if (tokenStream.match(Tokens.IDENT)) {
+// look ahead for not keyword, if not given, continue with declaration condition.
+ident = tokenStream.token().value.toLowerCase();
+if (ident === "not") {
+this._readWhitespace();
+this._supports_condition();
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.RPAREN);
+} else {
+tokenStream.unget();
+this._supports_declaration_condition(false);
+}
+} else {
+this._supports_condition();
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.RPAREN);
+}
+} else {
+this._supports_declaration_condition();
+}
+},
+_supports_declaration_condition: function(requireStartParen) {
+/*
+* supports_declaration_condition
+*  : '(' S* declaration ')'
+*  ;
+*/
+var tokenStream = this._tokenStream;
+if (requireStartParen !== false) {
+tokenStream.mustMatch(Tokens.LPAREN);
+}
+this._readWhitespace();
+this._declaration();
+tokenStream.mustMatch(Tokens.RPAREN);
+},
+_media: function() {
+/*
+* media
+*   : MEDIA_SYM S* media_query_list S* '{' S* ruleset* '}' S*
+*   ;
+*/
+var tokenStream     = this._tokenStream,
+line,
+col,
+mediaList;//       = [];
+//look for @media
+tokenStream.mustMatch(Tokens.MEDIA_SYM);
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+mediaList = this._media_query_list();
+tokenStream.mustMatch(Tokens.LBRACE);
+this._readWhitespace();
+this.fire({
+type:   "startmedia",
+media:  mediaList,
+line:   line,
+col:    col
+});
+while (true) {
+if (tokenStream.peek() === Tokens.PAGE_SYM) {
+this._page();
+} else if (tokenStream.peek() === Tokens.FONT_FACE_SYM) {
+this._font_face();
+} else if (tokenStream.peek() === Tokens.VIEWPORT_SYM) {
+this._viewport();
+} else if (tokenStream.peek() === Tokens.DOCUMENT_SYM) {
+this._document();
+} else if (tokenStream.peek() === Tokens.SUPPORTS_SYM) {
+this._supports();
+} else if (tokenStream.peek() === Tokens.MEDIA_SYM) {
+this._media();
+} else if (!this._ruleset()) {
+break;
+}
+}
+tokenStream.mustMatch(Tokens.RBRACE);
+this._readWhitespace();
+this.fire({
+type:   "endmedia",
+media:  mediaList,
+line:   line,
+col:    col
+});
+},
+//CSS3 Media Queries
+_media_query_list: function() {
+/*
+* media_query_list
+*   : S* [media_query [ ',' S* media_query ]* ]?
+*   ;
+*/
+var tokenStream = this._tokenStream,
+mediaList   = [];
+this._readWhitespace();
+if (tokenStream.peek() === Tokens.IDENT || tokenStream.peek() === Tokens.LPAREN) {
+mediaList.push(this._media_query());
+}
+while (tokenStream.match(Tokens.COMMA)) {
+this._readWhitespace();
+mediaList.push(this._media_query());
+}
+return mediaList;
+},
+/*
+* Note: "expression" in the grammar maps to the _media_expression
+* method.
+*/
+_media_query: function() {
+/*
+* media_query
+*   : [ONLY | NOT]? S* media_type S* [ AND S* expression ]*
+*   | expression [ AND S* expression ]*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+type        = null,
+ident       = null,
+token       = null,
+expressions = [];
+if (tokenStream.match(Tokens.IDENT)) {
+ident = tokenStream.token().value.toLowerCase();
+//since there's no custom tokens for these, need to manually check
+if (ident !== "only" && ident !== "not") {
+tokenStream.unget();
+ident = null;
+} else {
+token = tokenStream.token();
+}
+}
+this._readWhitespace();
+if (tokenStream.peek() === Tokens.IDENT) {
+type = this._media_type();
+if (token === null) {
+token = tokenStream.token();
+}
+} else if (tokenStream.peek() === Tokens.LPAREN) {
+if (token === null) {
+token = tokenStream.LT(1);
+}
+expressions.push(this._media_expression());
+}
+if (type === null && expressions.length === 0) {
+return null;
+} else {
+this._readWhitespace();
+while (tokenStream.match(Tokens.IDENT)) {
+if (tokenStream.token().value.toLowerCase() !== "and") {
+this._unexpectedToken(tokenStream.token());
+}
+this._readWhitespace();
+expressions.push(this._media_expression());
+}
+}
+return new MediaQuery(ident, type, expressions, token.startLine, token.startCol);
+},
+//CSS3 Media Queries
+_media_type: function() {
+/*
+* media_type
+*   : IDENT
+*   ;
+*/
+return this._media_feature();
+},
+/**
+* Note: in CSS3 Media Queries, this is called "expression".
+* Renamed here to avoid conflict with CSS3 Selectors
+* definition of "expression". Also note that "expr" in the
+* grammar now maps to "expression" from CSS3 selectors.
+* @method _media_expression
+* @private
+*/
+_media_expression: function() {
+/*
+* expression
+*  : '(' S* media_feature S* [ ':' S* expr ]? ')' S*
+*  ;
+*/
+var tokenStream = this._tokenStream,
+feature     = null,
+token,
+expression  = null;
+tokenStream.mustMatch(Tokens.LPAREN);
+feature = this._media_feature();
+this._readWhitespace();
+if (tokenStream.match(Tokens.COLON)) {
+this._readWhitespace();
+token = tokenStream.LT(1);
+expression = this._expression();
+}
+tokenStream.mustMatch(Tokens.RPAREN);
+this._readWhitespace();
+return new MediaFeature(feature, expression ? new SyntaxUnit(expression, token.startLine, token.startCol) : null);
+},
+//CSS3 Media Queries
+_media_feature: function() {
+/*
+* media_feature
+*   : IDENT
+*   ;
+*/
+var tokenStream = this._tokenStream;
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.IDENT);
+return SyntaxUnit.fromToken(tokenStream.token());
+},
+//CSS3 Paged Media
+_page: function() {
+/*
+* page:
+*    PAGE_SYM S* IDENT? pseudo_page? S*
+*    '{' S* [ declaration | margin ]? [ ';' S* [ declaration | margin ]? ]* '}' S*
+*    ;
+*/
+var tokenStream = this._tokenStream,
+line,
+col,
+identifier  = null,
+pseudoPage  = null;
+//look for @page
+tokenStream.mustMatch(Tokens.PAGE_SYM);
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+if (tokenStream.match(Tokens.IDENT)) {
+identifier = tokenStream.token().value;
+//The value 'auto' may not be used as a page name and MUST be treated as a syntax error.
+if (identifier.toLowerCase() === "auto") {
+this._unexpectedToken(tokenStream.token());
+}
+}
+//see if there's a colon upcoming
+if (tokenStream.peek() === Tokens.COLON) {
+pseudoPage = this._pseudo_page();
+}
+this._readWhitespace();
+this.fire({
+type:   "startpage",
+id:     identifier,
+pseudo: pseudoPage,
+line:   line,
+col:    col
+});
+this._readDeclarations(true, true);
+this.fire({
+type:   "endpage",
+id:     identifier,
+pseudo: pseudoPage,
+line:   line,
+col:    col
+});
+},
+//CSS3 Paged Media
+_margin: function() {
+/*
+* margin :
+*    margin_sym S* '{' declaration [ ';' S* declaration? ]* '}' S*
+*    ;
+*/
+var tokenStream = this._tokenStream,
+line,
+col,
+marginSym   = this._margin_sym();
+if (marginSym) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this.fire({
+type: "startpagemargin",
+margin: marginSym,
+line:   line,
+col:    col
+});
+this._readDeclarations(true);
+this.fire({
+type: "endpagemargin",
+margin: marginSym,
+line:   line,
+col:    col
+});
+return true;
+} else {
+return false;
+}
+},
+//CSS3 Paged Media
+_margin_sym: function() {
+/*
+* margin_sym :
+*    TOPLEFTCORNER_SYM |
+*    TOPLEFT_SYM |
+*    TOPCENTER_SYM |
+*    TOPRIGHT_SYM |
+*    TOPRIGHTCORNER_SYM |
+*    BOTTOMLEFTCORNER_SYM |
+*    BOTTOMLEFT_SYM |
+*    BOTTOMCENTER_SYM |
+*    BOTTOMRIGHT_SYM |
+*    BOTTOMRIGHTCORNER_SYM |
+*    LEFTTOP_SYM |
+*    LEFTMIDDLE_SYM |
+*    LEFTBOTTOM_SYM |
+*    RIGHTTOP_SYM |
+*    RIGHTMIDDLE_SYM |
+*    RIGHTBOTTOM_SYM
+*    ;
+*/
+var tokenStream = this._tokenStream;
+if (tokenStream.match([Tokens.TOPLEFTCORNER_SYM, Tokens.TOPLEFT_SYM,
+Tokens.TOPCENTER_SYM, Tokens.TOPRIGHT_SYM, Tokens.TOPRIGHTCORNER_SYM,
+Tokens.BOTTOMLEFTCORNER_SYM, Tokens.BOTTOMLEFT_SYM,
+Tokens.BOTTOMCENTER_SYM, Tokens.BOTTOMRIGHT_SYM,
+Tokens.BOTTOMRIGHTCORNER_SYM, Tokens.LEFTTOP_SYM,
+Tokens.LEFTMIDDLE_SYM, Tokens.LEFTBOTTOM_SYM, Tokens.RIGHTTOP_SYM,
+Tokens.RIGHTMIDDLE_SYM, Tokens.RIGHTBOTTOM_SYM])) {
+return SyntaxUnit.fromToken(tokenStream.token());
+} else {
+return null;
+}
+},
+_pseudo_page: function() {
+/*
+* pseudo_page
+*   : ':' IDENT
+*   ;
+*/
+var tokenStream = this._tokenStream;
+tokenStream.mustMatch(Tokens.COLON);
+tokenStream.mustMatch(Tokens.IDENT);
+//TODO: CSS3 Paged Media says only "left", "center", and "right" are allowed
+return tokenStream.token().value;
+},
+_font_face: function() {
+/*
+* font_face
+*   : FONT_FACE_SYM S*
+*     '{' S* declaration [ ';' S* declaration ]* '}' S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+line,
+col;
+//look for @page
+tokenStream.mustMatch(Tokens.FONT_FACE_SYM);
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+this.fire({
+type:   "startfontface",
+line:   line,
+col:    col
+});
+this._readDeclarations(true);
+this.fire({
+type:   "endfontface",
+line:   line,
+col:    col
+});
+},
+_viewport: function() {
+/*
+* viewport
+*   : VIEWPORT_SYM S*
+*     '{' S* declaration? [ ';' S* declaration? ]* '}' S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+line,
+col;
+tokenStream.mustMatch(Tokens.VIEWPORT_SYM);
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+this._readWhitespace();
+this.fire({
+type:   "startviewport",
+line:   line,
+col:    col
+});
+this._readDeclarations(true);
+this.fire({
+type:   "endviewport",
+line:   line,
+col:    col
+});
+},
+_document: function() {
+/*
+* document
+*   : DOCUMENT_SYM S*
+*     _document_function [ ',' S* _document_function ]* S*
+*     '{' S* ruleset* '}'
+*   ;
+*/
+var tokenStream = this._tokenStream,
+token,
+functions = [],
+prefix = "";
+tokenStream.mustMatch(Tokens.DOCUMENT_SYM);
+token = tokenStream.token();
+if (/^@\-([^\-]+)\-/.test(token.value)) {
+prefix = RegExp.$1;
+}
+this._readWhitespace();
+functions.push(this._document_function());
+while (tokenStream.match(Tokens.COMMA)) {
+this._readWhitespace();
+functions.push(this._document_function());
+}
+tokenStream.mustMatch(Tokens.LBRACE);
+this._readWhitespace();
+this.fire({
+type:      "startdocument",
+functions: functions,
+prefix:    prefix,
+line:      token.startLine,
+col:       token.startCol
+});
+var ok = true;
+while (ok) {
+switch (tokenStream.peek()) {
+case Tokens.PAGE_SYM:
+this._page();
+break;
+case Tokens.FONT_FACE_SYM:
+this._font_face();
+break;
+case Tokens.VIEWPORT_SYM:
+this._viewport();
+break;
+case Tokens.MEDIA_SYM:
+this._media();
+break;
+case Tokens.KEYFRAMES_SYM:
+this._keyframes();
+break;
+case Tokens.DOCUMENT_SYM:
+this._document();
+break;
+default:
+ok = Boolean(this._ruleset());
+}
+}
+tokenStream.mustMatch(Tokens.RBRACE);
+token = tokenStream.token();
+this._readWhitespace();
+this.fire({
+type:      "enddocument",
+functions: functions,
+prefix:    prefix,
+line:      token.startLine,
+col:       token.startCol
+});
+},
+_document_function: function() {
+/*
+* document_function
+*   : function | URI S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value;
+if (tokenStream.match(Tokens.URI)) {
+value = tokenStream.token().value;
+this._readWhitespace();
+} else {
+value = this._function();
+}
+return value;
+},
+_operator: function(inFunction) {
+/*
+* operator (outside function)
+*  : '/' S* | ',' S* | /( empty )/
+* operator (inside function)
+*  : '/' S* | '+' S* | '*' S* | '-' S* /( empty )/
+*  ;
+*/
+var tokenStream = this._tokenStream,
+token       = null;
+if (tokenStream.match([Tokens.SLASH, Tokens.COMMA]) ||
+(inFunction && tokenStream.match([Tokens.PLUS, Tokens.STAR, Tokens.MINUS]))) {
+token =  tokenStream.token();
+this._readWhitespace();
+}
+return token ? PropertyValuePart.fromToken(token) : null;
+},
+_combinator: function() {
+/*
+* combinator
+*  : PLUS S* | GREATER S* | TILDE S* | S+
+*  ;
+*/
+var tokenStream = this._tokenStream,
+value       = null,
+token;
+if (tokenStream.match([Tokens.PLUS, Tokens.GREATER, Tokens.TILDE])) {
+token = tokenStream.token();
+value = new Combinator(token.value, token.startLine, token.startCol);
+this._readWhitespace();
+}
+return value;
+},
+_unary_operator: function() {
+/*
+* unary_operator
+*  : '-' | '+'
+*  ;
+*/
+var tokenStream = this._tokenStream;
+if (tokenStream.match([Tokens.MINUS, Tokens.PLUS])) {
+return tokenStream.token().value;
+} else {
+return null;
+}
+},
+_property: function() {
+/*
+* property
+*   : IDENT S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value       = null,
+hack        = null,
+tokenValue,
+token,
+line,
+col;
+//check for star hack - throws error if not allowed
+if (tokenStream.peek() === Tokens.STAR && this.options.starHack) {
+tokenStream.get();
+token = tokenStream.token();
+hack = token.value;
+line = token.startLine;
+col = token.startCol;
+}
+if (tokenStream.match(Tokens.IDENT)) {
+token = tokenStream.token();
+tokenValue = token.value;
+//check for underscore hack - no error if not allowed because it's valid CSS syntax
+if (tokenValue.charAt(0) === "_" && this.options.underscoreHack) {
+hack = "_";
+tokenValue = tokenValue.substring(1);
+}
+value = new PropertyName(tokenValue, hack, (line||token.startLine), (col||token.startCol));
+this._readWhitespace();
+}
+return value;
+},
+//Augmented with CSS3 Selectors
+_ruleset: function() {
+/*
+* ruleset
+*   : selectors_group
+*     '{' S* declaration? [ ';' S* declaration? ]* '}' S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+tt,
+selectors;
+/*
+* Error Recovery: If even a single selector fails to parse,
+* then the entire ruleset should be thrown away.
+*/
+try {
+selectors = this._selectors_group();
+} catch (ex) {
+if (ex instanceof SyntaxError && !this.options.strict) {
+//fire error event
+this.fire({
+type:       "error",
+error:      ex,
+message:    ex.message,
+line:       ex.line,
+col:        ex.col
+});
+//skip over everything until closing brace
+tt = tokenStream.advance([Tokens.RBRACE]);
+if (tt === Tokens.RBRACE) {
+//if there's a right brace, the rule is finished so don't do anything
+} else {
+//otherwise, rethrow the error because it wasn't handled properly
+throw ex;
+}
+} else {
+//not a syntax error, rethrow it
+throw ex;
+}
+//trigger parser to continue
+return true;
+}
+//if it got here, all selectors parsed
+if (selectors) {
+this.fire({
+type:       "startrule",
+selectors:  selectors,
+line:       selectors[0].line,
+col:        selectors[0].col
+});
+this._readDeclarations(true);
+this.fire({
+type:       "endrule",
+selectors:  selectors,
+line:       selectors[0].line,
+col:        selectors[0].col
+});
+}
+return selectors;
+},
+//CSS3 Selectors
+_selectors_group: function() {
+/*
+* selectors_group
+*   : selector [ COMMA S* selector ]*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+selectors   = [],
+selector;
+selector = this._selector();
+if (selector !== null) {
+selectors.push(selector);
+while (tokenStream.match(Tokens.COMMA)) {
+this._readWhitespace();
+selector = this._selector();
+if (selector !== null) {
+selectors.push(selector);
+} else {
+this._unexpectedToken(tokenStream.LT(1));
+}
+}
+}
+return selectors.length ? selectors : null;
+},
+//CSS3 Selectors
+_selector: function() {
+/*
+* selector
+*   : simple_selector_sequence [ combinator simple_selector_sequence ]*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+selector    = [],
+nextSelector = null,
+combinator  = null,
+ws          = null;
+//if there's no simple selector, then there's no selector
+nextSelector = this._simple_selector_sequence();
+if (nextSelector === null) {
+return null;
+}
+selector.push(nextSelector);
+do {
+//look for a combinator
+combinator = this._combinator();
+if (combinator !== null) {
+selector.push(combinator);
+nextSelector = this._simple_selector_sequence();
+//there must be a next selector
+if (nextSelector === null) {
+this._unexpectedToken(tokenStream.LT(1));
+} else {
+//nextSelector is an instance of SelectorPart
+selector.push(nextSelector);
+}
+} else {
+//if there's not whitespace, we're done
+if (this._readWhitespace()) {
+//add whitespace separator
+ws = new Combinator(tokenStream.token().value, tokenStream.token().startLine, tokenStream.token().startCol);
+//combinator is not required
+combinator = this._combinator();
+//selector is required if there's a combinator
+nextSelector = this._simple_selector_sequence();
+if (nextSelector === null) {
+if (combinator !== null) {
+this._unexpectedToken(tokenStream.LT(1));
+}
+} else {
+if (combinator !== null) {
+selector.push(combinator);
+} else {
+selector.push(ws);
+}
+selector.push(nextSelector);
+}
+} else {
+break;
+}
+}
+} while (true);
+return new Selector(selector, selector[0].line, selector[0].col);
+},
+//CSS3 Selectors
+_simple_selector_sequence: function() {
+/*
+* simple_selector_sequence
+*   : [ type_selector | universal ]
+*     [ HASH | class | attrib | pseudo | negation ]*
+*   | [ HASH | class | attrib | pseudo | negation ]+
+*   ;
+*/
+var tokenStream = this._tokenStream,
+//parts of a simple selector
+elementName = null,
+modifiers   = [],
+//complete selector text
+selectorText= "",
+//the different parts after the element name to search for
+components  = [
+//HASH
+function() {
+return tokenStream.match(Tokens.HASH) ?
+new SelectorSubPart(tokenStream.token().value, "id", tokenStream.token().startLine, tokenStream.token().startCol) :
+null;
+},
+this._class,
+this._attrib,
+this._pseudo,
+this._negation
+],
+i           = 0,
+len         = components.length,
+component   = null,
+line,
+col;
+//get starting line and column for the selector
+line = tokenStream.LT(1).startLine;
+col = tokenStream.LT(1).startCol;
+elementName = this._type_selector();
+if (!elementName) {
+elementName = this._universal();
+}
+if (elementName !== null) {
+selectorText += elementName;
+}
+while (true) {
+//whitespace means we're done
+if (tokenStream.peek() === Tokens.S) {
+break;
+}
+//check for each component
+while (i < len && component === null) {
+component = components[i++].call(this);
+}
+if (component === null) {
+//we don't have a selector
+if (selectorText === "") {
+return null;
+} else {
+break;
+}
+} else {
+i = 0;
+modifiers.push(component);
+selectorText += component.toString();
+component = null;
+}
+}
+return selectorText !== "" ?
+new SelectorPart(elementName, modifiers, selectorText, line, col) :
+null;
+},
+//CSS3 Selectors
+_type_selector: function() {
+/*
+* type_selector
+*   : [ namespace_prefix ]? element_name
+*   ;
+*/
+var tokenStream = this._tokenStream,
+ns          = this._namespace_prefix(),
+elementName = this._element_name();
+if (!elementName) {
+/*
+* Need to back out the namespace that was read due to both
+* type_selector and universal reading namespace_prefix
+* first. Kind of hacky, but only way I can figure out
+* right now how to not change the grammar.
+*/
+if (ns) {
+tokenStream.unget();
+if (ns.length > 1) {
+tokenStream.unget();
+}
+}
+return null;
+} else {
+if (ns) {
+elementName.text = ns + elementName.text;
+elementName.col -= ns.length;
+}
+return elementName;
+}
+},
+//CSS3 Selectors
+_class: function() {
+/*
+* class
+*   : '.' IDENT
+*   ;
+*/
+var tokenStream = this._tokenStream,
+token;
+if (tokenStream.match(Tokens.DOT)) {
+tokenStream.mustMatch(Tokens.IDENT);
+token = tokenStream.token();
+return new SelectorSubPart("." + token.value, "class", token.startLine, token.startCol - 1);
+} else {
+return null;
+}
+},
+//CSS3 Selectors
+_element_name: function() {
+/*
+* element_name
+*   : IDENT
+*   ;
+*/
+var tokenStream = this._tokenStream,
+token;
+if (tokenStream.match(Tokens.IDENT)) {
+token = tokenStream.token();
+return new SelectorSubPart(token.value, "elementName", token.startLine, token.startCol);
+} else {
+return null;
+}
+},
+//CSS3 Selectors
+_namespace_prefix: function() {
+/*
+* namespace_prefix
+*   : [ IDENT | '*' ]? '|'
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value       = "";
+//verify that this is a namespace prefix
+if (tokenStream.LA(1) === Tokens.PIPE || tokenStream.LA(2) === Tokens.PIPE) {
+if (tokenStream.match([Tokens.IDENT, Tokens.STAR])) {
+value += tokenStream.token().value;
+}
+tokenStream.mustMatch(Tokens.PIPE);
+value += "|";
+}
+return value.length ? value : null;
+},
+//CSS3 Selectors
+_universal: function() {
+/*
+* universal
+*   : [ namespace_prefix ]? '*'
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value       = "",
+ns;
+ns = this._namespace_prefix();
+if (ns) {
+value += ns;
+}
+if (tokenStream.match(Tokens.STAR)) {
+value += "*";
+}
+return value.length ? value : null;
+},
+//CSS3 Selectors
+_attrib: function() {
+/*
+* attrib
+*   : '[' S* [ namespace_prefix ]? IDENT S*
+*         [ [ PREFIXMATCH |
+*             SUFFIXMATCH |
+*             SUBSTRINGMATCH |
+*             '=' |
+*             INCLUDES |
+*             DASHMATCH ] S* [ IDENT | STRING ] S*
+*         ]? ']'
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value       = null,
+ns,
+token;
+if (tokenStream.match(Tokens.LBRACKET)) {
+token = tokenStream.token();
+value = token.value;
+value += this._readWhitespace();
+ns = this._namespace_prefix();
+if (ns) {
+value += ns;
+}
+tokenStream.mustMatch(Tokens.IDENT);
+value += tokenStream.token().value;
+value += this._readWhitespace();
+if (tokenStream.match([Tokens.PREFIXMATCH, Tokens.SUFFIXMATCH, Tokens.SUBSTRINGMATCH,
+Tokens.EQUALS, Tokens.INCLUDES, Tokens.DASHMATCH])) {
+value += tokenStream.token().value;
+value += this._readWhitespace();
+tokenStream.mustMatch([Tokens.IDENT, Tokens.STRING]);
+value += tokenStream.token().value;
+value += this._readWhitespace();
+}
+tokenStream.mustMatch(Tokens.RBRACKET);
+return new SelectorSubPart(value + "]", "attribute", token.startLine, token.startCol);
+} else {
+return null;
+}
+},
+//CSS3 Selectors
+_pseudo: function() {
+/*
+* pseudo
+*   : ':' ':'? [ IDENT | functional_pseudo ]
+*   ;
+*/
+var tokenStream = this._tokenStream,
+pseudo      = null,
+colons      = ":",
+line,
+col;
+if (tokenStream.match(Tokens.COLON)) {
+if (tokenStream.match(Tokens.COLON)) {
+colons += ":";
+}
+if (tokenStream.match(Tokens.IDENT)) {
+pseudo = tokenStream.token().value;
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol - colons.length;
+} else if (tokenStream.peek() === Tokens.FUNCTION) {
+line = tokenStream.LT(1).startLine;
+col = tokenStream.LT(1).startCol - colons.length;
+pseudo = this._functional_pseudo();
+}
+if (pseudo) {
+pseudo = new SelectorSubPart(colons + pseudo, "pseudo", line, col);
+} else {
+var startLine = tokenStream.LT(1).startLine,
+startCol  = tokenStream.LT(0).startCol;
+throw new SyntaxError("Expected a `FUNCTION` or `IDENT` after colon at line " + startLine + ", col " + startCol + ".", startLine, startCol);
+}
+}
+return pseudo;
+},
+//CSS3 Selectors
+_functional_pseudo: function() {
+/*
+* functional_pseudo
+*   : FUNCTION S* expression ')'
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value = null;
+if (tokenStream.match(Tokens.FUNCTION)) {
+value = tokenStream.token().value;
+value += this._readWhitespace();
+value += this._expression();
+tokenStream.mustMatch(Tokens.RPAREN);
+value += ")";
+}
+return value;
+},
+//CSS3 Selectors
+_expression: function() {
+/*
+* expression
+*   : [ [ PLUS | '-' | DIMENSION | NUMBER | STRING | IDENT ] S* ]+
+*   ;
+*/
+var tokenStream = this._tokenStream,
+value       = "";
+while (tokenStream.match([Tokens.PLUS, Tokens.MINUS, Tokens.DIMENSION,
+Tokens.NUMBER, Tokens.STRING, Tokens.IDENT, Tokens.LENGTH,
+Tokens.FREQ, Tokens.ANGLE, Tokens.TIME,
+Tokens.RESOLUTION, Tokens.SLASH])) {
+value += tokenStream.token().value;
+value += this._readWhitespace();
+}
+return value.length ? value : null;
+},
+//CSS3 Selectors
+_negation: function() {
+/*
+* negation
+*   : NOT S* negation_arg S* ')'
+*   ;
+*/
+var tokenStream = this._tokenStream,
+line,
+col,
+value       = "",
+arg,
+subpart     = null;
+if (tokenStream.match(Tokens.NOT)) {
+value = tokenStream.token().value;
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+value += this._readWhitespace();
+arg = this._negation_arg();
+value += arg;
+value += this._readWhitespace();
+tokenStream.match(Tokens.RPAREN);
+value += tokenStream.token().value;
+subpart = new SelectorSubPart(value, "not", line, col);
+subpart.args.push(arg);
+}
+return subpart;
+},
+//CSS3 Selectors
+_negation_arg: function() {
+/*
+* negation_arg
+*   : type_selector | universal | HASH | class | attrib | pseudo
+*   ;
+*/
+var tokenStream = this._tokenStream,
+args        = [
+this._type_selector,
+this._universal,
+function() {
+return tokenStream.match(Tokens.HASH) ?
+new SelectorSubPart(tokenStream.token().value, "id", tokenStream.token().startLine, tokenStream.token().startCol) :
+null;
+},
+this._class,
+this._attrib,
+this._pseudo
+],
+arg         = null,
+i           = 0,
+len         = args.length,
+line,
+col,
+part;
+line = tokenStream.LT(1).startLine;
+col = tokenStream.LT(1).startCol;
+while (i < len && arg === null) {
+arg = args[i].call(this);
+i++;
+}
+//must be a negation arg
+if (arg === null) {
+this._unexpectedToken(tokenStream.LT(1));
+}
+//it's an element name
+if (arg.type === "elementName") {
+part = new SelectorPart(arg, [], arg.toString(), line, col);
+} else {
+part = new SelectorPart(null, [arg], arg.toString(), line, col);
+}
+return part;
+},
+_declaration: function() {
+/*
+* declaration
+*   : property ':' S* expr prio?
+*   | /( empty )/
+*   ;
+*/
+var tokenStream = this._tokenStream,
+property    = null,
+expr        = null,
+prio        = null,
+invalid     = null,
+propertyName= "";
+property = this._property();
+if (property !== null) {
+tokenStream.mustMatch(Tokens.COLON);
+this._readWhitespace();
+expr = this._expr();
+//if there's no parts for the value, it's an error
+if (!expr || expr.length === 0) {
+this._unexpectedToken(tokenStream.LT(1));
+}
+prio = this._prio();
+/*
+* If hacks should be allowed, then only check the root
+* property. If hacks should not be allowed, treat
+* _property or *property as invalid properties.
+*/
+propertyName = property.toString();
+if (this.options.starHack && property.hack === "*" ||
+this.options.underscoreHack && property.hack === "_") {
+propertyName = property.text;
+}
+try {
+this._validateProperty(propertyName, expr);
+} catch (ex) {
+invalid = ex;
+}
+this.fire({
+type:       "property",
+property:   property,
+value:      expr,
+important:  prio,
+line:       property.line,
+col:        property.col,
+invalid:    invalid
+});
+return true;
+} else {
+return false;
+}
+},
+_prio: function() {
+/*
+* prio
+*   : IMPORTANT_SYM S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+result      = tokenStream.match(Tokens.IMPORTANT_SYM);
+this._readWhitespace();
+return result;
+},
+_expr: function(inFunction) {
+/*
+* expr
+*   : term [ operator term ]*
+*   ;
+*/
+var values      = [],
+//valueParts    = [],
+value       = null,
+operator    = null;
+value = this._term(inFunction);
+if (value !== null) {
+values.push(value);
+do {
+operator = this._operator(inFunction);
+//if there's an operator, keep building up the value parts
+if (operator) {
+values.push(operator);
+} /*else {
+//if there's not an operator, you have a full value
+values.push(new PropertyValue(valueParts, valueParts[0].line, valueParts[0].col));
+valueParts = [];
+}*/
+value = this._term(inFunction);
+if (value === null) {
+break;
+} else {
+values.push(value);
+}
+} while (true);
+}
+//cleanup
+/*if (valueParts.length) {
+values.push(new PropertyValue(valueParts, valueParts[0].line, valueParts[0].col));
+}*/
+return values.length > 0 ? new PropertyValue(values, values[0].line, values[0].col) : null;
+},
+_term: function(inFunction) {
+/*
+* term
+*   : unary_operator?
+*     [ NUMBER S* | PERCENTAGE S* | LENGTH S* | ANGLE S* |
+*       TIME S* | FREQ S* | function | ie_function ]
+*   | STRING S* | IDENT S* | URI S* | UNICODERANGE S* | hexcolor
+*   ;
+*/
+var tokenStream = this._tokenStream,
+unary       = null,
+value       = null,
+endChar     = null,
+part        = null,
+token,
+line,
+col;
+//returns the operator or null
+unary = this._unary_operator();
+if (unary !== null) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+}
+//exception for IE filters
+if (tokenStream.peek() === Tokens.IE_FUNCTION && this.options.ieFilters) {
+value = this._ie_function();
+if (unary === null) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+}
+//see if it's a simple block
+} else if (inFunction && tokenStream.match([Tokens.LPAREN, Tokens.LBRACE, Tokens.LBRACKET])) {
+token = tokenStream.token();
+endChar = token.endChar;
+value = token.value + this._expr(inFunction).text;
+if (unary === null) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+}
+tokenStream.mustMatch(Tokens.type(endChar));
+value += endChar;
+this._readWhitespace();
+//see if there's a simple match
+} else if (tokenStream.match([Tokens.NUMBER, Tokens.PERCENTAGE, Tokens.LENGTH,
+Tokens.ANGLE, Tokens.TIME,
+Tokens.FREQ, Tokens.STRING, Tokens.IDENT, Tokens.URI, Tokens.UNICODE_RANGE])) {
+value = tokenStream.token().value;
+if (unary === null) {
+line = tokenStream.token().startLine;
+col = tokenStream.token().startCol;
+// Correct potentially-inaccurate IDENT parsing in
+// PropertyValuePart constructor.
+part = PropertyValuePart.fromToken(tokenStream.token());
+}
+this._readWhitespace();
+} else {
+//see if it's a color
+token = this._hexcolor();
+if (token === null) {
+//if there's no unary, get the start of the next token for line/col info
+if (unary === null) {
+line = tokenStream.LT(1).startLine;
+col = tokenStream.LT(1).startCol;
+}
+//has to be a function
+if (value === null) {
+/*
+* This checks for alpha(opacity=0) style of IE
+* functions. IE_FUNCTION only presents progid: style.
+*/
+if (tokenStream.LA(3) === Tokens.EQUALS && this.options.ieFilters) {
+value = this._ie_function();
+} else {
+value = this._function();
+}
+}
+/*if (value === null) {
+return null;
+//throw new Error("Expected identifier at line " + tokenStream.token().startLine + ", character " +  tokenStream.token().startCol + ".");
+}*/
+} else {
+value = token.value;
+if (unary === null) {
+line = token.startLine;
+col = token.startCol;
+}
+}
+}
+return part !== null ? part : value !== null ?
+new PropertyValuePart(unary !== null ? unary + value : value, line, col) :
+null;
+},
+_function: function() {
+/*
+* function
+*   : FUNCTION S* expr ')' S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+functionText = null,
+expr        = null,
+lt;
+if (tokenStream.match(Tokens.FUNCTION)) {
+functionText = tokenStream.token().value;
+this._readWhitespace();
+expr = this._expr(true);
+functionText += expr;
+//START: Horrible hack in case it's an IE filter
+if (this.options.ieFilters && tokenStream.peek() === Tokens.EQUALS) {
+do {
+if (this._readWhitespace()) {
+functionText += tokenStream.token().value;
+}
+//might be second time in the loop
+if (tokenStream.LA(0) === Tokens.COMMA) {
+functionText += tokenStream.token().value;
+}
+tokenStream.match(Tokens.IDENT);
+functionText += tokenStream.token().value;
+tokenStream.match(Tokens.EQUALS);
+functionText += tokenStream.token().value;
+//functionText += this._term();
+lt = tokenStream.peek();
+while (lt !== Tokens.COMMA && lt !== Tokens.S && lt !== Tokens.RPAREN) {
+tokenStream.get();
+functionText += tokenStream.token().value;
+lt = tokenStream.peek();
+}
+} while (tokenStream.match([Tokens.COMMA, Tokens.S]));
+}
+//END: Horrible Hack
+tokenStream.match(Tokens.RPAREN);
+functionText += ")";
+this._readWhitespace();
+}
+return functionText;
+},
+_ie_function: function() {
+/* (My own extension)
+* ie_function
+*   : IE_FUNCTION S* IDENT '=' term [S* ','? IDENT '=' term]+ ')' S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+functionText = null,
+lt;
+//IE function can begin like a regular function, too
+if (tokenStream.match([Tokens.IE_FUNCTION, Tokens.FUNCTION])) {
+functionText = tokenStream.token().value;
+do {
+if (this._readWhitespace()) {
+functionText += tokenStream.token().value;
+}
+//might be second time in the loop
+if (tokenStream.LA(0) === Tokens.COMMA) {
+functionText += tokenStream.token().value;
+}
+tokenStream.match(Tokens.IDENT);
+functionText += tokenStream.token().value;
+tokenStream.match(Tokens.EQUALS);
+functionText += tokenStream.token().value;
+//functionText += this._term();
+lt = tokenStream.peek();
+while (lt !== Tokens.COMMA && lt !== Tokens.S && lt !== Tokens.RPAREN) {
+tokenStream.get();
+functionText += tokenStream.token().value;
+lt = tokenStream.peek();
+}
+} while (tokenStream.match([Tokens.COMMA, Tokens.S]));
+tokenStream.match(Tokens.RPAREN);
+functionText += ")";
+this._readWhitespace();
+}
+return functionText;
+},
+_hexcolor: function() {
+/*
+* There is a constraint on the color that it must
+* have either 3 or 6 hex-digits (i.e., [0-9a-fA-F])
+* after the "#"; e.g., "#000" is OK, but "#abcd" is not.
+*
+* hexcolor
+*   : HASH S*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+token = null,
+color;
+if (tokenStream.match(Tokens.HASH)) {
+//need to do some validation here
+token = tokenStream.token();
+color = token.value;
+if (!/#[a-f0-9]{3,6}/i.test(color)) {
+throw new SyntaxError("Expected a hex color but found '" + color + "' at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
+}
+this._readWhitespace();
+}
+return token;
+},
+//-----------------------------------------------------------------
+// Animations methods
+//-----------------------------------------------------------------
+_keyframes: function() {
+/*
+* keyframes:
+*   : KEYFRAMES_SYM S* keyframe_name S* '{' S* keyframe_rule* '}' {
+*   ;
+*/
+var tokenStream = this._tokenStream,
+token,
+tt,
+name,
+prefix = "";
+tokenStream.mustMatch(Tokens.KEYFRAMES_SYM);
+token = tokenStream.token();
+if (/^@\-([^\-]+)\-/.test(token.value)) {
+prefix = RegExp.$1;
+}
+this._readWhitespace();
+name = this._keyframe_name();
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.LBRACE);
+this.fire({
+type:   "startkeyframes",
+name:   name,
+prefix: prefix,
+line:   token.startLine,
+col:    token.startCol
+});
+this._readWhitespace();
+tt = tokenStream.peek();
+//check for key
+while (tt === Tokens.IDENT || tt === Tokens.PERCENTAGE) {
+this._keyframe_rule();
+this._readWhitespace();
+tt = tokenStream.peek();
+}
+this.fire({
+type:   "endkeyframes",
+name:   name,
+prefix: prefix,
+line:   token.startLine,
+col:    token.startCol
+});
+this._readWhitespace();
+tokenStream.mustMatch(Tokens.RBRACE);
+this._readWhitespace();
+},
+_keyframe_name: function() {
+/*
+* keyframe_name:
+*   : IDENT
+*   | STRING
+*   ;
+*/
+var tokenStream = this._tokenStream;
+tokenStream.mustMatch([Tokens.IDENT, Tokens.STRING]);
+return SyntaxUnit.fromToken(tokenStream.token());
+},
+_keyframe_rule: function() {
+/*
+* keyframe_rule:
+*   : key_list S*
+*     '{' S* declaration [ ';' S* declaration ]* '}' S*
+*   ;
+*/
+var keyList = this._key_list();
+this.fire({
+type:   "startkeyframerule",
+keys:   keyList,
+line:   keyList[0].line,
+col:    keyList[0].col
+});
+this._readDeclarations(true);
+this.fire({
+type:   "endkeyframerule",
+keys:   keyList,
+line:   keyList[0].line,
+col:    keyList[0].col
+});
+},
+_key_list: function() {
+/*
+* key_list:
+*   : key [ S* ',' S* key]*
+*   ;
+*/
+var tokenStream = this._tokenStream,
+keyList = [];
+//must be least one key
+keyList.push(this._key());
+this._readWhitespace();
+while (tokenStream.match(Tokens.COMMA)) {
+this._readWhitespace();
+keyList.push(this._key());
+this._readWhitespace();
+}
+return keyList;
+},
+_key: function() {
+/*
+* There is a restriction that IDENT can be only "from" or "to".
+*
+* key
+*   : PERCENTAGE
+*   | IDENT
+*   ;
+*/
+var tokenStream = this._tokenStream,
+token;
+if (tokenStream.match(Tokens.PERCENTAGE)) {
+return SyntaxUnit.fromToken(tokenStream.token());
+} else if (tokenStream.match(Tokens.IDENT)) {
+token = tokenStream.token();
+if (/from|to/i.test(token.value)) {
+return SyntaxUnit.fromToken(token);
+}
+tokenStream.unget();
+}
+//if it gets here, there wasn't a valid token, so time to explode
+this._unexpectedToken(tokenStream.LT(1));
+},
+//-----------------------------------------------------------------
+// Helper methods
+//-----------------------------------------------------------------
+/**
+* Not part of CSS grammar, but useful for skipping over
+* combination of white space and HTML-style comments.
+* @return {void}
+* @method _skipCruft
+* @private
+*/
+_skipCruft: function() {
+while (this._tokenStream.match([Tokens.S, Tokens.CDO, Tokens.CDC])) {
+//noop
+}
+},
+/**
+* Not part of CSS grammar, but this pattern occurs frequently
+* in the official CSS grammar. Split out here to eliminate
+* duplicate code.
+* @param {Boolean} checkStart Indicates if the rule should check
+*      for the left brace at the beginning.
+* @param {Boolean} readMargins Indicates if the rule should check
+*      for margin patterns.
+* @return {void}
+* @method _readDeclarations
+* @private
+*/
+_readDeclarations: function(checkStart, readMargins) {
+/*
+* Reads the pattern
+* S* '{' S* declaration [ ';' S* declaration ]* '}' S*
+* or
+* S* '{' S* [ declaration | margin ]? [ ';' S* [ declaration | margin ]? ]* '}' S*
+* Note that this is how it is described in CSS3 Paged Media, but is actually incorrect.
+* A semicolon is only necessary following a declaration if there's another declaration
+* or margin afterwards.
+*/
+var tokenStream = this._tokenStream,
+tt;
+this._readWhitespace();
+if (checkStart) {
+tokenStream.mustMatch(Tokens.LBRACE);
+}
+this._readWhitespace();
+try {
+while (true) {
+if (tokenStream.match(Tokens.SEMICOLON) || (readMargins && this._margin())) {
+//noop
+} else if (this._declaration()) {
+if (!tokenStream.match(Tokens.SEMICOLON)) {
+break;
+}
+} else {
+break;
+}
+//if ((!this._margin() && !this._declaration()) || !tokenStream.match(Tokens.SEMICOLON)){
+//    break;
+//}
+this._readWhitespace();
+}
+tokenStream.mustMatch(Tokens.RBRACE);
+this._readWhitespace();
+} catch (ex) {
+if (ex instanceof SyntaxError && !this.options.strict) {
+//fire error event
+this.fire({
+type:       "error",
+error:      ex,
+message:    ex.message,
+line:       ex.line,
+col:        ex.col
+});
+//see if there's another declaration
+tt = tokenStream.advance([Tokens.SEMICOLON, Tokens.RBRACE]);
+if (tt === Tokens.SEMICOLON) {
+//if there's a semicolon, then there might be another declaration
+this._readDeclarations(false, readMargins);
+} else if (tt !== Tokens.RBRACE) {
+//if there's a right brace, the rule is finished so don't do anything
+//otherwise, rethrow the error because it wasn't handled properly
+throw ex;
+}
+} else {
+//not a syntax error, rethrow it
+throw ex;
+}
+}
+},
+/**
+* In some cases, you can end up with two white space tokens in a
+* row. Instead of making a change in every function that looks for
+* white space, this function is used to match as much white space
+* as necessary.
+* @method _readWhitespace
+* @return {String} The white space if found, empty string if not.
+* @private
+*/
+_readWhitespace: function() {
+var tokenStream = this._tokenStream,
+ws = "";
+while (tokenStream.match(Tokens.S)) {
+ws += tokenStream.token().value;
+}
+return ws;
+},
+/**
+* Throws an error when an unexpected token is found.
+* @param {Object} token The token that was found.
+* @method _unexpectedToken
+* @return {void}
+* @private
+*/
+_unexpectedToken: function(token) {
+throw new SyntaxError("Unexpected token '" + token.value + "' at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
+},
+/**
+* Helper method used for parsing subparts of a style sheet.
+* @return {void}
+* @method _verifyEnd
+* @private
+*/
+_verifyEnd: function() {
+if (this._tokenStream.LA(1) !== Tokens.EOF) {
+this._unexpectedToken(this._tokenStream.LT(1));
+}
+},
+//-----------------------------------------------------------------
+// Validation methods
+//-----------------------------------------------------------------
+_validateProperty: function(property, value) {
+Validation.validate(property, value);
+},
+//-----------------------------------------------------------------
+// Parsing methods
+//-----------------------------------------------------------------
+parse: function(input) {
+this._tokenStream = new TokenStream(input, Tokens);
+this._stylesheet();
+},
+parseStyleSheet: function(input) {
+//just passthrough
+return this.parse(input);
+},
+parseMediaQuery: function(input) {
+this._tokenStream = new TokenStream(input, Tokens);
+var result = this._media_query();
+//if there's anything more, then it's an invalid selector
+this._verifyEnd();
+//otherwise return result
+return result;
+},
+/**
+* Parses a property value (everything after the semicolon).
+* @return {parserlib.css.PropertyValue} The property value.
+* @throws parserlib.util.SyntaxError If an unexpected token is found.
+* @method parserPropertyValue
+*/
+parsePropertyValue: function(input) {
+this._tokenStream = new TokenStream(input, Tokens);
+this._readWhitespace();
+var result = this._expr();
+//okay to have a trailing white space
+this._readWhitespace();
+//if there's anything more, then it's an invalid selector
+this._verifyEnd();
+//otherwise return result
+return result;
+},
+/**
+* Parses a complete CSS rule, including selectors and
+* properties.
+* @param {String} input The text to parser.
+* @return {Boolean} True if the parse completed successfully, false if not.
+* @method parseRule
+*/
+parseRule: function(input) {
+this._tokenStream = new TokenStream(input, Tokens);
+//skip any leading white space
+this._readWhitespace();
+var result = this._ruleset();
+//skip any trailing white space
+this._readWhitespace();
+//if there's anything more, then it's an invalid selector
+this._verifyEnd();
+//otherwise return result
+return result;
+},
+/**
+* Parses a single CSS selector (no comma)
+* @param {String} input The text to parse as a CSS selector.
+* @return {Selector} An object representing the selector.
+* @throws parserlib.util.SyntaxError If an unexpected token is found.
+* @method parseSelector
+*/
+parseSelector: function(input) {
+this._tokenStream = new TokenStream(input, Tokens);
+//skip any leading white space
+this._readWhitespace();
+var result = this._selector();
+//skip any trailing white space
+this._readWhitespace();
+//if there's anything more, then it's an invalid selector
+this._verifyEnd();
+//otherwise return result
+return result;
+},
+/**
+* Parses an HTML style attribute: a set of CSS declarations
+* separated by semicolons.
+* @param {String} input The text to parse as a style attribute
+* @return {void}
+* @method parseStyleAttribute
+*/
+parseStyleAttribute: function(input) {
+input += "}"; // for error recovery in _readDeclarations()
+this._tokenStream = new TokenStream(input, Tokens);
+this._readDeclarations();
+}
+};
+//copy over onto prototype
+for (prop in additions) {
+if (Object.prototype.hasOwnProperty.call(additions, prop)) {
+proto[prop] = additions[prop];
+}
+}
+return proto;
+}();
+/*
+nth
+: S* [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]? |
+['-'|'+']? INTEGER | {O}{D}{D} | {E}{V}{E}{N} ] S*
+;
+*/
+},{"../util/EventTarget":23,"../util/SyntaxError":25,"../util/SyntaxUnit":26,"./Combinator":2,"./MediaFeature":4,"./MediaQuery":5,"./PropertyName":8,"./PropertyValue":9,"./PropertyValuePart":11,"./Selector":13,"./SelectorPart":14,"./SelectorSubPart":15,"./TokenStream":17,"./Tokens":18,"./Validation":19}],7:[function(require,module,exports){
+"use strict";
+/* exported Properties */
+var Properties = module.exports = {
+__proto__: null,
+//A
+"align-items"                   : "flex-start | flex-end | center | baseline | stretch",
+"align-content"                 : "flex-start | flex-end | center | space-between | space-around | stretch",
+"align-self"                    : "auto | flex-start | flex-end | center | baseline | stretch",
+"all"                           : "initial | inherit | unset",
+"-webkit-align-items"           : "flex-start | flex-end | center | baseline | stretch",
+"-webkit-align-content"         : "flex-start | flex-end | center | space-between | space-around | stretch",
+"-webkit-align-self"            : "auto | flex-start | flex-end | center | baseline | stretch",
+"alignment-adjust"              : "auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical | <percentage> | <length>",
+"alignment-baseline"            : "auto | baseline | use-script | before-edge | text-before-edge | after-edge | text-after-edge | central | middle | ideographic | alphabetic | hanging | mathematical",
+"animation"                     : 1,
+"animation-delay"               : "<time>#",
+"animation-direction"           : "<single-animation-direction>#",
+"animation-duration"            : "<time>#",
+"animation-fill-mode"           : "[ none | forwards | backwards | both ]#",
+"animation-iteration-count"     : "[ <number> | infinite ]#",
+"animation-name"                : "[ none | <single-animation-name> ]#",
+"animation-play-state"          : "[ running | paused ]#",
+"animation-timing-function"     : 1,
+//vendor prefixed
+"-moz-animation-delay"               : "<time>#",
+"-moz-animation-direction"           : "[ normal | alternate ]#",
+"-moz-animation-duration"            : "<time>#",
+"-moz-animation-iteration-count"     : "[ <number> | infinite ]#",
+"-moz-animation-name"                : "[ none | <single-animation-name> ]#",
+"-moz-animation-play-state"          : "[ running | paused ]#",
+"-ms-animation-delay"               : "<time>#",
+"-ms-animation-direction"           : "[ normal | alternate ]#",
+"-ms-animation-duration"            : "<time>#",
+"-ms-animation-iteration-count"     : "[ <number> | infinite ]#",
+"-ms-animation-name"                : "[ none | <single-animation-name> ]#",
+"-ms-animation-play-state"          : "[ running | paused ]#",
+"-webkit-animation-delay"               : "<time>#",
+"-webkit-animation-direction"           : "[ normal | alternate ]#",
+"-webkit-animation-duration"            : "<time>#",
+"-webkit-animation-fill-mode"           : "[ none | forwards | backwards | both ]#",
+"-webkit-animation-iteration-count"     : "[ <number> | infinite ]#",
+"-webkit-animation-name"                : "[ none | <single-animation-name> ]#",
+"-webkit-animation-play-state"          : "[ running | paused ]#",
+"-o-animation-delay"               : "<time>#",
+"-o-animation-direction"           : "[ normal | alternate ]#",
+"-o-animation-duration"            : "<time>#",
+"-o-animation-iteration-count"     : "[ <number> | infinite ]#",
+"-o-animation-name"                : "[ none | <single-animation-name> ]#",
+"-o-animation-play-state"          : "[ running | paused ]#",
+"appearance"                    : "none | auto",
+"-moz-appearance"               : "none | button | button-arrow-down | button-arrow-next | button-arrow-previous | button-arrow-up | button-bevel | button-focus | caret | checkbox | checkbox-container | checkbox-label | checkmenuitem | dualbutton | groupbox | listbox | listitem | menuarrow | menubar | menucheckbox | menuimage | menuitem | menuitemtext | menulist | menulist-button | menulist-text | menulist-textfield | menupopup | menuradio | menuseparator | meterbar | meterchunk | progressbar | progressbar-vertical | progresschunk | progresschunk-vertical | radio | radio-container | radio-label | radiomenuitem | range | range-thumb | resizer | resizerpanel | scale-horizontal | scalethumbend | scalethumb-horizontal | scalethumbstart | scalethumbtick | scalethumb-vertical | scale-vertical | scrollbarbutton-down | scrollbarbutton-left | scrollbarbutton-right | scrollbarbutton-up | scrollbarthumb-horizontal | scrollbarthumb-vertical | scrollbartrack-horizontal | scrollbartrack-vertical | searchfield | separator | sheet | spinner | spinner-downbutton | spinner-textfield | spinner-upbutton | splitter | statusbar | statusbarpanel | tab | tabpanel | tabpanels | tab-scroll-arrow-back | tab-scroll-arrow-forward | textfield | textfield-multiline | toolbar | toolbarbutton | toolbarbutton-dropdown | toolbargripper | toolbox | tooltip | treeheader | treeheadercell | treeheadersortarrow | treeitem | treeline | treetwisty | treetwistyopen | treeview | -moz-mac-unified-toolbar | -moz-win-borderless-glass | -moz-win-browsertabbar-toolbox | -moz-win-communicationstext | -moz-win-communications-toolbox | -moz-win-exclude-glass | -moz-win-glass | -moz-win-mediatext | -moz-win-media-toolbox | -moz-window-button-box | -moz-window-button-box-maximized | -moz-window-button-close | -moz-window-button-maximize | -moz-window-button-minimize | -moz-window-button-restore | -moz-window-frame-bottom | -moz-window-frame-left | -moz-window-frame-right | -moz-window-titlebar | -moz-window-titlebar-maximized",
+"-ms-appearance"                : "none | icon | window | desktop | workspace | document | tooltip | dialog | button | push-button | hyperlink | radio | radio-button | checkbox | menu-item | tab | menu | menubar | pull-down-menu | pop-up-menu | list-menu | radio-group | checkbox-group | outline-tree | range | field | combo-box | signature | password | normal",
+"-webkit-appearance"            : "none | button | button-bevel | caps-lock-indicator | caret | checkbox | default-button | listbox	| listitem | media-fullscreen-button | media-mute-button | media-play-button | media-seek-back-button	| media-seek-forward-button	| media-slider | media-sliderthumb | menulist	| menulist-button	| menulist-text	| menulist-textfield | push-button	| radio	| searchfield	| searchfield-cancel-button	| searchfield-decoration | searchfield-results-button | searchfield-results-decoration | slider-horizontal | slider-vertical | sliderthumb-horizontal | sliderthumb-vertical	| square-button	| textarea	| textfield	| scrollbarbutton-down | scrollbarbutton-left | scrollbarbutton-right | scrollbarbutton-up | scrollbargripper-horizontal | scrollbargripper-vertical | scrollbarthumb-horizontal | scrollbarthumb-vertical | scrollbartrack-horizontal | scrollbartrack-vertical",
+"-o-appearance"                 : "none | window | desktop | workspace | document | tooltip | dialog | button | push-button | hyperlink | radio | radio-button | checkbox | menu-item | tab | menu | menubar | pull-down-menu | pop-up-menu | list-menu | radio-group | checkbox-group | outline-tree | range | field | combo-box | signature | password | normal",
+"azimuth"                       : "<azimuth>",
+//B
+"backface-visibility"           : "visible | hidden",
+"background"                    : 1,
+"background-attachment"         : "<attachment>#",
+"background-clip"               : "<box>#",
+"background-color"              : "<color>",
+"background-image"              : "<bg-image>#",
+"background-origin"             : "<box>#",
+"background-position"           : "<bg-position>",
+"background-repeat"             : "<repeat-style>#",
+"background-size"               : "<bg-size>#",
+"baseline-shift"                : "baseline | sub | super | <percentage> | <length>",
+"behavior"                      : 1,
+"binding"                       : 1,
+"bleed"                         : "<length>",
+"bookmark-label"                : "<content> | <attr> | <string>",
+"bookmark-level"                : "none | <integer>",
+"bookmark-state"                : "open | closed",
+"bookmark-target"               : "none | <uri> | <attr>",
+"border"                        : "<border-width> || <border-style> || <color>",
+"border-bottom"                 : "<border-width> || <border-style> || <color>",
+"border-bottom-color"           : "<color>",
+"border-bottom-left-radius"     :  "<x-one-radius>",
+"border-bottom-right-radius"    :  "<x-one-radius>",
+"border-bottom-style"           : "<border-style>",
+"border-bottom-width"           : "<border-width>",
+"border-collapse"               : "collapse | separate",
+"border-color"                  : "<color>{1,4}",
+"border-image"                  : 1,
+"border-image-outset"           : "[ <length> | <number> ]{1,4}",
+"border-image-repeat"           : "[ stretch | repeat | round ]{1,2}",
+"border-image-slice"            : "<border-image-slice>",
+"border-image-source"           : "<image> | none",
+"border-image-width"            : "[ <length> | <percentage> | <number> | auto ]{1,4}",
+"border-left"                   : "<border-width> || <border-style> || <color>",
+"border-left-color"             : "<color>",
+"border-left-style"             : "<border-style>",
+"border-left-width"             : "<border-width>",
+"border-radius"                 : "<border-radius>",
+"border-right"                  : "<border-width> || <border-style> || <color>",
+"border-right-color"            : "<color>",
+"border-right-style"            : "<border-style>",
+"border-right-width"            : "<border-width>",
+"border-spacing"                : "<length>{1,2}",
+"border-style"                  : "<border-style>{1,4}",
+"border-top"                    : "<border-width> || <border-style> || <color>",
+"border-top-color"              : "<color>",
+"border-top-left-radius"        : "<x-one-radius>",
+"border-top-right-radius"       : "<x-one-radius>",
+"border-top-style"              : "<border-style>",
+"border-top-width"              : "<border-width>",
+"border-width"                  : "<border-width>{1,4}",
+"bottom"                        : "<margin-width>",
+"-moz-box-align"                : "start | end | center | baseline | stretch",
+"-moz-box-decoration-break"     : "slice | clone",
+"-moz-box-direction"            : "normal | reverse",
+"-moz-box-flex"                 : "<number>",
+"-moz-box-flex-group"           : "<integer>",
+"-moz-box-lines"                : "single | multiple",
+"-moz-box-ordinal-group"        : "<integer>",
+"-moz-box-orient"               : "horizontal | vertical | inline-axis | block-axis",
+"-moz-box-pack"                 : "start | end | center | justify",
+"-o-box-decoration-break"       : "slice | clone",
+"-webkit-box-align"             : "start | end | center | baseline | stretch",
+"-webkit-box-decoration-break"  : "slice | clone",
+"-webkit-box-direction"         : "normal | reverse",
+"-webkit-box-flex"              : "<number>",
+"-webkit-box-flex-group"        : "<integer>",
+"-webkit-box-lines"             : "single | multiple",
+"-webkit-box-ordinal-group"     : "<integer>",
+"-webkit-box-orient"            : "horizontal | vertical | inline-axis | block-axis",
+"-webkit-box-pack"              : "start | end | center | justify",
+"box-decoration-break"          : "slice | clone",
+"box-shadow"                    : "<box-shadow>",
+"box-sizing"                    : "content-box | border-box",
+"break-after"                   : "auto | always | avoid | left | right | page | column | avoid-page | avoid-column",
+"break-before"                  : "auto | always | avoid | left | right | page | column | avoid-page | avoid-column",
+"break-inside"                  : "auto | avoid | avoid-page | avoid-column",
+//C
+"caption-side"                  : "top | bottom",
+"clear"                         : "none | right | left | both",
+"clip"                          : "<shape> | auto",
+"-webkit-clip-path"             : "<clip-source> | <clip-path> | none",
+"clip-path"                     : "<clip-source> | <clip-path> | none",
+"clip-rule"                     : "nonzero | evenodd",
+"color"                         : "<color>",
+"color-interpolation"           : "auto | sRGB | linearRGB",
+"color-interpolation-filters"   : "auto | sRGB | linearRGB",
+"color-profile"                 : 1,
+"color-rendering"               : "auto | optimizeSpeed | optimizeQuality",
+"column-count"                  : "<integer> | auto",                      //https://www.w3.org/TR/css3-multicol/
+"column-fill"                   : "auto | balance",
+"column-gap"                    : "<length> | normal",
+"column-rule"                   : "<border-width> || <border-style> || <color>",
+"column-rule-color"             : "<color>",
+"column-rule-style"             : "<border-style>",
+"column-rule-width"             : "<border-width>",
+"column-span"                   : "none | all",
+"column-width"                  : "<length> | auto",
+"columns"                       : 1,
+"content"                       : 1,
+"counter-increment"             : 1,
+"counter-reset"                 : 1,
+"crop"                          : "<shape> | auto",
+"cue"                           : "cue-after | cue-before",
+"cue-after"                     : 1,
+"cue-before"                    : 1,
+"cursor"                        : 1,
+//D
+"direction"                     : "ltr | rtl",
+"display"                       : "inline | block | list-item | inline-block | table | inline-table | table-row-group | table-header-group | table-footer-group | table-row | table-column-group | table-column | table-cell | table-caption | grid | inline-grid | run-in | ruby | ruby-base | ruby-text | ruby-base-container | ruby-text-container | contents | none | -moz-box | -moz-inline-block | -moz-inline-box | -moz-inline-grid | -moz-inline-stack | -moz-inline-table | -moz-grid | -moz-grid-group | -moz-grid-line | -moz-groupbox | -moz-deck | -moz-popup | -moz-stack | -moz-marker | -webkit-box | -webkit-inline-box | -ms-flexbox | -ms-inline-flexbox | flex | -webkit-flex | inline-flex | -webkit-inline-flex",
+"dominant-baseline"             : "auto | use-script | no-change | reset-size | ideographic | alphabetic | hanging | mathematical | central | middle | text-after-edge | text-before-edge",
+"drop-initial-after-adjust"     : "central | middle | after-edge | text-after-edge | ideographic | alphabetic | mathematical | <percentage> | <length>",
+"drop-initial-after-align"      : "baseline | use-script | before-edge | text-before-edge | after-edge | text-after-edge | central | middle | ideographic | alphabetic | hanging | mathematical",
+"drop-initial-before-adjust"    : "before-edge | text-before-edge | central | middle | hanging | mathematical | <percentage> | <length>",
+"drop-initial-before-align"     : "caps-height | baseline | use-script | before-edge | text-before-edge | after-edge | text-after-edge | central | middle | ideographic | alphabetic | hanging | mathematical",
+"drop-initial-size"             : "auto | line | <length> | <percentage>",
+"drop-initial-value"            : "<integer>",
+//E
+"elevation"                     : "<angle> | below | level | above | higher | lower",
+"empty-cells"                   : "show | hide",
+"enable-background"             : 1,
+//F
+"fill"                          : "<paint>",
+"fill-opacity"                  : "<opacity-value>",
+"fill-rule"                     : "nonzero | evenodd",
+"filter"                        : "<filter-function-list> | none",
+"fit"                           : "fill | hidden | meet | slice",
+"fit-position"                  : 1,
+"flex"                          : "<flex>",
+"flex-basis"                    : "<width>",
+"flex-direction"                : "row | row-reverse | column | column-reverse",
+"flex-flow"                     : "<flex-direction> || <flex-wrap>",
+"flex-grow"                     : "<number>",
+"flex-shrink"                   : "<number>",
+"flex-wrap"                     : "nowrap | wrap | wrap-reverse",
+"-webkit-flex"                  : "<flex>",
+"-webkit-flex-basis"            : "<width>",
+"-webkit-flex-direction"        : "row | row-reverse | column | column-reverse",
+"-webkit-flex-flow"             : "<flex-direction> || <flex-wrap>",
+"-webkit-flex-grow"             : "<number>",
+"-webkit-flex-shrink"           : "<number>",
+"-webkit-flex-wrap"             : "nowrap | wrap | wrap-reverse",
+"-ms-flex"                      : "<flex>",
+"-ms-flex-align"                : "start | end | center | stretch | baseline",
+"-ms-flex-direction"            : "row | row-reverse | column | column-reverse",
+"-ms-flex-order"                : "<number>",
+"-ms-flex-pack"                 : "start | end | center | justify",
+"-ms-flex-wrap"                 : "nowrap | wrap | wrap-reverse",
+"float"                         : "left | right | none",
+"float-offset"                  : 1,
+"flood-color"                   : 1,
+"flood-opacity"                 : "<opacity-value>",
+"font"                          : "<font-shorthand> | caption | icon | menu | message-box | small-caption | status-bar",
+"font-family"                   : "<font-family>",
+"font-feature-settings"         : "<feature-tag-value> | normal",
+"font-kerning"                  : "auto | normal | none",
+"font-size"                     : "<font-size>",
+"font-size-adjust"              : "<number> | none",
+"font-stretch"                  : "<font-stretch>",
+"font-style"                    : "<font-style>",
+"font-variant"                  : "<font-variant> | normal | none",
+"font-variant-alternates"       : "<font-variant-alternates> | normal",
+"font-variant-caps"             : "<font-variant-caps> | normal",
+"font-variant-east-asian"       : "<font-variant-east-asian> | normal",
+"font-variant-ligatures"        : "<font-variant-ligatures> | normal | none",
+"font-variant-numeric"          : "<font-variant-numeric> | normal",
+"font-variant-position"         : "normal | sub | super",
+"font-weight"                   : "<font-weight>",
+//G
+"glyph-orientation-horizontal"  : "<glyph-angle>",
+"glyph-orientation-vertical"    : "auto | <glyph-angle>",
+"grid"                          : 1,
+"grid-area"                     : 1,
+"grid-auto-columns"             : 1,
+"grid-auto-flow"                : 1,
+"grid-auto-position"            : 1,
+"grid-auto-rows"                : 1,
+"grid-cell-stacking"            : "columns | rows | layer",
+"grid-column"                   : 1,
+"grid-columns"                  : 1,
+"grid-column-align"             : "start | end | center | stretch",
+"grid-column-sizing"            : 1,
+"grid-column-start"             : 1,
+"grid-column-end"               : 1,
+"grid-column-span"              : "<integer>",
+"grid-flow"                     : "none | rows | columns",
+"grid-layer"                    : "<integer>",
+"grid-row"                      : 1,
+"grid-rows"                     : 1,
+"grid-row-align"                : "start | end | center | stretch",
+"grid-row-start"                : 1,
+"grid-row-end"                  : 1,
+"grid-row-span"                 : "<integer>",
+"grid-row-sizing"               : 1,
+"grid-template"                 : 1,
+"grid-template-areas"           : 1,
+"grid-template-columns"         : 1,
+"grid-template-rows"            : 1,
+//H
+"hanging-punctuation"           : 1,
+"height"                        : "<margin-width> | <content-sizing>",
+"hyphenate-after"               : "<integer> | auto",
+"hyphenate-before"              : "<integer> | auto",
+"hyphenate-character"           : "<string> | auto",
+"hyphenate-lines"               : "no-limit | <integer>",
+"hyphenate-resource"            : 1,
+"hyphens"                       : "none | manual | auto",
+//I
+"icon"                          : 1,
+"image-orientation"             : "angle | auto",
+"image-rendering"               : "auto | optimizeSpeed | optimizeQuality",
+"image-resolution"              : 1,
+"ime-mode"                      : "auto | normal | active | inactive | disabled",
+"inline-box-align"              : "last | <integer>",
+//J
+"justify-content"               : "flex-start | flex-end | center | space-between | space-around",
+"-webkit-justify-content"       : "flex-start | flex-end | center | space-between | space-around",
+//K
+"kerning"                       : "auto | <length>",
+//L
+"left"                          : "<margin-width>",
+"letter-spacing"                : "<length> | normal",
+"line-height"                   : "<line-height>",
+"line-break"                    : "auto | loose | normal | strict",
+"line-stacking"                 : 1,
+"line-stacking-ruby"            : "exclude-ruby | include-ruby",
+"line-stacking-shift"           : "consider-shifts | disregard-shifts",
+"line-stacking-strategy"        : "inline-line-height | block-line-height | max-height | grid-height",
+"list-style"                    : 1,
+"list-style-image"              : "<uri> | none",
+"list-style-position"           : "inside | outside",
+"list-style-type"               : "disc | circle | square | decimal | decimal-leading-zero | lower-roman | upper-roman | lower-greek | lower-latin | upper-latin | armenian | georgian | lower-alpha | upper-alpha | none",
+//M
+"margin"                        : "<margin-width>{1,4}",
+"margin-bottom"                 : "<margin-width>",
+"margin-left"                   : "<margin-width>",
+"margin-right"                  : "<margin-width>",
+"margin-top"                    : "<margin-width>",
+"mark"                          : 1,
+"mark-after"                    : 1,
+"mark-before"                   : 1,
+"marker"                        : 1,
+"marker-end"                    : 1,
+"marker-mid"                    : 1,
+"marker-start"                  : 1,
+"marks"                         : 1,
+"marquee-direction"             : 1,
+"marquee-play-count"            : 1,
+"marquee-speed"                 : 1,
+"marquee-style"                 : 1,
+"mask"                          : 1,
+"max-height"                    : "<length> | <percentage> | <content-sizing> | none",
+"max-width"                     : "<length> | <percentage> | <content-sizing> | none",
+"min-height"                    : "<length> | <percentage> | <content-sizing> | contain-floats | -moz-contain-floats | -webkit-contain-floats",
+"min-width"                     : "<length> | <percentage> | <content-sizing> | contain-floats | -moz-contain-floats | -webkit-contain-floats",
+"move-to"                       : 1,
+//N
+"nav-down"                      : 1,
+"nav-index"                     : 1,
+"nav-left"                      : 1,
+"nav-right"                     : 1,
+"nav-up"                        : 1,
+//O
+"object-fit"                    : "fill | contain | cover | none | scale-down",
+"object-position"               : "<position>",
+"opacity"                       : "<opacity-value>",
+"order"                         : "<integer>",
+"-webkit-order"                 : "<integer>",
+"orphans"                       : "<integer>",
+"outline"                       : 1,
+"outline-color"                 : "<color> | invert",
+"outline-offset"                : 1,
+"outline-style"                 : "<border-style>",
+"outline-width"                 : "<border-width>",
+"overflow"                      : "visible | hidden | scroll | auto",
+"overflow-style"                : 1,
+"overflow-wrap"                 : "normal | break-word",
+"overflow-x"                    : 1,
+"overflow-y"                    : 1,
+//P
+"padding"                       : "<padding-width>{1,4}",
+"padding-bottom"                : "<padding-width>",
+"padding-left"                  : "<padding-width>",
+"padding-right"                 : "<padding-width>",
+"padding-top"                   : "<padding-width>",
+"page"                          : 1,
+"page-break-after"              : "auto | always | avoid | left | right",
+"page-break-before"             : "auto | always | avoid | left | right",
+"page-break-inside"             : "auto | avoid",
+"page-policy"                   : 1,
+"pause"                         : 1,
+"pause-after"                   : 1,
+"pause-before"                  : 1,
+"perspective"                   : 1,
+"perspective-origin"            : 1,
+"phonemes"                      : 1,
+"pitch"                         : 1,
+"pitch-range"                   : 1,
+"play-during"                   : 1,
+"pointer-events"                : "auto | none | visiblePainted | visibleFill | visibleStroke | visible | painted | fill | stroke | all",
+"position"                      : "static | relative | absolute | fixed",
+"presentation-level"            : 1,
+"punctuation-trim"              : 1,
+//Q
+"quotes"                        : 1,
+//R
+"rendering-intent"              : 1,
+"resize"                        : 1,
+"rest"                          : 1,
+"rest-after"                    : 1,
+"rest-before"                   : 1,
+"richness"                      : 1,
+"right"                         : "<margin-width>",
+"rotation"                      : 1,
+"rotation-point"                : 1,
+"ruby-align"                    : 1,
+"ruby-overhang"                 : 1,
+"ruby-position"                 : 1,
+"ruby-span"                     : 1,
+//S
+"shape-rendering"               : "auto | optimizeSpeed | crispEdges | geometricPrecision",
+"size"                          : 1,
+"speak"                         : "normal | none | spell-out",
+"speak-header"                  : "once | always",
+"speak-numeral"                 : "digits | continuous",
+"speak-punctuation"             : "code | none",
+"speech-rate"                   : 1,
+"src"                           : 1,
+"stop-color"                    : 1,
+"stop-opacity"                  : "<opacity-value>",
+"stress"                        : 1,
+"string-set"                    : 1,
+"stroke"                        : "<paint>",
+"stroke-dasharray"              : "none | <dasharray>",
+"stroke-dashoffset"             : "<percentage> | <length>",
+"stroke-linecap"                : "butt | round | square",
+"stroke-linejoin"               : "miter | round | bevel",
+"stroke-miterlimit"             : "<miterlimit>",
+"stroke-opacity"                : "<opacity-value>",
+"stroke-width"                  : "<percentage> | <length>",
+"table-layout"                  : "auto | fixed",
+"tab-size"                      : "<integer> | <length>",
+"target"                        : 1,
+"target-name"                   : 1,
+"target-new"                    : 1,
+"target-position"               : 1,
+"text-align"                    : "left | right | center | justify | match-parent | start | end",
+"text-align-last"               : 1,
+"text-anchor"                   : "start | middle | end",
+"text-decoration"               : "<text-decoration-line> || <text-decoration-style> || <text-decoration-color>",
+"text-decoration-color"         : "<text-decoration-color>",
+"text-decoration-line"          : "<text-decoration-line>",
+"text-decoration-style"         : "<text-decoration-style>",
+"text-emphasis"                 : 1,
+"text-height"                   : 1,
+"text-indent"                   : "<length> | <percentage>",
+"text-justify"                  : "auto | none | inter-word | inter-ideograph | inter-cluster | distribute | kashida",
+"text-outline"                  : 1,
+"text-overflow"                 : 1,
+"text-rendering"                : "auto | optimizeSpeed | optimizeLegibility | geometricPrecision",
+"text-shadow"                   : 1,
+"text-transform"                : "capitalize | uppercase | lowercase | none",
+"text-wrap"                     : "normal | none | avoid",
+"top"                           : "<margin-width>",
+"-ms-touch-action"              : "auto | none | pan-x | pan-y | pan-left | pan-right | pan-up | pan-down | manipulation",
+"touch-action"                  : "auto | none | pan-x | pan-y | pan-left | pan-right | pan-up | pan-down | manipulation",
+"transform"                     : 1,
+"transform-origin"              : 1,
+"transform-style"               : 1,
+"transition"                    : 1,
+"transition-delay"              : 1,
+"transition-duration"           : 1,
+"transition-property"           : 1,
+"transition-timing-function"    : 1,
+//U
+"unicode-bidi"                  : "normal | embed | isolate | bidi-override | isolate-override | plaintext",
+"user-modify"                   : "read-only | read-write | write-only",
+"user-select"                   : "none | text | toggle | element | elements | all",
+//V
+"vertical-align"                : "auto | use-script | baseline | sub | super | top | text-top | central | middle | bottom | text-bottom | <percentage> | <length>",
+"visibility"                    : "visible | hidden | collapse",
+"voice-balance"                 : 1,
+"voice-duration"                : 1,
+"voice-family"                  : 1,
+"voice-pitch"                   : 1,
+"voice-pitch-range"             : 1,
+"voice-rate"                    : 1,
+"voice-stress"                  : 1,
+"voice-volume"                  : 1,
+"volume"                        : 1,
+//W
+"white-space"                   : "normal | pre | nowrap | pre-wrap | pre-line | -pre-wrap | -o-pre-wrap | -moz-pre-wrap | -hp-pre-wrap",   // https://perishablepress.com/wrapping-content/
+"white-space-collapse"          : 1,
+"widows"                        : "<integer>",
+"width"                         : "<length> | <percentage> | <content-sizing> | auto",
+"will-change"                   : "<will-change>",
+"word-break"                    : "normal | keep-all | break-all",
+"word-spacing"                  : "<length> | normal",
+"word-wrap"                     : "normal | break-word",
+"writing-mode"                  : "horizontal-tb | vertical-rl | vertical-lr | lr-tb | rl-tb | tb-rl | bt-rl | tb-lr | bt-lr | lr-bt | rl-bt | lr | rl | tb",
+//Z
+"z-index"                       : "<integer> | auto",
+"zoom"                          : "<number> | <percentage> | normal"
+};
+},{}],8:[function(require,module,exports){
+"use strict";
+module.exports = PropertyName;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents a selector combinator (whitespace, +, >).
+* @namespace parserlib.css
+* @class PropertyName
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {String} text The text representation of the unit.
+* @param {String} hack The type of IE hack applied ("*", "_", or null).
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function PropertyName(text, hack, line, col) {
+SyntaxUnit.call(this, text, line, col, Parser.PROPERTY_NAME_TYPE);
+/**
+* The type of IE hack applied ("*", "_", or null).
+* @type String
+* @property hack
+*/
+this.hack = hack;
+}
+PropertyName.prototype = new SyntaxUnit();
+PropertyName.prototype.constructor = PropertyName;
+PropertyName.prototype.toString = function() {
+return (this.hack ? this.hack : "") + this.text;
+};
+},{"../util/SyntaxUnit":26,"./Parser":6}],9:[function(require,module,exports){
+"use strict";
+module.exports = PropertyValue;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents a single part of a CSS property value, meaning that it represents
+* just everything single part between ":" and ";". If there are multiple values
+* separated by commas, this type represents just one of the values.
+* @param {String[]} parts An array of value parts making up this value.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+* @namespace parserlib.css
+* @class PropertyValue
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+*/
+function PropertyValue(parts, line, col) {
+SyntaxUnit.call(this, parts.join(" "), line, col, Parser.PROPERTY_VALUE_TYPE);
+/**
+* The parts that make up the selector.
+* @type Array
+* @property parts
+*/
+this.parts = parts;
+}
+PropertyValue.prototype = new SyntaxUnit();
+PropertyValue.prototype.constructor = PropertyValue;
+},{"../util/SyntaxUnit":26,"./Parser":6}],10:[function(require,module,exports){
+"use strict";
+module.exports = PropertyValueIterator;
+/**
+* A utility class that allows for easy iteration over the various parts of a
+* property value.
+* @param {parserlib.css.PropertyValue} value The property value to iterate over.
+* @namespace parserlib.css
+* @class PropertyValueIterator
+* @constructor
+*/
+function PropertyValueIterator(value) {
+/**
+* Iterator value
+* @type int
+* @property _i
+* @private
+*/
+this._i = 0;
+/**
+* The parts that make up the value.
+* @type Array
+* @property _parts
+* @private
+*/
+this._parts = value.parts;
+/**
+* Keeps track of bookmarks along the way.
+* @type Array
+* @property _marks
+* @private
+*/
+this._marks = [];
+/**
+* Holds the original property value.
+* @type parserlib.css.PropertyValue
+* @property value
+*/
+this.value = value;
+}
+/**
+* Returns the total number of parts in the value.
+* @return {int} The total number of parts in the value.
+* @method count
+*/
+PropertyValueIterator.prototype.count = function() {
+return this._parts.length;
+};
+/**
+* Indicates if the iterator is positioned at the first item.
+* @return {Boolean} True if positioned at first item, false if not.
+* @method isFirst
+*/
+PropertyValueIterator.prototype.isFirst = function() {
+return this._i === 0;
+};
+/**
+* Indicates if there are more parts of the property value.
+* @return {Boolean} True if there are more parts, false if not.
+* @method hasNext
+*/
+PropertyValueIterator.prototype.hasNext = function() {
+return this._i < this._parts.length;
+};
+/**
+* Marks the current spot in the iteration so it can be restored to
+* later on.
+* @return {void}
+* @method mark
+*/
+PropertyValueIterator.prototype.mark = function() {
+this._marks.push(this._i);
+};
+/**
+* Returns the next part of the property value or null if there is no next
+* part. Does not move the internal counter forward.
+* @return {parserlib.css.PropertyValuePart} The next part of the property value or null if there is no next
+* part.
+* @method peek
+*/
+PropertyValueIterator.prototype.peek = function(count) {
+return this.hasNext() ? this._parts[this._i + (count || 0)] : null;
+};
+/**
+* Returns the next part of the property value or null if there is no next
+* part.
+* @return {parserlib.css.PropertyValuePart} The next part of the property value or null if there is no next
+* part.
+* @method next
+*/
+PropertyValueIterator.prototype.next = function() {
+return this.hasNext() ? this._parts[this._i++] : null;
+};
+/**
+* Returns the previous part of the property value or null if there is no
+* previous part.
+* @return {parserlib.css.PropertyValuePart} The previous part of the
+* property value or null if there is no previous part.
+* @method previous
+*/
+PropertyValueIterator.prototype.previous = function() {
+return this._i > 0 ? this._parts[--this._i] : null;
+};
+/**
+* Restores the last saved bookmark.
+* @return {void}
+* @method restore
+*/
+PropertyValueIterator.prototype.restore = function() {
+if (this._marks.length) {
+this._i = this._marks.pop();
+}
+};
+/**
+* Drops the last saved bookmark.
+* @return {void}
+* @method drop
+*/
+PropertyValueIterator.prototype.drop = function() {
+this._marks.pop();
+};
+},{}],11:[function(require,module,exports){
+"use strict";
+module.exports = PropertyValuePart;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Colors = require("./Colors");
+var Parser = require("./Parser");
+var Tokens = require("./Tokens");
+/**
+* Represents a single part of a CSS property value, meaning that it represents
+* just one part of the data between ":" and ";".
+* @param {String} text The text representation of the unit.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+* @namespace parserlib.css
+* @class PropertyValuePart
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+*/
+function PropertyValuePart(text, line, col, optionalHint) {
+var hint = optionalHint || {};
+SyntaxUnit.call(this, text, line, col, Parser.PROPERTY_VALUE_PART_TYPE);
+/**
+* Indicates the type of value unit.
+* @type String
+* @property type
+*/
+this.type = "unknown";
+//figure out what type of data it is
+var temp;
+//it is a measurement?
+if (/^([+\-]?[\d\.]+)([a-z]+)$/i.test(text)) {  //dimension
+this.type = "dimension";
+this.value = +RegExp.$1;
+this.units = RegExp.$2;
+//try to narrow down
+switch (this.units.toLowerCase()) {
+case "em":
+case "rem":
+case "ex":
+case "px":
+case "cm":
+case "mm":
+case "in":
+case "pt":
+case "pc":
+case "ch":
+case "vh":
+case "vw":
+case "vmax":
+case "vmin":
+this.type = "length";
+break;
+case "fr":
+this.type = "grid";
+break;
+case "deg":
+case "rad":
+case "grad":
+case "turn":
+this.type = "angle";
+break;
+case "ms":
+case "s":
+this.type = "time";
+break;
+case "hz":
+case "khz":
+this.type = "frequency";
+break;
+case "dpi":
+case "dpcm":
+this.type = "resolution";
+break;
+//default
+}
+} else if (/^([+\-]?[\d\.]+)%$/i.test(text)) {  //percentage
+this.type = "percentage";
+this.value = +RegExp.$1;
+} else if (/^([+\-]?\d+)$/i.test(text)) {  //integer
+this.type = "integer";
+this.value = +RegExp.$1;
+} else if (/^([+\-]?[\d\.]+)$/i.test(text)) {  //number
+this.type = "number";
+this.value = +RegExp.$1;
+} else if (/^#([a-f0-9]{3,6})/i.test(text)) {  //hexcolor
+this.type = "color";
+temp = RegExp.$1;
+if (temp.length === 3) {
+this.red    = parseInt(temp.charAt(0)+temp.charAt(0), 16);
+this.green  = parseInt(temp.charAt(1)+temp.charAt(1), 16);
+this.blue   = parseInt(temp.charAt(2)+temp.charAt(2), 16);
+} else {
+this.red    = parseInt(temp.substring(0, 2), 16);
+this.green  = parseInt(temp.substring(2, 4), 16);
+this.blue   = parseInt(temp.substring(4, 6), 16);
+}
+} else if (/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/i.test(text)) { //rgb() color with absolute numbers
+this.type   = "color";
+this.red    = +RegExp.$1;
+this.green  = +RegExp.$2;
+this.blue   = +RegExp.$3;
+} else if (/^rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)/i.test(text)) { //rgb() color with percentages
+this.type   = "color";
+this.red    = +RegExp.$1 * 255 / 100;
+this.green  = +RegExp.$2 * 255 / 100;
+this.blue   = +RegExp.$3 * 255 / 100;
+} else if (/^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d\.]+)\s*\)/i.test(text)) { //rgba() color with absolute numbers
+this.type   = "color";
+this.red    = +RegExp.$1;
+this.green  = +RegExp.$2;
+this.blue   = +RegExp.$3;
+this.alpha  = +RegExp.$4;
+} else if (/^rgba\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*,\s*([\d\.]+)\s*\)/i.test(text)) { //rgba() color with percentages
+this.type   = "color";
+this.red    = +RegExp.$1 * 255 / 100;
+this.green  = +RegExp.$2 * 255 / 100;
+this.blue   = +RegExp.$3 * 255 / 100;
+this.alpha  = +RegExp.$4;
+} else if (/^hsl\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)/i.test(text)) { //hsl()
+this.type   = "color";
+this.hue    = +RegExp.$1;
+this.saturation = +RegExp.$2 / 100;
+this.lightness  = +RegExp.$3 / 100;
+} else if (/^hsla\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*,\s*([\d\.]+)\s*\)/i.test(text)) { //hsla() color with percentages
+this.type   = "color";
+this.hue    = +RegExp.$1;
+this.saturation = +RegExp.$2 / 100;
+this.lightness  = +RegExp.$3 / 100;
+this.alpha  = +RegExp.$4;
+} else if (/^url\(("([^\\"]|\\.)*")\)/i.test(text)) { //URI
+// generated by TokenStream.readURI, so always double-quoted.
+this.type   = "uri";
+this.uri    = PropertyValuePart.parseString(RegExp.$1);
+} else if (/^([^\(]+)\(/i.test(text)) {
+this.type   = "function";
+this.name   = RegExp.$1;
+this.value  = text;
+} else if (/^"([^\n\r\f\\"]|\\\r\n|\\[^\r0-9a-f]|\\[0-9a-f]{1,6}(\r\n|[ \n\r\t\f])?)*"/i.test(text)) {    //double-quoted string
+this.type   = "string";
+this.value  = PropertyValuePart.parseString(text);
+} else if (/^'([^\n\r\f\\']|\\\r\n|\\[^\r0-9a-f]|\\[0-9a-f]{1,6}(\r\n|[ \n\r\t\f])?)*'/i.test(text)) {    //single-quoted string
+this.type   = "string";
+this.value  = PropertyValuePart.parseString(text);
+} else if (Colors[text.toLowerCase()]) {  //named color
+this.type   = "color";
+temp        = Colors[text.toLowerCase()].substring(1);
+this.red    = parseInt(temp.substring(0, 2), 16);
+this.green  = parseInt(temp.substring(2, 4), 16);
+this.blue   = parseInt(temp.substring(4, 6), 16);
+} else if (/^[,\/]$/.test(text)) {
+this.type   = "operator";
+this.value  = text;
+} else if (/^-?[a-z_\u00A0-\uFFFF][a-z0-9\-_\u00A0-\uFFFF]*$/i.test(text)) {
+this.type   = "identifier";
+this.value  = text;
+}
+// There can be ambiguity with escape sequences in identifiers, as
+// well as with "color" parts which are also "identifiers", so record
+// an explicit hint when the token generating this PropertyValuePart
+// was an identifier.
+this.wasIdent = Boolean(hint.ident);
+}
+PropertyValuePart.prototype = new SyntaxUnit();
+PropertyValuePart.prototype.constructor = PropertyValuePart;
+/**
+* Helper method to parse a CSS string.
+*/
+PropertyValuePart.parseString = function(str) {
+str = str.slice(1, -1); // Strip surrounding single/double quotes
+var replacer = function(match, esc) {
+if (/^(\n|\r\n|\r|\f)$/.test(esc)) {
+return "";
+}
+var m = /^[0-9a-f]{1,6}/i.exec(esc);
+if (m) {
+var codePoint = parseInt(m[0], 16);
+if (String.fromCodePoint) {
+return String.fromCodePoint(codePoint);
+} else {
+// XXX No support for surrogates on old JavaScript engines.
+return String.fromCharCode(codePoint);
+}
+}
+return esc;
+};
+return str.replace(/\\(\r\n|[^\r0-9a-f]|[0-9a-f]{1,6}(\r\n|[ \n\r\t\f])?)/ig,
+replacer);
+};
+/**
+* Helper method to serialize a CSS string.
+*/
+PropertyValuePart.serializeString = function(value) {
+var replacer = function(match, c) {
+if (c === "\"") {
+return "\\" + c;
+}
+var cp = String.codePointAt ? String.codePointAt(0) :
+// We only escape non-surrogate chars, so using charCodeAt
+// is harmless here.
+String.charCodeAt(0);
+return "\\" + cp.toString(16) + " ";
+};
+return "\"" + value.replace(/["\r\n\f]/g, replacer) + "\"";
+};
+/**
+* Create a new syntax unit based solely on the given token.
+* Convenience method for creating a new syntax unit when
+* it represents a single token instead of multiple.
+* @param {Object} token The token object to represent.
+* @return {parserlib.css.PropertyValuePart} The object representing the token.
+* @static
+* @method fromToken
+*/
+PropertyValuePart.fromToken = function(token) {
+var part = new PropertyValuePart(token.value, token.startLine, token.startCol, {
+// Tokens can have escaped characters that would fool the type
+// identification in the PropertyValuePart constructor, so pass
+// in a hint if this was an identifier.
+ident: token.type === Tokens.IDENT
+});
+return part;
+};
+},{"../util/SyntaxUnit":26,"./Colors":1,"./Parser":6,"./Tokens":18}],12:[function(require,module,exports){
+"use strict";
+var Pseudos = module.exports = {
+__proto__:       null,
+":first-letter": 1,
+":first-line":   1,
+":before":       1,
+":after":        1
+};
+Pseudos.ELEMENT = 1;
+Pseudos.CLASS = 2;
+Pseudos.isElement = function(pseudo) {
+return pseudo.indexOf("::") === 0 || Pseudos[pseudo.toLowerCase()] === Pseudos.ELEMENT;
+};
+},{}],13:[function(require,module,exports){
+"use strict";
+module.exports = Selector;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+var Specificity = require("./Specificity");
+/**
+* Represents an entire single selector, including all parts but not
+* including multiple selectors (those separated by commas).
+* @namespace parserlib.css
+* @class Selector
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {Array} parts Array of selectors parts making up this selector.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function Selector(parts, line, col) {
+SyntaxUnit.call(this, parts.join(" "), line, col, Parser.SELECTOR_TYPE);
+/**
+* The parts that make up the selector.
+* @type Array
+* @property parts
+*/
+this.parts = parts;
+/**
+* The specificity of the selector.
+* @type parserlib.css.Specificity
+* @property specificity
+*/
+this.specificity = Specificity.calculate(this);
+}
+Selector.prototype = new SyntaxUnit();
+Selector.prototype.constructor = Selector;
+},{"../util/SyntaxUnit":26,"./Parser":6,"./Specificity":16}],14:[function(require,module,exports){
+"use strict";
+module.exports = SelectorPart;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents a single part of a selector string, meaning a single set of
+* element name and modifiers. This does not include combinators such as
+* spaces, +, >, etc.
+* @namespace parserlib.css
+* @class SelectorPart
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {String} elementName The element name in the selector or null
+*      if there is no element name.
+* @param {Array} modifiers Array of individual modifiers for the element.
+*      May be empty if there are none.
+* @param {String} text The text representation of the unit.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function SelectorPart(elementName, modifiers, text, line, col) {
+SyntaxUnit.call(this, text, line, col, Parser.SELECTOR_PART_TYPE);
+/**
+* The tag name of the element to which this part
+* of the selector affects.
+* @type String
+* @property elementName
+*/
+this.elementName = elementName;
+/**
+* The parts that come after the element name, such as class names, IDs,
+* pseudo classes/elements, etc.
+* @type Array
+* @property modifiers
+*/
+this.modifiers = modifiers;
+}
+SelectorPart.prototype = new SyntaxUnit();
+SelectorPart.prototype.constructor = SelectorPart;
+},{"../util/SyntaxUnit":26,"./Parser":6}],15:[function(require,module,exports){
+"use strict";
+module.exports = SelectorSubPart;
+var SyntaxUnit = require("../util/SyntaxUnit");
+var Parser = require("./Parser");
+/**
+* Represents a selector modifier string, meaning a class name, element name,
+* element ID, pseudo rule, etc.
+* @namespace parserlib.css
+* @class SelectorSubPart
+* @extends parserlib.util.SyntaxUnit
+* @constructor
+* @param {String} text The text representation of the unit.
+* @param {String} type The type of selector modifier.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function SelectorSubPart(text, type, line, col) {
+SyntaxUnit.call(this, text, line, col, Parser.SELECTOR_SUB_PART_TYPE);
+/**
+* The type of modifier.
+* @type String
+* @property type
+*/
+this.type = type;
+/**
+* Some subparts have arguments, this represents them.
+* @type Array
+* @property args
+*/
+this.args = [];
+}
+SelectorSubPart.prototype = new SyntaxUnit();
+SelectorSubPart.prototype.constructor = SelectorSubPart;
+},{"../util/SyntaxUnit":26,"./Parser":6}],16:[function(require,module,exports){
+"use strict";
+module.exports = Specificity;
+var Pseudos = require("./Pseudos");
+var SelectorPart = require("./SelectorPart");
+/**
+* Represents a selector's specificity.
+* @namespace parserlib.css
+* @class Specificity
+* @constructor
+* @param {int} a Should be 1 for inline styles, zero for stylesheet styles
+* @param {int} b Number of ID selectors
+* @param {int} c Number of classes and pseudo classes
+* @param {int} d Number of element names and pseudo elements
+*/
+function Specificity(a, b, c, d) {
+this.a = a;
+this.b = b;
+this.c = c;
+this.d = d;
+}
+Specificity.prototype = {
+constructor: Specificity,
+/**
+* Compare this specificity to another.
+* @param {Specificity} other The other specificity to compare to.
+* @return {int} -1 if the other specificity is larger, 1 if smaller, 0 if equal.
+* @method compare
+*/
+compare: function(other) {
+var comps = ["a", "b", "c", "d"],
+i, len;
+for (i=0, len=comps.length; i < len; i++) {
+if (this[comps[i]] < other[comps[i]]) {
+return -1;
+} else if (this[comps[i]] > other[comps[i]]) {
+return 1;
+}
+}
+return 0;
+},
+/**
+* Creates a numeric value for the specificity.
+* @return {int} The numeric value for the specificity.
+* @method valueOf
+*/
+valueOf: function() {
+return (this.a * 1000) + (this.b * 100) + (this.c * 10) + this.d;
+},
+/**
+* Returns a string representation for specificity.
+* @return {String} The string representation of specificity.
+* @method toString
+*/
+toString: function() {
+return this.a + "," + this.b + "," + this.c + "," + this.d;
+}
+};
+/**
+* Calculates the specificity of the given selector.
+* @param {parserlib.css.Selector} The selector to calculate specificity for.
+* @return {parserlib.css.Specificity} The specificity of the selector.
+* @static
+* @method calculate
+*/
+Specificity.calculate = function(selector) {
+var i, len,
+part,
+b=0, c=0, d=0;
+function updateValues(part) {
+var i, j, len, num,
+elementName = part.elementName ? part.elementName.text : "",
+modifier;
+if (elementName && elementName.charAt(elementName.length-1) !== "*") {
+d++;
+}
+for (i=0, len=part.modifiers.length; i < len; i++) {
+modifier = part.modifiers[i];
+switch (modifier.type) {
+case "class":
+case "attribute":
+c++;
+break;
+case "id":
+b++;
+break;
+case "pseudo":
+if (Pseudos.isElement(modifier.text)) {
+d++;
+} else {
+c++;
+}
+break;
+case "not":
+for (j=0, num=modifier.args.length; j < num; j++) {
+updateValues(modifier.args[j]);
+}
+}
+}
+}
+for (i=0, len=selector.parts.length; i < len; i++) {
+part = selector.parts[i];
+if (part instanceof SelectorPart) {
+updateValues(part);
+}
+}
+return new Specificity(0, b, c, d);
+};
+},{"./Pseudos":12,"./SelectorPart":14}],17:[function(require,module,exports){
+"use strict";
+module.exports = TokenStream;
+var TokenStreamBase = require("../util/TokenStreamBase");
+var PropertyValuePart = require("./PropertyValuePart");
+var Tokens = require("./Tokens");
+var h = /^[0-9a-fA-F]$/,
+nonascii = /^[\u00A0-\uFFFF]$/,
+nl = /\n|\r\n|\r|\f/,
+whitespace = /\u0009|\u000a|\u000c|\u000d|\u0020/;
+//-----------------------------------------------------------------------------
+// Helper functions
+//-----------------------------------------------------------------------------
+function isHexDigit(c) {
+return c !== null && h.test(c);
+}
+function isDigit(c) {
+return c !== null && /\d/.test(c);
+}
+function isWhitespace(c) {
+return c !== null && whitespace.test(c);
+}
+function isNewLine(c) {
+return c !== null && nl.test(c);
+}
+function isNameStart(c) {
+return c !== null && /[a-z_\u00A0-\uFFFF\\]/i.test(c);
+}
+function isNameChar(c) {
+return c !== null && (isNameStart(c) || /[0-9\-\\]/.test(c));
+}
+function isIdentStart(c) {
+return c !== null && (isNameStart(c) || /\-\\/.test(c));
+}
+function mix(receiver, supplier) {
+for (var prop in supplier) {
+if (Object.prototype.hasOwnProperty.call(supplier, prop)) {
+receiver[prop] = supplier[prop];
+}
+}
+return receiver;
+}
+//-----------------------------------------------------------------------------
+// CSS Token Stream
+//-----------------------------------------------------------------------------
+/**
+* A token stream that produces CSS tokens.
+* @param {String|Reader} input The source of text to tokenize.
+* @constructor
+* @class TokenStream
+* @namespace parserlib.css
+*/
+function TokenStream(input) {
+TokenStreamBase.call(this, input, Tokens);
+}
+TokenStream.prototype = mix(new TokenStreamBase(), {
+/**
+* Overrides the TokenStreamBase method of the same name
+* to produce CSS tokens.
+* @return {Object} A token object representing the next token.
+* @method _getToken
+* @private
+*/
+_getToken: function() {
+var c,
+reader = this._reader,
+token   = null,
+startLine   = reader.getLine(),
+startCol    = reader.getCol();
+c = reader.read();
+while (c) {
+switch (c) {
+/*
+* Potential tokens:
+* - COMMENT
+* - SLASH
+* - CHAR
+*/
+case "/":
+if (reader.peek() === "*") {
+token = this.commentToken(c, startLine, startCol);
+} else {
+token = this.charToken(c, startLine, startCol);
+}
+break;
+/*
+* Potential tokens:
+* - DASHMATCH
+* - INCLUDES
+* - PREFIXMATCH
+* - SUFFIXMATCH
+* - SUBSTRINGMATCH
+* - CHAR
+*/
+case "|":
+case "~":
+case "^":
+case "$":
+case "*":
+if (reader.peek() === "=") {
+token = this.comparisonToken(c, startLine, startCol);
+} else {
+token = this.charToken(c, startLine, startCol);
+}
+break;
+/*
+* Potential tokens:
+* - STRING
+* - INVALID
+*/
+case "\"":
+case "'":
+token = this.stringToken(c, startLine, startCol);
+break;
+/*
+* Potential tokens:
+* - HASH
+* - CHAR
+*/
+case "#":
+if (isNameChar(reader.peek())) {
+token = this.hashToken(c, startLine, startCol);
+} else {
+token = this.charToken(c, startLine, startCol);
+}
+break;
+/*
+* Potential tokens:
+* - DOT
+* - NUMBER
+* - DIMENSION
+* - PERCENTAGE
+*/
+case ".":
+if (isDigit(reader.peek())) {
+token = this.numberToken(c, startLine, startCol);
+} else {
+token = this.charToken(c, startLine, startCol);
+}
+break;
+/*
+* Potential tokens:
+* - CDC
+* - MINUS
+* - NUMBER
+* - DIMENSION
+* - PERCENTAGE
+*/
+case "-":
+if (reader.peek() === "-") {  //could be closing HTML-style comment
+token = this.htmlCommentEndToken(c, startLine, startCol);
+} else if (isNameStart(reader.peek())) {
+token = this.identOrFunctionToken(c, startLine, startCol);
+} else {
+token = this.charToken(c, startLine, startCol);
+}
+break;
+/*
+* Potential tokens:
+* - IMPORTANT_SYM
+* - CHAR
+*/
+case "!":
+token = this.importantToken(c, startLine, startCol);
+break;
+/*
+* Any at-keyword or CHAR
+*/
+case "@":
+token = this.atRuleToken(c, startLine, startCol);
+break;
+/*
+* Potential tokens:
+* - NOT
+* - CHAR
+*/
+case ":":
+token = this.notToken(c, startLine, startCol);
+break;
+/*
+* Potential tokens:
+* - CDO
+* - CHAR
+*/
+case "<":
+token = this.htmlCommentStartToken(c, startLine, startCol);
+break;
+/*
+* Potential tokens:
+* - IDENT
+* - CHAR
+*/
+case "\\":
+if (/[^\r\n\f]/.test(reader.peek())) {
+token = this.identOrFunctionToken(this.readEscape(c, true), startLine, startCol);
+} else {
+token = this.charToken(c, startLine, startCol);
+}
+break;
+/*
+* Potential tokens:
+* - UNICODE_RANGE
+* - URL
+* - CHAR
+*/
+case "U":
+case "u":
+if (reader.peek() === "+") {
+token = this.unicodeRangeToken(c, startLine, startCol);
+break;
+}
+/* falls through */
+default:
+/*
+* Potential tokens:
+* - NUMBER
+* - DIMENSION
+* - LENGTH
+* - FREQ
+* - TIME
+* - EMS
+* - EXS
+* - ANGLE
+*/
+if (isDigit(c)) {
+token = this.numberToken(c, startLine, startCol);
+} else
+/*
+* Potential tokens:
+* - S
+*/
+if (isWhitespace(c)) {
+token = this.whitespaceToken(c, startLine, startCol);
+} else
+/*
+* Potential tokens:
+* - IDENT
+*/
+if (isIdentStart(c)) {
+token = this.identOrFunctionToken(c, startLine, startCol);
+} else {
+/*
+* Potential tokens:
+* - CHAR
+* - PLUS
+*/
+token = this.charToken(c, startLine, startCol);
+}
+}
+//make sure this token is wanted
+//TODO: check channel
+break;
+}
+if (!token && c === null) {
+token = this.createToken(Tokens.EOF, null, startLine, startCol);
+}
+return token;
+},
+//-------------------------------------------------------------------------
+// Methods to create tokens
+//-------------------------------------------------------------------------
+/**
+* Produces a token based on available data and the current
+* reader position information. This method is called by other
+* private methods to create tokens and is never called directly.
+* @param {int} tt The token type.
+* @param {String} value The text value of the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @param {Object} options (Optional) Specifies a channel property
+*      to indicate that a different channel should be scanned
+*      and/or a hide property indicating that the token should
+*      be hidden.
+* @return {Object} A token object.
+* @method createToken
+*/
+createToken: function(tt, value, startLine, startCol, options) {
+var reader = this._reader;
+options = options || {};
+return {
+value:      value,
+type:       tt,
+channel:    options.channel,
+endChar:    options.endChar,
+hide:       options.hide || false,
+startLine:  startLine,
+startCol:   startCol,
+endLine:    reader.getLine(),
+endCol:     reader.getCol()
+};
+},
+//-------------------------------------------------------------------------
+// Methods to create specific tokens
+//-------------------------------------------------------------------------
+/**
+* Produces a token for any at-rule. If the at-rule is unknown, then
+* the token is for a single "@" character.
+* @param {String} first The first character for the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method atRuleToken
+*/
+atRuleToken: function(first, startLine, startCol) {
+var rule    = first,
+reader  = this._reader,
+tt      = Tokens.CHAR,
+ident;
+/*
+* First, mark where we are. There are only four @ rules,
+* so anything else is really just an invalid token.
+* Basically, if this doesn't match one of the known @
+* rules, just return '@' as an unknown token and allow
+* parsing to continue after that point.
+*/
+reader.mark();
+//try to find the at-keyword
+ident = this.readName();
+rule = first + ident;
+tt = Tokens.type(rule.toLowerCase());
+//if it's not valid, use the first character only and reset the reader
+if (tt === Tokens.CHAR || tt === Tokens.UNKNOWN) {
+if (rule.length > 1) {
+tt = Tokens.UNKNOWN_SYM;
+} else {
+tt = Tokens.CHAR;
+rule = first;
+reader.reset();
+}
+}
+return this.createToken(tt, rule, startLine, startCol);
+},
+/**
+* Produces a character token based on the given character
+* and location in the stream. If there's a special (non-standard)
+* token name, this is used; otherwise CHAR is used.
+* @param {String} c The character for the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method charToken
+*/
+charToken: function(c, startLine, startCol) {
+var tt = Tokens.type(c);
+var opts = {};
+if (tt === -1) {
+tt = Tokens.CHAR;
+} else {
+opts.endChar = Tokens[tt].endChar;
+}
+return this.createToken(tt, c, startLine, startCol, opts);
+},
+/**
+* Produces a character token based on the given character
+* and location in the stream. If there's a special (non-standard)
+* token name, this is used; otherwise CHAR is used.
+* @param {String} first The first character for the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method commentToken
+*/
+commentToken: function(first, startLine, startCol) {
+var comment = this.readComment(first);
+return this.createToken(Tokens.COMMENT, comment, startLine, startCol);
+},
+/**
+* Produces a comparison token based on the given character
+* and location in the stream. The next character must be
+* read and is already known to be an equals sign.
+* @param {String} c The character for the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method comparisonToken
+*/
+comparisonToken: function(c, startLine, startCol) {
+var reader  = this._reader,
+comparison  = c + reader.read(),
+tt      = Tokens.type(comparison) || Tokens.CHAR;
+return this.createToken(tt, comparison, startLine, startCol);
+},
+/**
+* Produces a hash token based on the specified information. The
+* first character provided is the pound sign (#) and then this
+* method reads a name afterward.
+* @param {String} first The first character (#) in the hash name.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method hashToken
+*/
+hashToken: function(first, startLine, startCol) {
+var name    = this.readName(first);
+return this.createToken(Tokens.HASH, name, startLine, startCol);
+},
+/**
+* Produces a CDO or CHAR token based on the specified information. The
+* first character is provided and the rest is read by the function to determine
+* the correct token to create.
+* @param {String} first The first character in the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method htmlCommentStartToken
+*/
+htmlCommentStartToken: function(first, startLine, startCol) {
+var reader      = this._reader,
+text        = first;
+reader.mark();
+text += reader.readCount(3);
+if (text === "<!--") {
+return this.createToken(Tokens.CDO, text, startLine, startCol);
+} else {
+reader.reset();
+return this.charToken(first, startLine, startCol);
+}
+},
+/**
+* Produces a CDC or CHAR token based on the specified information. The
+* first character is provided and the rest is read by the function to determine
+* the correct token to create.
+* @param {String} first The first character in the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method htmlCommentEndToken
+*/
+htmlCommentEndToken: function(first, startLine, startCol) {
+var reader      = this._reader,
+text        = first;
+reader.mark();
+text += reader.readCount(2);
+if (text === "-->") {
+return this.createToken(Tokens.CDC, text, startLine, startCol);
+} else {
+reader.reset();
+return this.charToken(first, startLine, startCol);
+}
+},
+/**
+* Produces an IDENT or FUNCTION token based on the specified information. The
+* first character is provided and the rest is read by the function to determine
+* the correct token to create.
+* @param {String} first The first character in the identifier.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method identOrFunctionToken
+*/
+identOrFunctionToken: function(first, startLine, startCol) {
+var reader  = this._reader,
+ident   = this.readName(first),
+tt      = Tokens.IDENT,
+uriFns  = ["url(", "url-prefix(", "domain("],
+uri;
+//if there's a left paren immediately after, it's a URI or function
+if (reader.peek() === "(") {
+ident += reader.read();
+if (uriFns.indexOf(ident.toLowerCase()) > -1) {
+reader.mark();
+uri = this.readURI(ident);
+if (uri === null) {
+//didn't find a valid URL or there's no closing paren
+reader.reset();
+tt = Tokens.FUNCTION;
+} else {
+tt = Tokens.URI;
+ident = uri;
+}
+} else {
+tt = Tokens.FUNCTION;
+}
+} else if (reader.peek() === ":") {  //might be an IE function
+//IE-specific functions always being with progid:
+if (ident.toLowerCase() === "progid") {
+ident += reader.readTo("(");
+tt = Tokens.IE_FUNCTION;
+}
+}
+return this.createToken(tt, ident, startLine, startCol);
+},
+/**
+* Produces an IMPORTANT_SYM or CHAR token based on the specified information. The
+* first character is provided and the rest is read by the function to determine
+* the correct token to create.
+* @param {String} first The first character in the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method importantToken
+*/
+importantToken: function(first, startLine, startCol) {
+var reader      = this._reader,
+important   = first,
+tt          = Tokens.CHAR,
+temp,
+c;
+reader.mark();
+c = reader.read();
+while (c) {
+//there can be a comment in here
+if (c === "/") {
+//if the next character isn't a star, then this isn't a valid !important token
+if (reader.peek() !== "*") {
+break;
+} else {
+temp = this.readComment(c);
+if (temp === "") {    //broken!
+break;
+}
+}
+} else if (isWhitespace(c)) {
+important += c + this.readWhitespace();
+} else if (/i/i.test(c)) {
+temp = reader.readCount(8);
+if (/mportant/i.test(temp)) {
+important += c + temp;
+tt = Tokens.IMPORTANT_SYM;
+}
+break;  //we're done
+} else {
+break;
+}
+c = reader.read();
+}
+if (tt === Tokens.CHAR) {
+reader.reset();
+return this.charToken(first, startLine, startCol);
+} else {
+return this.createToken(tt, important, startLine, startCol);
+}
+},
+/**
+* Produces a NOT or CHAR token based on the specified information. The
+* first character is provided and the rest is read by the function to determine
+* the correct token to create.
+* @param {String} first The first character in the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method notToken
+*/
+notToken: function(first, startLine, startCol) {
+var reader      = this._reader,
+text        = first;
+reader.mark();
+text += reader.readCount(4);
+if (text.toLowerCase() === ":not(") {
+return this.createToken(Tokens.NOT, text, startLine, startCol);
+} else {
+reader.reset();
+return this.charToken(first, startLine, startCol);
+}
+},
+/**
+* Produces a number token based on the given character
+* and location in the stream. This may return a token of
+* NUMBER, EMS, EXS, LENGTH, ANGLE, TIME, FREQ, DIMENSION,
+* or PERCENTAGE.
+* @param {String} first The first character for the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method numberToken
+*/
+numberToken: function(first, startLine, startCol) {
+var reader  = this._reader,
+value   = this.readNumber(first),
+ident,
+tt      = Tokens.NUMBER,
+c       = reader.peek();
+if (isIdentStart(c)) {
+ident = this.readName(reader.read());
+value += ident;
+if (/^em$|^ex$|^px$|^gd$|^rem$|^vw$|^vh$|^vmax$|^vmin$|^ch$|^cm$|^mm$|^in$|^pt$|^pc$/i.test(ident)) {
+tt = Tokens.LENGTH;
+} else if (/^deg|^rad$|^grad$|^turn$/i.test(ident)) {
+tt = Tokens.ANGLE;
+} else if (/^ms$|^s$/i.test(ident)) {
+tt = Tokens.TIME;
+} else if (/^hz$|^khz$/i.test(ident)) {
+tt = Tokens.FREQ;
+} else if (/^dpi$|^dpcm$/i.test(ident)) {
+tt = Tokens.RESOLUTION;
+} else {
+tt = Tokens.DIMENSION;
+}
+} else if (c === "%") {
+value += reader.read();
+tt = Tokens.PERCENTAGE;
+}
+return this.createToken(tt, value, startLine, startCol);
+},
+/**
+* Produces a string token based on the given character
+* and location in the stream. Since strings may be indicated
+* by single or double quotes, a failure to match starting
+* and ending quotes results in an INVALID token being generated.
+* The first character in the string is passed in and then
+* the rest are read up to and including the final quotation mark.
+* @param {String} first The first character in the string.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method stringToken
+*/
+stringToken: function(first, startLine, startCol) {
+var delim   = first,
+string  = first,
+reader  = this._reader,
+tt      = Tokens.STRING,
+c       = reader.read(),
+i;
+while (c) {
+string += c;
+if (c === "\\") {
+c = reader.read();
+if (c === null) {
+break; // premature EOF after backslash
+} else if (/[^\r\n\f0-9a-f]/i.test(c)) {
+// single-character escape
+string += c;
+} else {
+// read up to six hex digits
+for (i=0; isHexDigit(c) && i<6; i++) {
+string += c;
+c = reader.read();
+}
+// swallow trailing newline or space
+if (c === "\r" && reader.peek() === "\n") {
+string += c;
+c = reader.read();
+}
+if (isWhitespace(c)) {
+string += c;
+} else {
+// This character is null or not part of the escape;
+// jump back to the top to process it.
+continue;
+}
+}
+} else if (c === delim) {
+break; // delimiter found.
+} else if (isNewLine(reader.peek())) {
+// newline without an escapement: it's an invalid string
+tt = Tokens.INVALID;
+break;
+}
+c = reader.read();
+}
+//if c is null, that means we're out of input and the string was never closed
+if (c === null) {
+tt = Tokens.INVALID;
+}
+return this.createToken(tt, string, startLine, startCol);
+},
+unicodeRangeToken: function(first, startLine, startCol) {
+var reader  = this._reader,
+value   = first,
+temp,
+tt      = Tokens.CHAR;
+//then it should be a unicode range
+if (reader.peek() === "+") {
+reader.mark();
+value += reader.read();
+value += this.readUnicodeRangePart(true);
+//ensure there's an actual unicode range here
+if (value.length === 2) {
+reader.reset();
+} else {
+tt = Tokens.UNICODE_RANGE;
+//if there's a ? in the first part, there can't be a second part
+if (value.indexOf("?") === -1) {
+if (reader.peek() === "-") {
+reader.mark();
+temp = reader.read();
+temp += this.readUnicodeRangePart(false);
+//if there's not another value, back up and just take the first
+if (temp.length === 1) {
+reader.reset();
+} else {
+value += temp;
+}
+}
+}
+}
+}
+return this.createToken(tt, value, startLine, startCol);
+},
+/**
+* Produces a S token based on the specified information. Since whitespace
+* may have multiple characters, this consumes all whitespace characters
+* into a single token.
+* @param {String} first The first character in the token.
+* @param {int} startLine The beginning line for the character.
+* @param {int} startCol The beginning column for the character.
+* @return {Object} A token object.
+* @method whitespaceToken
+*/
+whitespaceToken: function(first, startLine, startCol) {
+var value   = first + this.readWhitespace();
+return this.createToken(Tokens.S, value, startLine, startCol);
+},
+//-------------------------------------------------------------------------
+// Methods to read values from the string stream
+//-------------------------------------------------------------------------
+readUnicodeRangePart: function(allowQuestionMark) {
+var reader  = this._reader,
+part = "",
+c       = reader.peek();
+//first read hex digits
+while (isHexDigit(c) && part.length < 6) {
+reader.read();
+part += c;
+c = reader.peek();
+}
+//then read question marks if allowed
+if (allowQuestionMark) {
+while (c === "?" && part.length < 6) {
+reader.read();
+part += c;
+c = reader.peek();
+}
+}
+//there can't be any other characters after this point
+return part;
+},
+readWhitespace: function() {
+var reader  = this._reader,
+whitespace = "",
+c       = reader.peek();
+while (isWhitespace(c)) {
+reader.read();
+whitespace += c;
+c = reader.peek();
+}
+return whitespace;
+},
+readNumber: function(first) {
+var reader  = this._reader,
+number  = first,
+hasDot  = (first === "."),
+c       = reader.peek();
+while (c) {
+if (isDigit(c)) {
+number += reader.read();
+} else if (c === ".") {
+if (hasDot) {
+break;
+} else {
+hasDot = true;
+number += reader.read();
+}
+} else {
+break;
+}
+c = reader.peek();
+}
+return number;
+},
+// returns null w/o resetting reader if string is invalid.
+readString: function() {
+var token = this.stringToken(this._reader.read(), 0, 0);
+return token.type === Tokens.INVALID ? null : token.value;
+},
+// returns null w/o resetting reader if URI is invalid.
+readURI: function(first) {
+var reader  = this._reader,
+uri     = first,
+inner   = "",
+c       = reader.peek();
+//skip whitespace before
+while (c && isWhitespace(c)) {
+reader.read();
+c = reader.peek();
+}
+//it's a string
+if (c === "'" || c === "\"") {
+inner = this.readString();
+if (inner !== null) {
+inner = PropertyValuePart.parseString(inner);
+}
+} else {
+inner = this.readUnquotedURL();
+}
+c = reader.peek();
+//skip whitespace after
+while (c && isWhitespace(c)) {
+reader.read();
+c = reader.peek();
+}
+//if there was no inner value or the next character isn't closing paren, it's not a URI
+if (inner === null || c !== ")") {
+uri = null;
+} else {
+// Ensure argument to URL is always double-quoted
+// (This simplifies later processing in PropertyValuePart.)
+uri += PropertyValuePart.serializeString(inner) + reader.read();
+}
+return uri;
+},
+// This method never fails, although it may return an empty string.
+readUnquotedURL: function(first) {
+var reader  = this._reader,
+url     = first || "",
+c;
+for (c = reader.peek(); c; c = reader.peek()) {
+// Note that the grammar at
+// https://www.w3.org/TR/CSS2/grammar.html#scanner
+// incorrectly includes the backslash character in the
+// `url` production, although it is correctly omitted in
+// the `baduri1` production.
+if (nonascii.test(c) || /^[\-!#$%&*-\[\]-~]$/.test(c)) {
+url += c;
+reader.read();
+} else if (c === "\\") {
+if (/^[^\r\n\f]$/.test(reader.peek(2))) {
+url += this.readEscape(reader.read(), true);
+} else {
+break; // bad escape sequence.
+}
+} else {
+break; // bad character
+}
+}
+return url;
+},
+readName: function(first) {
+var reader  = this._reader,
+ident   = first || "",
+c;
+for (c = reader.peek(); c; c = reader.peek()) {
+if (c === "\\") {
+if (/^[^\r\n\f]$/.test(reader.peek(2))) {
+ident += this.readEscape(reader.read(), true);
+} else {
+// Bad escape sequence.
+break;
+}
+} else if (isNameChar(c)) {
+ident += reader.read();
+} else {
+break;
+}
+}
+return ident;
+},
+readEscape: function(first, unescape) {
+var reader  = this._reader,
+cssEscape = first || "",
+i       = 0,
+c       = reader.peek();
+if (isHexDigit(c)) {
+do {
+cssEscape += reader.read();
+c = reader.peek();
+} while (c && isHexDigit(c) && ++i < 6);
+}
+if (cssEscape.length === 1) {
+if (/^[^\r\n\f0-9a-f]$/.test(c)) {
+reader.read();
+if (unescape) {
+return c;
+}
+} else {
+// We should never get here (readName won't call readEscape
+// if the escape sequence is bad).
+throw new Error("Bad escape sequence.");
+}
+} else if (c === "\r") {
+reader.read();
+if (reader.peek() === "\n") {
+c += reader.read();
+}
+} else if (/^[ \t\n\f]$/.test(c)) {
+reader.read();
+} else {
+c = "";
+}
+if (unescape) {
+var cp = parseInt(cssEscape.slice(first.length), 16);
+return String.fromCodePoint ? String.fromCodePoint(cp) :
+String.fromCharCode(cp);
+}
+return cssEscape + c;
+},
+readComment: function(first) {
+var reader  = this._reader,
+comment = first || "",
+c       = reader.read();
+if (c === "*") {
+while (c) {
+comment += c;
+//look for end of comment
+if (comment.length > 2 && c === "*" && reader.peek() === "/") {
+comment += reader.read();
+break;
+}
+c = reader.read();
+}
+return comment;
+} else {
+return "";
+}
+}
+});
+},{"../util/TokenStreamBase":27,"./PropertyValuePart":11,"./Tokens":18}],18:[function(require,module,exports){
+"use strict";
+var Tokens = module.exports = [
+/*
+* The following token names are defined in CSS3 Grammar: https://www.w3.org/TR/css3-syntax/#lexical
+*/
+// HTML-style comments
+{ name: "CDO" },
+{ name: "CDC" },
+// ignorables
+{ name: "S", whitespace: true/*, channel: "ws"*/ },
+{ name: "COMMENT", comment: true, hide: true, channel: "comment" },
+// attribute equality
+{ name: "INCLUDES", text: "~=" },
+{ name: "DASHMATCH", text: "|=" },
+{ name: "PREFIXMATCH", text: "^=" },
+{ name: "SUFFIXMATCH", text: "$=" },
+{ name: "SUBSTRINGMATCH", text: "*=" },
+// identifier types
+{ name: "STRING" },
+{ name: "IDENT" },
+{ name: "HASH" },
+// at-keywords
+{ name: "IMPORT_SYM", text: "@import" },
+{ name: "PAGE_SYM", text: "@page" },
+{ name: "MEDIA_SYM", text: "@media" },
+{ name: "FONT_FACE_SYM", text: "@font-face" },
+{ name: "CHARSET_SYM", text: "@charset" },
+{ name: "NAMESPACE_SYM", text: "@namespace" },
+{ name: "SUPPORTS_SYM", text: "@supports" },
+{ name: "VIEWPORT_SYM", text: ["@viewport", "@-ms-viewport", "@-o-viewport"] },
+{ name: "DOCUMENT_SYM", text: ["@document", "@-moz-document"] },
+{ name: "UNKNOWN_SYM" },
+//{ name: "ATKEYWORD"},
+// CSS3 animations
+{ name: "KEYFRAMES_SYM", text: [ "@keyframes", "@-webkit-keyframes", "@-moz-keyframes", "@-o-keyframes" ] },
+// important symbol
+{ name: "IMPORTANT_SYM" },
+// measurements
+{ name: "LENGTH" },
+{ name: "ANGLE" },
+{ name: "TIME" },
+{ name: "FREQ" },
+{ name: "DIMENSION" },
+{ name: "PERCENTAGE" },
+{ name: "NUMBER" },
+// functions
+{ name: "URI" },
+{ name: "FUNCTION" },
+// Unicode ranges
+{ name: "UNICODE_RANGE" },
+/*
+* The following token names are defined in CSS3 Selectors: https://www.w3.org/TR/css3-selectors/#selector-syntax
+*/
+// invalid string
+{ name: "INVALID" },
+// combinators
+{ name: "PLUS", text: "+" },
+{ name: "GREATER", text: ">" },
+{ name: "COMMA", text: "," },
+{ name: "TILDE", text: "~" },
+// modifier
+{ name: "NOT" },
+/*
+* Defined in CSS3 Paged Media
+*/
+{ name: "TOPLEFTCORNER_SYM", text: "@top-left-corner" },
+{ name: "TOPLEFT_SYM", text: "@top-left" },
+{ name: "TOPCENTER_SYM", text: "@top-center" },
+{ name: "TOPRIGHT_SYM", text: "@top-right" },
+{ name: "TOPRIGHTCORNER_SYM", text: "@top-right-corner" },
+{ name: "BOTTOMLEFTCORNER_SYM", text: "@bottom-left-corner" },
+{ name: "BOTTOMLEFT_SYM", text: "@bottom-left" },
+{ name: "BOTTOMCENTER_SYM", text: "@bottom-center" },
+{ name: "BOTTOMRIGHT_SYM", text: "@bottom-right" },
+{ name: "BOTTOMRIGHTCORNER_SYM", text: "@bottom-right-corner" },
+{ name: "LEFTTOP_SYM", text: "@left-top" },
+{ name: "LEFTMIDDLE_SYM", text: "@left-middle" },
+{ name: "LEFTBOTTOM_SYM", text: "@left-bottom" },
+{ name: "RIGHTTOP_SYM", text: "@right-top" },
+{ name: "RIGHTMIDDLE_SYM", text: "@right-middle" },
+{ name: "RIGHTBOTTOM_SYM", text: "@right-bottom" },
+/*
+* The following token names are defined in CSS3 Media Queries: https://www.w3.org/TR/css3-mediaqueries/#syntax
+*/
+/*{ name: "MEDIA_ONLY", state: "media"},
+{ name: "MEDIA_NOT", state: "media"},
+{ name: "MEDIA_AND", state: "media"},*/
+{ name: "RESOLUTION", state: "media" },
+/*
+* The following token names are not defined in any CSS specification but are used by the lexer.
+*/
+// not a real token, but useful for stupid IE filters
+{ name: "IE_FUNCTION" },
+// part of CSS3 grammar but not the Flex code
+{ name: "CHAR" },
+// TODO: Needed?
+// Not defined as tokens, but might as well be
+{
+name: "PIPE",
+text: "|"
+},
+{
+name: "SLASH",
+text: "/"
+},
+{
+name: "MINUS",
+text: "-"
+},
+{
+name: "STAR",
+text: "*"
+},
+{
+name: "LBRACE",
+endChar: "}",
+text: "{"
+},
+{
+name: "RBRACE",
+text: "}"
+},
+{
+name: "LBRACKET",
+endChar: "]",
+text: "["
+},
+{
+name: "RBRACKET",
+text: "]"
+},
+{
+name: "EQUALS",
+text: "="
+},
+{
+name: "COLON",
+text: ":"
+},
+{
+name: "SEMICOLON",
+text: ";"
+},
+{
+name: "LPAREN",
+endChar: ")",
+text: "("
+},
+{
+name: "RPAREN",
+text: ")"
+},
+{
+name: "DOT",
+text: "."
+}
+];
+(function() {
+var nameMap = [],
+typeMap = Object.create(null);
+Tokens.UNKNOWN = -1;
+Tokens.unshift({ name:"EOF" });
+for (var i=0, len = Tokens.length; i < len; i++) {
+nameMap.push(Tokens[i].name);
+Tokens[Tokens[i].name] = i;
+if (Tokens[i].text) {
+if (Tokens[i].text instanceof Array) {
+for (var j=0; j < Tokens[i].text.length; j++) {
+typeMap[Tokens[i].text[j]] = i;
+}
+} else {
+typeMap[Tokens[i].text] = i;
+}
+}
+}
+Tokens.name = function(tt) {
+return nameMap[tt];
+};
+Tokens.type = function(c) {
+return typeMap[c] || -1;
+};
+})();
+},{}],19:[function(require,module,exports){
+"use strict";
+/* exported Validation */
+var Matcher = require("./Matcher");
+var Properties = require("./Properties");
+var ValidationTypes = require("./ValidationTypes");
+var ValidationError = require("./ValidationError");
+var PropertyValueIterator = require("./PropertyValueIterator");
+var Validation = module.exports = {
+validate: function(property, value) {
+//normalize name
+var name        = property.toString().toLowerCase(),
+expression  = new PropertyValueIterator(value),
+spec        = Properties[name],
+part;
+if (!spec) {
+if (name.indexOf("-") !== 0) {    //vendor prefixed are ok
+throw new ValidationError("Unknown property '" + property + "'.", property.line, property.col);
+}
+} else if (typeof spec !== "number") {
+// All properties accept some CSS-wide values.
+// https://drafts.csswg.org/css-values-3/#common-keywords
+if (ValidationTypes.isAny(expression, "inherit | initial | unset")) {
+if (expression.hasNext()) {
+part = expression.next();
+throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
+}
+return;
+}
+// Property-specific validation.
+this.singleProperty(spec, expression);
+}
+},
+singleProperty: function(types, expression) {
+var result      = false,
+value       = expression.value,
+part;
+result = Matcher.parse(types).match(expression);
+if (!result) {
+if (expression.hasNext() && !expression.isFirst()) {
+part = expression.peek();
+throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
+} else {
+throw new ValidationError("Expected (" + ValidationTypes.describe(types) + ") but found '" + value + "'.", value.line, value.col);
+}
+} else if (expression.hasNext()) {
+part = expression.next();
+throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
+}
+}
+};
+},{"./Matcher":3,"./Properties":7,"./PropertyValueIterator":10,"./ValidationError":20,"./ValidationTypes":21}],20:[function(require,module,exports){
+"use strict";
+module.exports = ValidationError;
+/**
+* Type to use when a validation error occurs.
+* @class ValidationError
+* @namespace parserlib.util
+* @constructor
+* @param {String} message The error message.
+* @param {int} line The line at which the error occurred.
+* @param {int} col The column at which the error occurred.
+*/
+function ValidationError(message, line, col) {
+/**
+* The column at which the error occurred.
+* @type int
+* @property col
+*/
+this.col = col;
+/**
+* The line at which the error occurred.
+* @type int
+* @property line
+*/
+this.line = line;
+/**
+* The text representation of the unit.
+* @type String
+* @property text
+*/
+this.message = message;
+}
+//inherit from Error
+ValidationError.prototype = new Error();
+},{}],21:[function(require,module,exports){
+"use strict";
+var ValidationTypes = module.exports;
+var Matcher = require("./Matcher");
+function copy(to, from) {
+Object.keys(from).forEach(function(prop) {
+to[prop] = from[prop];
+});
+}
+copy(ValidationTypes, {
+isLiteral: function (part, literals) {
+var text = part.text.toString().toLowerCase(),
+args = literals.split(" | "),
+i, len, found = false;
+for (i=0, len=args.length; i < len && !found; i++) {
+if (args[i].charAt(0) === "<") {
+found = this.simple[args[i]](part);
+} else if (args[i].slice(-2) === "()") {
+found = (part.type === "function" &&
+part.name === args[i].slice(0, -2));
+} else if (text === args[i].toLowerCase()) {
+found = true;
+}
+}
+return found;
+},
+isSimple: function(type) {
+return Boolean(this.simple[type]);
+},
+isComplex: function(type) {
+return Boolean(this.complex[type]);
+},
+describe: function(type) {
+if (this.complex[type] instanceof Matcher) {
+return this.complex[type].toString(0);
+}
+return type;
+},
+/**
+* Determines if the next part(s) of the given expression
+* are any of the given types.
+*/
+isAny: function (expression, types) {
+var args = types.split(" | "),
+i, len, found = false;
+for (i=0, len=args.length; i < len && !found && expression.hasNext(); i++) {
+found = this.isType(expression, args[i]);
+}
+return found;
+},
+/**
+* Determines if the next part(s) of the given expression
+* are one of a group.
+*/
+isAnyOfGroup: function(expression, types) {
+var args = types.split(" || "),
+i, len, found = false;
+for (i=0, len=args.length; i < len && !found; i++) {
+found = this.isType(expression, args[i]);
+}
+return found ? args[i-1] : false;
+},
+/**
+* Determines if the next part(s) of the given expression
+* are of a given type.
+*/
+isType: function (expression, type) {
+var part = expression.peek(),
+result = false;
+if (type.charAt(0) !== "<") {
+result = this.isLiteral(part, type);
+if (result) {
+expression.next();
+}
+} else if (this.simple[type]) {
+result = this.simple[type](part);
+if (result) {
+expression.next();
+}
+} else if (this.complex[type] instanceof Matcher) {
+result = this.complex[type].match(expression);
+} else {
+result = this.complex[type](expression);
+}
+return result;
+},
+simple: {
+__proto__: null,
+"<absolute-size>":
+"xx-small | x-small | small | medium | large | x-large | xx-large",
+"<animateable-feature>":
+"scroll-position | contents | <animateable-feature-name>",
+"<animateable-feature-name>": function(part) {
+return this["<ident>"](part) &&
+!/^(unset|initial|inherit|will-change|auto|scroll-position|contents)$/i.test(part);
+},
+"<angle>": function(part) {
+return part.type === "angle";
+},
+"<attachment>": "scroll | fixed | local",
+"<attr>": "attr()",
+// inset() = inset( <shape-arg>{1,4} [round <border-radius>]? )
+// circle() = circle( [<shape-radius>]? [at <position>]? )
+// ellipse() = ellipse( [<shape-radius>{2}]? [at <position>]? )
+// polygon() = polygon( [<fill-rule>,]? [<shape-arg> <shape-arg>]# )
+"<basic-shape>": "inset() | circle() | ellipse() | polygon()",
+"<bg-image>": "<image> | <gradient> | none",
+"<border-style>":
+"none | hidden | dotted | dashed | solid | double | groove | " +
+"ridge | inset | outset",
+"<border-width>": "<length> | thin | medium | thick",
+"<box>": "padding-box | border-box | content-box",
+"<clip-source>": "<uri>",
+"<color>": function(part) {
+return part.type === "color" || String(part) === "transparent" || String(part) === "currentColor";
+},
+// The SVG <color> spec doesn't include "currentColor" or "transparent" as a color.
+"<color-svg>": function(part) {
+return part.type === "color";
+},
+"<content>": "content()",
+// https://www.w3.org/TR/css3-sizing/#width-height-keywords
+"<content-sizing>":
+"fill-available | -moz-available | -webkit-fill-available | " +
+"max-content | -moz-max-content | -webkit-max-content | " +
+"min-content | -moz-min-content | -webkit-min-content | " +
+"fit-content | -moz-fit-content | -webkit-fit-content",
+"<feature-tag-value>": function(part) {
+return part.type === "function" && /^[A-Z0-9]{4}$/i.test(part);
+},
+// custom() isn't actually in the spec
+"<filter-function>":
+"blur() | brightness() | contrast() | custom() | " +
+"drop-shadow() | grayscale() | hue-rotate() | invert() | " +
+"opacity() | saturate() | sepia()",
+"<flex-basis>": "<width>",
+"<flex-direction>": "row | row-reverse | column | column-reverse",
+"<flex-grow>": "<number>",
+"<flex-shrink>": "<number>",
+"<flex-wrap>": "nowrap | wrap | wrap-reverse",
+"<font-size>":
+"<absolute-size> | <relative-size> | <length> | <percentage>",
+"<font-stretch>":
+"normal | ultra-condensed | extra-condensed | condensed | " +
+"semi-condensed | semi-expanded | expanded | extra-expanded | " +
+"ultra-expanded",
+"<font-style>": "normal | italic | oblique",
+"<font-variant-caps>":
+"small-caps | all-small-caps | petite-caps | all-petite-caps | " +
+"unicase | titling-caps",
+"<font-variant-css21>": "normal | small-caps",
+"<font-weight>":
+"normal | bold | bolder | lighter | " +
+"100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900",
+"<generic-family>":
+"serif | sans-serif | cursive | fantasy | monospace",
+"<geometry-box>": "<shape-box> | fill-box | stroke-box | view-box",
+"<glyph-angle>": function(part) {
+return part.type === "angle" && part.units === "deg";
+},
+"<gradient>": function(part) {
+return part.type === "function" && /^(?:\-(?:ms|moz|o|webkit)\-)?(?:repeating\-)?(?:radial\-|linear\-)?gradient/i.test(part);
+},
+"<icccolor>":
+"cielab() | cielch() | cielchab() | " +
+"icc-color() | icc-named-color()",
+//any identifier
+"<ident>": function(part) {
+return part.type === "identifier" || part.wasIdent;
+},
+"<ident-not-generic-family>": function(part) {
+return this["<ident>"](part) && !this["<generic-family>"](part);
+},
+"<image>": "<uri>",
+"<integer>": function(part) {
+return part.type === "integer";
+},
+"<length>": function(part) {
+if (part.type === "function" && /^(?:\-(?:ms|moz|o|webkit)\-)?calc/i.test(part)) {
+return true;
+} else {
+return part.type === "length" || part.type === "number" || part.type === "integer" || String(part) === "0";
+}
+},
+"<line>": function(part) {
+return part.type === "integer";
+},
+"<line-height>": "<number> | <length> | <percentage> | normal",
+"<margin-width>": "<length> | <percentage> | auto",
+"<miterlimit>": function(part) {
+return this["<number>"](part) && part.value >= 1;
+},
+"<nonnegative-length-or-percentage>": function(part) {
+return (this["<length>"](part) || this["<percentage>"](part)) &&
+(String(part) === "0" || part.type === "function" || (part.value) >= 0);
+},
+"<nonnegative-number-or-percentage>": function(part) {
+return (this["<number>"](part) || this["<percentage>"](part)) &&
+(String(part) === "0" || part.type === "function" || (part.value) >= 0);
+},
+"<number>": function(part) {
+return part.type === "number" || this["<integer>"](part);
+},
+"<opacity-value>": function(part) {
+return this["<number>"](part) && part.value >= 0 && part.value <= 1;
+},
+"<padding-width>": "<nonnegative-length-or-percentage>",
+"<percentage>": function(part) {
+return part.type === "percentage" || String(part) === "0";
+},
+"<relative-size>": "smaller | larger",
+"<shape>": "rect() | inset-rect()",
+"<shape-box>": "<box> | margin-box",
+"<single-animation-direction>":
+"normal | reverse | alternate | alternate-reverse",
+"<single-animation-name>": function(part) {
+return this["<ident>"](part) &&
+/^-?[a-z_][-a-z0-9_]+$/i.test(part) &&
+!/^(none|unset|initial|inherit)$/i.test(part);
+},
+"<string>": function(part) {
+return part.type === "string";
+},
+"<time>": function(part) {
+return part.type === "time";
+},
+"<uri>": function(part) {
+return part.type === "uri";
+},
+"<width>": "<margin-width>"
+},
+complex: {
+__proto__: null,
+"<azimuth>":
+"<angle>" +
+" | " +
+"[ [ left-side | far-left | left | center-left | center | " +
+"center-right | right | far-right | right-side ] || behind ]" +
+" | "+
+"leftwards | rightwards",
+"<bg-position>": "<position>#",
+"<bg-size>":
+"[ <length> | <percentage> | auto ]{1,2} | cover | contain",
+"<border-image-slice>":
+// [<number> | <percentage>]{1,4} && fill?
+// *but* fill can appear between any of the numbers
+Matcher.many([true /* first element is required */],
+Matcher.cast("<nonnegative-number-or-percentage>"),
+Matcher.cast("<nonnegative-number-or-percentage>"),
+Matcher.cast("<nonnegative-number-or-percentage>"),
+Matcher.cast("<nonnegative-number-or-percentage>"),
+"fill"),
+"<border-radius>":
+"<nonnegative-length-or-percentage>{1,4} " +
+"[ / <nonnegative-length-or-percentage>{1,4} ]?",
+"<box-shadow>": "none | <shadow>#",
+"<clip-path>": "<basic-shape> || <geometry-box>",
+"<dasharray>":
+// "list of comma and/or white space separated <length>s and
+// <percentage>s".  There is a non-negative constraint.
+Matcher.cast("<nonnegative-length-or-percentage>")
+.braces(1, Infinity, "#", Matcher.cast(",").question()),
+"<family-name>":
+// <string> | <IDENT>+
+"<string> | <ident-not-generic-family> <ident>*",
+"<filter-function-list>": "[ <filter-function> | <uri> ]+",
+// https://www.w3.org/TR/2014/WD-css-flexbox-1-20140325/#flex-property
+"<flex>":
+"none | [ <flex-grow> <flex-shrink>? || <flex-basis> ]",
+"<font-family>": "[ <generic-family> | <family-name> ]#",
+"<font-shorthand>":
+"[ <font-style> || <font-variant-css21> || " +
+"<font-weight> || <font-stretch> ]? <font-size> " +
+"[ / <line-height> ]? <font-family>",
+"<font-variant-alternates>":
+// stylistic(<feature-value-name>)
+"stylistic() || " +
+"historical-forms || " +
+// styleset(<feature-value-name> #)
+"styleset() || " +
+// character-variant(<feature-value-name> #)
+"character-variant() || " +
+// swash(<feature-value-name>)
+"swash() || " +
+// ornaments(<feature-value-name>)
+"ornaments() || " +
+// annotation(<feature-value-name>)
+"annotation()",
+"<font-variant-ligatures>":
+// <common-lig-values>
+"[ common-ligatures | no-common-ligatures ] || " +
+// <discretionary-lig-values>
+"[ discretionary-ligatures | no-discretionary-ligatures ] || " +
+// <historical-lig-values>
+"[ historical-ligatures | no-historical-ligatures ] || " +
+// <contextual-alt-values>
+"[ contextual | no-contextual ]",
+"<font-variant-numeric>":
+// <numeric-figure-values>
+"[ lining-nums | oldstyle-nums ] || " +
+// <numeric-spacing-values>
+"[ proportional-nums | tabular-nums ] || " +
+// <numeric-fraction-values>
+"[ diagonal-fractions | stacked-fractions ] || " +
+"ordinal || slashed-zero",
+"<font-variant-east-asian>":
+// <east-asian-variant-values>
+"[ jis78 | jis83 | jis90 | jis04 | simplified | traditional ] || " +
+// <east-asian-width-values>
+"[ full-width | proportional-width ] || " +
+"ruby",
+// Note that <color> here is "as defined in the SVG spec", which
+// is more restrictive that the <color> defined in the CSS spec.
+// none | currentColor | <color> [<icccolor>]? |
+// <funciri> [ none | currentColor | <color> [<icccolor>]? ]?
+"<paint>": "<paint-basic> | <uri> <paint-basic>?",
+// Helper definition for <paint> above.
+"<paint-basic>": "none | currentColor | <color-svg> <icccolor>?",
+"<position>":
+// Because our `alt` combinator is ordered, we need to test these
+// in order from longest possible match to shortest.
+"[ center | [ left | right ] [ <percentage> | <length> ]? ] && " +
+"[ center | [ top | bottom ] [ <percentage> | <length> ]? ]" +
+" | " +
+"[ left | center | right | <percentage> | <length> ] " +
+"[ top | center | bottom | <percentage> | <length> ]" +
+" | " +
+"[ left | center | right | top | bottom | <percentage> | <length> ]",
+"<repeat-style>":
+"repeat-x | repeat-y | [ repeat | space | round | no-repeat ]{1,2}",
+"<shadow>":
+//inset? && [ <length>{2,4} && <color>? ]
+Matcher.many([true /* length is required */],
+Matcher.cast("<length>").braces(2, 4), "inset", "<color>"),
+"<text-decoration-color>":
+"<color>",
+"<text-decoration-line>":
+"none | [ underline || overline || line-through || blink ]",
+"<text-decoration-style>":
+"solid | double | dotted | dashed | wavy",
+"<will-change>":
+"auto | <animateable-feature>#",
+"<x-one-radius>":
+//[ <length> | <percentage> ] [ <length> | <percentage> ]?
+"[ <length> | <percentage> ]{1,2}"
+}
+});
+Object.keys(ValidationTypes.simple).forEach(function(nt) {
+var rule = ValidationTypes.simple[nt];
+if (typeof rule === "string") {
+ValidationTypes.simple[nt] = function(part) {
+return ValidationTypes.isLiteral(part, rule);
+};
+}
+});
+Object.keys(ValidationTypes.complex).forEach(function(nt) {
+var rule = ValidationTypes.complex[nt];
+if (typeof rule === "string") {
+ValidationTypes.complex[nt] = Matcher.parse(rule);
+}
+});
+// Because this is defined relative to other complex validation types,
+// we need to define it *after* the rest of the types are initialized.
+ValidationTypes.complex["<font-variant>"] =
+Matcher.oror({ expand: "<font-variant-ligatures>" },
+{ expand: "<font-variant-alternates>" },
+"<font-variant-caps>",
+{ expand: "<font-variant-numeric>" },
+{ expand: "<font-variant-east-asian>" });
+},{"./Matcher":3}],22:[function(require,module,exports){
+"use strict";
+module.exports = {
+Colors            : require("./Colors"),
+Combinator        : require("./Combinator"),
+Parser            : require("./Parser"),
+PropertyName      : require("./PropertyName"),
+PropertyValue     : require("./PropertyValue"),
+PropertyValuePart : require("./PropertyValuePart"),
+Matcher           : require("./Matcher"),
+MediaFeature      : require("./MediaFeature"),
+MediaQuery        : require("./MediaQuery"),
+Selector          : require("./Selector"),
+SelectorPart      : require("./SelectorPart"),
+SelectorSubPart   : require("./SelectorSubPart"),
+Specificity       : require("./Specificity"),
+TokenStream       : require("./TokenStream"),
+Tokens            : require("./Tokens"),
+ValidationError   : require("./ValidationError")
+};
+},{"./Colors":1,"./Combinator":2,"./Matcher":3,"./MediaFeature":4,"./MediaQuery":5,"./Parser":6,"./PropertyName":8,"./PropertyValue":9,"./PropertyValuePart":11,"./Selector":13,"./SelectorPart":14,"./SelectorSubPart":15,"./Specificity":16,"./TokenStream":17,"./Tokens":18,"./ValidationError":20}],23:[function(require,module,exports){
+"use strict";
+module.exports = EventTarget;
+/**
+* A generic base to inherit from for any object
+* that needs event handling.
+* @class EventTarget
+* @constructor
+*/
+function EventTarget() {
+/**
+* The array of listeners for various events.
+* @type Object
+* @property _listeners
+* @private
+*/
+this._listeners = Object.create(null);
+}
+EventTarget.prototype = {
+//restore constructor
+constructor: EventTarget,
+/**
+* Adds a listener for a given event type.
+* @param {String} type The type of event to add a listener for.
+* @param {Function} listener The function to call when the event occurs.
+* @return {void}
+* @method addListener
+*/
+addListener: function(type, listener) {
+if (!this._listeners[type]) {
+this._listeners[type] = [];
+}
+this._listeners[type].push(listener);
+},
+/**
+* Fires an event based on the passed-in object.
+* @param {Object|String} event An object with at least a 'type' attribute
+*      or a string indicating the event name.
+* @return {void}
+* @method fire
+*/
+fire: function(event) {
+if (typeof event === "string") {
+event = { type: event };
+}
+if (typeof event.target !== "undefined") {
+event.target = this;
+}
+if (typeof event.type === "undefined") {
+throw new Error("Event object missing 'type' property.");
+}
+if (this._listeners[event.type]) {
+//create a copy of the array and use that so listeners can't chane
+var listeners = this._listeners[event.type].concat();
+for (var i=0, len=listeners.length; i < len; i++) {
+listeners[i].call(this, event);
+}
+}
+},
+/**
+* Removes a listener for a given event type.
+* @param {String} type The type of event to remove a listener from.
+* @param {Function} listener The function to remove from the event.
+* @return {void}
+* @method removeListener
+*/
+removeListener: function(type, listener) {
+if (this._listeners[type]) {
+var listeners = this._listeners[type];
+for (var i=0, len=listeners.length; i < len; i++) {
+if (listeners[i] === listener) {
+listeners.splice(i, 1);
+break;
+}
+}
+}
+}
+};
+},{}],24:[function(require,module,exports){
+"use strict";
+module.exports = StringReader;
+/**
+* Convenient way to read through strings.
+* @namespace parserlib.util
+* @class StringReader
+* @constructor
+* @param {String} text The text to read.
+*/
+function StringReader(text) {
+/**
+* The input text with line endings normalized.
+* @property _input
+* @type String
+* @private
+*/
+this._input = text.replace(/(\r\n?|\n)/g, "\n");
+/**
+* The row for the character to be read next.
+* @property _line
+* @type int
+* @private
+*/
+this._line = 1;
+/**
+* The column for the character to be read next.
+* @property _col
+* @type int
+* @private
+*/
+this._col = 1;
+/**
+* The index of the character in the input to be read next.
+* @property _cursor
+* @type int
+* @private
+*/
+this._cursor = 0;
+}
+StringReader.prototype = {
+// restore constructor
+constructor: StringReader,
+//-------------------------------------------------------------------------
+// Position info
+//-------------------------------------------------------------------------
+/**
+* Returns the column of the character to be read next.
+* @return {int} The column of the character to be read next.
+* @method getCol
+*/
+getCol: function() {
+return this._col;
+},
+/**
+* Returns the row of the character to be read next.
+* @return {int} The row of the character to be read next.
+* @method getLine
+*/
+getLine: function() {
+return this._line;
+},
+/**
+* Determines if you're at the end of the input.
+* @return {Boolean} True if there's no more input, false otherwise.
+* @method eof
+*/
+eof: function() {
+return this._cursor === this._input.length;
+},
+//-------------------------------------------------------------------------
+// Basic reading
+//-------------------------------------------------------------------------
+/**
+* Reads the next character without advancing the cursor.
+* @param {int} count How many characters to look ahead (default is 1).
+* @return {String} The next character or null if there is no next character.
+* @method peek
+*/
+peek: function(count) {
+var c = null;
+count = typeof count === "undefined" ? 1 : count;
+// if we're not at the end of the input...
+if (this._cursor < this._input.length) {
+// get character and increment cursor and column
+c = this._input.charAt(this._cursor + count - 1);
+}
+return c;
+},
+/**
+* Reads the next character from the input and adjusts the row and column
+* accordingly.
+* @return {String} The next character or null if there is no next character.
+* @method read
+*/
+read: function() {
+var c = null;
+// if we're not at the end of the input...
+if (this._cursor < this._input.length) {
+// if the last character was a newline, increment row count
+// and reset column count
+if (this._input.charAt(this._cursor) === "\n") {
+this._line++;
+this._col=1;
+} else {
+this._col++;
+}
+// get character and increment cursor and column
+c = this._input.charAt(this._cursor++);
+}
+return c;
+},
+//-------------------------------------------------------------------------
+// Misc
+//-------------------------------------------------------------------------
+/**
+* Saves the current location so it can be returned to later.
+* @method mark
+* @return {void}
+*/
+mark: function() {
+this._bookmark = {
+cursor: this._cursor,
+line:   this._line,
+col:    this._col
+};
+},
+reset: function() {
+if (this._bookmark) {
+this._cursor = this._bookmark.cursor;
+this._line = this._bookmark.line;
+this._col = this._bookmark.col;
+delete this._bookmark;
+}
+},
+//-------------------------------------------------------------------------
+// Advanced reading
+//-------------------------------------------------------------------------
+/**
+* Reads up to and including the given string. Throws an error if that
+* string is not found.
+* @param {String} pattern The string to read.
+* @return {String} The string when it is found.
+* @throws Error when the string pattern is not found.
+* @method readTo
+*/
+readTo: function(pattern) {
+var buffer = "",
+c;
+/*
+* First, buffer must be the same length as the pattern.
+* Then, buffer must end with the pattern or else reach the
+* end of the input.
+*/
+while (buffer.length < pattern.length || buffer.lastIndexOf(pattern) !== buffer.length - pattern.length) {
+c = this.read();
+if (c) {
+buffer += c;
+} else {
+throw new Error("Expected \"" + pattern + "\" at line " + this._line  + ", col " + this._col + ".");
+}
+}
+return buffer;
+},
+/**
+* Reads characters while each character causes the given
+* filter function to return true. The function is passed
+* in each character and either returns true to continue
+* reading or false to stop.
+* @param {Function} filter The function to read on each character.
+* @return {String} The string made up of all characters that passed the
+*      filter check.
+* @method readWhile
+*/
+readWhile: function(filter) {
+var buffer = "",
+c = this.peek();
+while (c !== null && filter(c)) {
+buffer += this.read();
+c = this.peek();
+}
+return buffer;
+},
+/**
+* Reads characters that match either text or a regular expression and
+* returns those characters. If a match is found, the row and column
+* are adjusted; if no match is found, the reader's state is unchanged.
+* reading or false to stop.
+* @param {String|RegExp} matcher If a string, then the literal string
+*      value is searched for. If a regular expression, then any string
+*      matching the pattern is search for.
+* @return {String} The string made up of all characters that matched or
+*      null if there was no match.
+* @method readMatch
+*/
+readMatch: function(matcher) {
+var source = this._input.substring(this._cursor),
+value = null;
+// if it's a string, just do a straight match
+if (typeof matcher === "string") {
+if (source.slice(0, matcher.length) === matcher) {
+value = this.readCount(matcher.length);
+}
+} else if (matcher instanceof RegExp) {
+if (matcher.test(source)) {
+value = this.readCount(RegExp.lastMatch.length);
+}
+}
+return value;
+},
+/**
+* Reads a given number of characters. If the end of the input is reached,
+* it reads only the remaining characters and does not throw an error.
+* @param {int} count The number of characters to read.
+* @return {String} The string made up the read characters.
+* @method readCount
+*/
+readCount: function(count) {
+var buffer = "";
+while (count--) {
+buffer += this.read();
+}
+return buffer;
+}
+};
+},{}],25:[function(require,module,exports){
+"use strict";
+module.exports = SyntaxError;
+/**
+* Type to use when a syntax error occurs.
+* @class SyntaxError
+* @namespace parserlib.util
+* @constructor
+* @param {String} message The error message.
+* @param {int} line The line at which the error occurred.
+* @param {int} col The column at which the error occurred.
+*/
+function SyntaxError(message, line, col) {
+Error.call(this);
+this.name = this.constructor.name;
+/**
+* The column at which the error occurred.
+* @type int
+* @property col
+*/
+this.col = col;
+/**
+* The line at which the error occurred.
+* @type int
+* @property line
+*/
+this.line = line;
+/**
+* The text representation of the unit.
+* @type String
+* @property text
+*/
+this.message = message;
+}
+//inherit from Error
+SyntaxError.prototype = Object.create(Error.prototype); // jshint ignore:line
+SyntaxError.prototype.constructor = SyntaxError; // jshint ignore:line
+},{}],26:[function(require,module,exports){
+"use strict";
+module.exports = SyntaxUnit;
+/**
+* Base type to represent a single syntactic unit.
+* @class SyntaxUnit
+* @namespace parserlib.util
+* @constructor
+* @param {String} text The text of the unit.
+* @param {int} line The line of text on which the unit resides.
+* @param {int} col The column of text on which the unit resides.
+*/
+function SyntaxUnit(text, line, col, type) {
+/**
+* The column of text on which the unit resides.
+* @type int
+* @property col
+*/
+this.col = col;
+/**
+* The line of text on which the unit resides.
+* @type int
+* @property line
+*/
+this.line = line;
+/**
+* The text representation of the unit.
+* @type String
+* @property text
+*/
+this.text = text;
+/**
+* The type of syntax unit.
+* @type int
+* @property type
+*/
+this.type = type;
+}
+/**
+* Create a new syntax unit based solely on the given token.
+* Convenience method for creating a new syntax unit when
+* it represents a single token instead of multiple.
+* @param {Object} token The token object to represent.
+* @return {parserlib.util.SyntaxUnit} The object representing the token.
+* @static
+* @method fromToken
+*/
+SyntaxUnit.fromToken = function(token) {
+return new SyntaxUnit(token.value, token.startLine, token.startCol);
+};
+SyntaxUnit.prototype = {
+//restore constructor
+constructor: SyntaxUnit,
+/**
+* Returns the text representation of the unit.
+* @return {String} The text representation of the unit.
+* @method valueOf
+*/
+valueOf: function() {
+return this.toString();
+},
+/**
+* Returns the text representation of the unit.
+* @return {String} The text representation of the unit.
+* @method toString
+*/
+toString: function() {
+return this.text;
+}
+};
+},{}],27:[function(require,module,exports){
+"use strict";
+module.exports = TokenStreamBase;
+var StringReader = require("./StringReader");
+var SyntaxError = require("./SyntaxError");
+/**
+* Generic TokenStream providing base functionality.
+* @class TokenStreamBase
+* @namespace parserlib.util
+* @constructor
+* @param {String|StringReader} input The text to tokenize or a reader from
+*      which to read the input.
+*/
+function TokenStreamBase(input, tokenData) {
+/**
+* The string reader for easy access to the text.
+* @type StringReader
+* @property _reader
+* @private
+*/
+this._reader = new StringReader(input ? input.toString() : "");
+/**
+* Token object for the last consumed token.
+* @type Token
+* @property _token
+* @private
+*/
+this._token = null;
+/**
+* The array of token information.
+* @type Array
+* @property _tokenData
+* @private
+*/
+this._tokenData = tokenData;
+/**
+* Lookahead token buffer.
+* @type Array
+* @property _lt
+* @private
+*/
+this._lt = [];
+/**
+* Lookahead token buffer index.
+* @type int
+* @property _ltIndex
+* @private
+*/
+this._ltIndex = 0;
+this._ltIndexCache = [];
+}
+/**
+* Accepts an array of token information and outputs
+* an array of token data containing key-value mappings
+* and matching functions that the TokenStream needs.
+* @param {Array} tokens An array of token descriptors.
+* @return {Array} An array of processed token data.
+* @method createTokenData
+* @static
+*/
+TokenStreamBase.createTokenData = function(tokens) {
+var nameMap     = [],
+typeMap     = Object.create(null),
+tokenData     = tokens.concat([]),
+i            = 0,
+len            = tokenData.length+1;
+tokenData.UNKNOWN = -1;
+tokenData.unshift({ name:"EOF" });
+for (; i < len; i++) {
+nameMap.push(tokenData[i].name);
+tokenData[tokenData[i].name] = i;
+if (tokenData[i].text) {
+typeMap[tokenData[i].text] = i;
+}
+}
+tokenData.name = function(tt) {
+return nameMap[tt];
+};
+tokenData.type = function(c) {
+return typeMap[c];
+};
+return tokenData;
+};
+TokenStreamBase.prototype = {
+//restore constructor
+constructor: TokenStreamBase,
+//-------------------------------------------------------------------------
+// Matching methods
+//-------------------------------------------------------------------------
+/**
+* Determines if the next token matches the given token type.
+* If so, that token is consumed; if not, the token is placed
+* back onto the token stream. You can pass in any number of
+* token types and this will return true if any of the token
+* types is found.
+* @param {int|int[]} tokenTypes Either a single token type or an array of
+*      token types that the next token might be. If an array is passed,
+*      it's assumed that the token can be any of these.
+* @param {variant} channel (Optional) The channel to read from. If not
+*      provided, reads from the default (unnamed) channel.
+* @return {Boolean} True if the token type matches, false if not.
+* @method match
+*/
+match: function(tokenTypes, channel) {
+//always convert to an array, makes things easier
+if (!(tokenTypes instanceof Array)) {
+tokenTypes = [tokenTypes];
+}
+var tt  = this.get(channel),
+i   = 0,
+len = tokenTypes.length;
+while (i < len) {
+if (tt === tokenTypes[i++]) {
+return true;
+}
+}
+//no match found, put the token back
+this.unget();
+return false;
+},
+/**
+* Determines if the next token matches the given token type.
+* If so, that token is consumed; if not, an error is thrown.
+* @param {int|int[]} tokenTypes Either a single token type or an array of
+*      token types that the next token should be. If an array is passed,
+*      it's assumed that the token must be one of these.
+* @return {void}
+* @method mustMatch
+*/
+mustMatch: function(tokenTypes) {
+var token;
+//always convert to an array, makes things easier
+if (!(tokenTypes instanceof Array)) {
+tokenTypes = [tokenTypes];
+}
+if (!this.match.apply(this, arguments)) {
+token = this.LT(1);
+throw new SyntaxError("Expected " + this._tokenData[tokenTypes[0]].name +
+" at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
+}
+},
+//-------------------------------------------------------------------------
+// Consuming methods
+//-------------------------------------------------------------------------
+/**
+* Keeps reading from the token stream until either one of the specified
+* token types is found or until the end of the input is reached.
+* @param {int|int[]} tokenTypes Either a single token type or an array of
+*      token types that the next token should be. If an array is passed,
+*      it's assumed that the token must be one of these.
+* @param {variant} channel (Optional) The channel to read from. If not
+*      provided, reads from the default (unnamed) channel.
+* @return {void}
+* @method advance
+*/
+advance: function(tokenTypes, channel) {
+while (this.LA(0) !== 0 && !this.match(tokenTypes, channel)) {
+this.get();
+}
+return this.LA(0);
+},
+/**
+* Consumes the next token from the token stream.
+* @return {int} The token type of the token that was just consumed.
+* @method get
+*/
+get: function(channel) {
+var tokenInfo   = this._tokenData,
+i           =0,
+token,
+info;
+//check the lookahead buffer first
+if (this._lt.length && this._ltIndex >= 0 && this._ltIndex < this._lt.length) {
+i++;
+this._token = this._lt[this._ltIndex++];
+info = tokenInfo[this._token.type];
+//obey channels logic
+while ((info.channel !== undefined && channel !== info.channel) &&
+this._ltIndex < this._lt.length) {
+this._token = this._lt[this._ltIndex++];
+info = tokenInfo[this._token.type];
+i++;
+}
+//here be dragons
+if ((info.channel === undefined || channel === info.channel) &&
+this._ltIndex <= this._lt.length) {
+this._ltIndexCache.push(i);
+return this._token.type;
+}
+}
+//call token retriever method
+token = this._getToken();
+//if it should be hidden, don't save a token
+if (token.type > -1 && !tokenInfo[token.type].hide) {
+//apply token channel
+token.channel = tokenInfo[token.type].channel;
+//save for later
+this._token = token;
+this._lt.push(token);
+//save space that will be moved (must be done before array is truncated)
+this._ltIndexCache.push(this._lt.length - this._ltIndex + i);
+//keep the buffer under 5 items
+if (this._lt.length > 5) {
+this._lt.shift();
+}
+//also keep the shift buffer under 5 items
+if (this._ltIndexCache.length > 5) {
+this._ltIndexCache.shift();
+}
+//update lookahead index
+this._ltIndex = this._lt.length;
+}
+/*
+* Skip to the next token if:
+* 1. The token type is marked as hidden.
+* 2. The token type has a channel specified and it isn't the current channel.
+*/
+info = tokenInfo[token.type];
+if (info &&
+(info.hide ||
+(info.channel !== undefined && channel !== info.channel))) {
+return this.get(channel);
+} else {
+//return just the type
+return token.type;
+}
+},
+/**
+* Looks ahead a certain number of tokens and returns the token type at
+* that position. This will throw an error if you lookahead past the
+* end of input, past the size of the lookahead buffer, or back past
+* the first token in the lookahead buffer.
+* @param {int} The index of the token type to retrieve. 0 for the
+*      current token, 1 for the next, -1 for the previous, etc.
+* @return {int} The token type of the token in the given position.
+* @method LA
+*/
+LA: function(index) {
+var total = index,
+tt;
+if (index > 0) {
+//TODO: Store 5 somewhere
+if (index > 5) {
+throw new Error("Too much lookahead.");
+}
+//get all those tokens
+while (total) {
+tt = this.get();
+total--;
+}
+//unget all those tokens
+while (total < index) {
+this.unget();
+total++;
+}
+} else if (index < 0) {
+if (this._lt[this._ltIndex+index]) {
+tt = this._lt[this._ltIndex+index].type;
+} else {
+throw new Error("Too much lookbehind.");
+}
+} else {
+tt = this._token.type;
+}
+return tt;
+},
+/**
+* Looks ahead a certain number of tokens and returns the token at
+* that position. This will throw an error if you lookahead past the
+* end of input, past the size of the lookahead buffer, or back past
+* the first token in the lookahead buffer.
+* @param {int} The index of the token type to retrieve. 0 for the
+*      current token, 1 for the next, -1 for the previous, etc.
+* @return {Object} The token of the token in the given position.
+* @method LA
+*/
+LT: function(index) {
+//lookahead first to prime the token buffer
+this.LA(index);
+//now find the token, subtract one because _ltIndex is already at the next index
+return this._lt[this._ltIndex+index-1];
+},
+/**
+* Returns the token type for the next token in the stream without
+* consuming it.
+* @return {int} The token type of the next token in the stream.
+* @method peek
+*/
+peek: function() {
+return this.LA(1);
+},
+/**
+* Returns the actual token object for the last consumed token.
+* @return {Token} The token object for the last consumed token.
+* @method token
+*/
+token: function() {
+return this._token;
+},
+/**
+* Returns the name of the token for the given token type.
+* @param {int} tokenType The type of token to get the name of.
+* @return {String} The name of the token or "UNKNOWN_TOKEN" for any
+*      invalid token type.
+* @method tokenName
+*/
+tokenName: function(tokenType) {
+if (tokenType < 0 || tokenType > this._tokenData.length) {
+return "UNKNOWN_TOKEN";
+} else {
+return this._tokenData[tokenType].name;
+}
+},
+/**
+* Returns the token type value for the given token name.
+* @param {String} tokenName The name of the token whose value should be returned.
+* @return {int} The token type value for the given token name or -1
+*      for an unknown token.
+* @method tokenName
+*/
+tokenType: function(tokenName) {
+return this._tokenData[tokenName] || -1;
+},
+/**
+* Returns the last consumed token to the token stream.
+* @method unget
+*/
+unget: function() {
+//if (this._ltIndex > -1) {
+if (this._ltIndexCache.length) {
+this._ltIndex -= this._ltIndexCache.pop();//--;
+this._token = this._lt[this._ltIndex - 1];
+} else {
+throw new Error("Too much lookahead.");
+}
+}
+};
+},{"./StringReader":24,"./SyntaxError":25}],28:[function(require,module,exports){
+"use strict";
+module.exports = {
+StringReader    : require("./StringReader"),
+SyntaxError     : require("./SyntaxError"),
+SyntaxUnit      : require("./SyntaxUnit"),
+EventTarget     : require("./EventTarget"),
+TokenStreamBase : require("./TokenStreamBase")
+};
+},{"./EventTarget":23,"./StringReader":24,"./SyntaxError":25,"./SyntaxUnit":26,"./TokenStreamBase":27}],"parserlib":[function(require,module,exports){
+"use strict";
+module.exports = {
+css  : require("./css"),
+util : require("./util")
+};
+},{"./css":22,"./util":28}]},{},[]);
+return require('parserlib');
+})();
+var clone = (function() {
+'use strict';
+var nativeMap;
+try {
+nativeMap = Map;
+} catch(_) {
+// maybe a reference error because no `Map`. Give it a dummy value that no
+// value will ever be an instanceof.
+nativeMap = function() {};
+}
+var nativeSet;
+try {
+nativeSet = Set;
+} catch(_) {
+nativeSet = function() {};
+}
+var nativePromise;
+try {
+nativePromise = Promise;
+} catch(_) {
+nativePromise = function() {};
+}
+/**
+* Clones (copies) an Object using deep copying.
+*
+* This function supports circular references by default, but if you are certain
+* there are no circular references in your object, you can save some CPU time
+* by calling clone(obj, false).
+*
+* Caution: if `circular` is false and `parent` contains circular references,
+* your program may enter an infinite loop and crash.
+*
+* @param `parent` - the object to be cloned
+* @param `circular` - set to true if the object to be cloned may contain
+*    circular references. (optional - true by default)
+* @param `depth` - set to a number if the object is only to be cloned to
+*    a particular depth. (optional - defaults to Infinity)
+* @param `prototype` - sets the prototype to be used when cloning an object.
+*    (optional - defaults to parent prototype).
+* @param `includeNonEnumerable` - set to true if the non-enumerable properties
+*    should be cloned as well. Non-enumerable properties on the prototype
+*    chain will be ignored. (optional - false by default)
+*/
+function clone(parent, circular, depth, prototype, includeNonEnumerable) {
+if (typeof circular === 'object') {
+depth = circular.depth;
+prototype = circular.prototype;
+includeNonEnumerable = circular.includeNonEnumerable;
+circular = circular.circular;
+}
+// maintain two arrays for circular references, where corresponding parents
+// and children have the same index
+var allParents = [];
+var allChildren = [];
+var useBuffer = typeof Buffer != 'undefined';
+if (typeof circular == 'undefined')
+circular = true;
+if (typeof depth == 'undefined')
+depth = Infinity;
+// recurse this function so we don't reset allParents and allChildren
+function _clone(parent, depth) {
+// cloning null always returns null
+if (parent === null)
+return null;
+if (depth === 0)
+return parent;
+var child;
+var proto;
+if (typeof parent != 'object') {
+return parent;
+}
+if (parent instanceof nativeMap) {
+child = new nativeMap();
+} else if (parent instanceof nativeSet) {
+child = new nativeSet();
+} else if (parent instanceof nativePromise) {
+child = new nativePromise(function (resolve, reject) {
+parent.then(function(value) {
+resolve(_clone(value, depth - 1));
+}, function(err) {
+reject(_clone(err, depth - 1));
+});
+});
+} else if (clone.__isArray(parent)) {
+child = [];
+} else if (clone.__isRegExp(parent)) {
+child = new RegExp(parent.source, __getRegExpFlags(parent));
+if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+} else if (clone.__isDate(parent)) {
+child = new Date(parent.getTime());
+} else if (useBuffer && Buffer.isBuffer(parent)) {
+child = new Buffer(parent.length);
+parent.copy(child);
+return child;
+} else if (parent instanceof Error) {
+child = Object.create(parent);
+} else {
+if (typeof prototype == 'undefined') {
+proto = Object.getPrototypeOf(parent);
+child = Object.create(proto);
+}
+else {
+child = Object.create(prototype);
+proto = prototype;
+}
+}
+if (circular) {
+var index = allParents.indexOf(parent);
+if (index != -1) {
+return allChildren[index];
+}
+allParents.push(parent);
+allChildren.push(child);
+}
+if (parent instanceof nativeMap) {
+var keyIterator = parent.keys();
+while(true) {
+var next = keyIterator.next();
+if (next.done) {
+break;
+}
+var keyChild = _clone(next.value, depth - 1);
+var valueChild = _clone(parent.get(next.value), depth - 1);
+child.set(keyChild, valueChild);
+}
+}
+if (parent instanceof nativeSet) {
+var iterator = parent.keys();
+while(true) {
+var next = iterator.next();
+if (next.done) {
+break;
+}
+var entryChild = _clone(next.value, depth - 1);
+child.add(entryChild);
+}
+}
+for (var i in parent) {
+var attrs;
+if (proto) {
+attrs = Object.getOwnPropertyDescriptor(proto, i);
+}
+if (attrs && attrs.set == null) {
+continue;
+}
+child[i] = _clone(parent[i], depth - 1);
+}
+if (Object.getOwnPropertySymbols) {
+var symbols = Object.getOwnPropertySymbols(parent);
+for (var i = 0; i < symbols.length; i++) {
+// Don't need to worry about cloning a symbol because it is a primitive,
+// like a number or string.
+var symbol = symbols[i];
+var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+continue;
+}
+child[symbol] = _clone(parent[symbol], depth - 1);
+if (!descriptor.enumerable) {
+Object.defineProperty(child, symbol, {
+enumerable: false
+});
+}
+}
+}
+if (includeNonEnumerable) {
+var allPropertyNames = Object.getOwnPropertyNames(parent);
+for (var i = 0; i < allPropertyNames.length; i++) {
+var propertyName = allPropertyNames[i];
+var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
+if (descriptor && descriptor.enumerable) {
+continue;
+}
+child[propertyName] = _clone(parent[propertyName], depth - 1);
+Object.defineProperty(child, propertyName, {
+enumerable: false
+});
+}
+}
+return child;
+}
+return _clone(parent, depth);
+}
+/**
+* Simple flat clone using prototype, accepts only objects, usefull for property
+* override on FLAT configuration object (no nested props).
+*
+* USE WITH CAUTION! This may not behave as you wish if you do not know how this
+* works.
+*/
+clone.clonePrototype = function clonePrototype(parent) {
+if (parent === null)
+return null;
+var c = function () {};
+c.prototype = parent;
+return new c();
+};
+// private utility functions
+function __objToStr(o) {
+return Object.prototype.toString.call(o);
+}
+clone.__objToStr = __objToStr;
+function __isDate(o) {
+return typeof o === 'object' && __objToStr(o) === '[object Date]';
+}
+clone.__isDate = __isDate;
+function __isArray(o) {
+return typeof o === 'object' && __objToStr(o) === '[object Array]';
+}
+clone.__isArray = __isArray;
+function __isRegExp(o) {
+return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
+}
+clone.__isRegExp = __isRegExp;
+function __getRegExpFlags(re) {
+var flags = '';
+if (re.global) flags += 'g';
+if (re.ignoreCase) flags += 'i';
+if (re.multiline) flags += 'm';
+return flags;
+}
+clone.__getRegExpFlags = __getRegExpFlags;
+return clone;
+})();
+if (typeof module === 'object' && module.exports) {
+module.exports = clone;
+}
+/**
+* Main CSSLint object.
+* @class CSSLint
+* @static
+* @extends parserlib.util.EventTarget
+*/
+/* global parserlib, clone, Reporter */
+/* exported CSSLint */
+var CSSLint = (function() {
+"use strict";
+var rules           = [],
+formatters      = [],
+embeddedRuleset = /\/\*\s*csslint([^\*]*)\*\//,
+api             = new parserlib.util.EventTarget();
+api.version = "1.0.4";
+//-------------------------------------------------------------------------
+// Rule Management
+//-------------------------------------------------------------------------
+/**
+* Adds a new rule to the engine.
+* @param {Object} rule The rule to add.
+* @method addRule
+*/
+api.addRule = function(rule) {
+rules.push(rule);
+rules[rule.id] = rule;
+};
+/**
+* Clears all rule from the engine.
+* @method clearRules
+*/
+api.clearRules = function() {
+rules = [];
+};
+/**
+* Returns the rule objects.
+* @return An array of rule objects.
+* @method getRules
+*/
+api.getRules = function() {
+return [].concat(rules).sort(function(a, b) {
+return a.id > b.id ? 1 : 0;
+});
+};
+/**
+* Returns a ruleset configuration object with all current rules.
+* @return A ruleset object.
+* @method getRuleset
+*/
+api.getRuleset = function() {
+var ruleset = {},
+i = 0,
+len = rules.length;
+while (i < len) {
+ruleset[rules[i++].id] = 1;    // by default, everything is a warning
+}
+return ruleset;
+};
+/**
+* Returns a ruleset object based on embedded rules.
+* @param {String} text A string of css containing embedded rules.
+* @param {Object} ruleset A ruleset object to modify.
+* @return {Object} A ruleset object.
+* @method getEmbeddedRuleset
+*/
+function applyEmbeddedRuleset(text, ruleset) {
+var valueMap,
+embedded = text && text.match(embeddedRuleset),
+rules = embedded && embedded[1];
+if (rules) {
+valueMap = {
+"true": 2,  // true is error
+"": 1,      // blank is warning
+"false": 0, // false is ignore
+"2": 2,     // explicit error
+"1": 1,     // explicit warning
+"0": 0      // explicit ignore
+};
+rules.toLowerCase().split(",").forEach(function(rule) {
+var pair = rule.split(":"),
+property = pair[0] || "",
+value = pair[1] || "";
+ruleset[property.trim()] = valueMap[value.trim()];
+});
+}
+return ruleset;
+}
+//-------------------------------------------------------------------------
+// Formatters
+//-------------------------------------------------------------------------
+/**
+* Adds a new formatter to the engine.
+* @param {Object} formatter The formatter to add.
+* @method addFormatter
+*/
+api.addFormatter = function(formatter) {
+// formatters.push(formatter);
+formatters[formatter.id] = formatter;
+};
+/**
+* Retrieves a formatter for use.
+* @param {String} formatId The name of the format to retrieve.
+* @return {Object} The formatter or undefined.
+* @method getFormatter
+*/
+api.getFormatter = function(formatId) {
+return formatters[formatId];
+};
+/**
+* Formats the results in a particular format for a single file.
+* @param {Object} result The results returned from CSSLint.verify().
+* @param {String} filename The filename for which the results apply.
+* @param {String} formatId The name of the formatter to use.
+* @param {Object} options (Optional) for special output handling.
+* @return {String} A formatted string for the results.
+* @method format
+*/
+api.format = function(results, filename, formatId, options) {
+var formatter = this.getFormatter(formatId),
+result = null;
+if (formatter) {
+result = formatter.startFormat();
+result += formatter.formatResults(results, filename, options || {});
+result += formatter.endFormat();
+}
+return result;
+};
+/**
+* Indicates if the given format is supported.
+* @param {String} formatId The ID of the format to check.
+* @return {Boolean} True if the format exists, false if not.
+* @method hasFormat
+*/
+api.hasFormat = function(formatId) {
+return formatters.hasOwnProperty(formatId);
+};
+//-------------------------------------------------------------------------
+// Verification
+//-------------------------------------------------------------------------
+/**
+* Starts the verification process for the given CSS text.
+* @param {String} text The CSS text to verify.
+* @param {Object} ruleset (Optional) List of rules to apply. If null, then
+*      all rules are used. If a rule has a value of 1 then it's a warning,
+*      a value of 2 means it's an error.
+* @return {Object} Results of the verification.
+* @method verify
+*/
+api.verify = function(text, ruleset) {
+var i = 0,
+reporter,
+lines,
+allow = {},
+ignore = [],
+report,
+parser = new parserlib.css.Parser({
+starHack: true,
+ieFilters: true,
+underscoreHack: true,
+strict: false
+});
+// normalize line endings
+lines = text.replace(/\n\r?/g, "$split$").split("$split$");
+// find 'allow' comments
+CSSLint.Util.forEach(lines, function (line, lineno) {
+var allowLine = line && line.match(/\/\*[ \t]*csslint[ \t]+allow:[ \t]*([^\*]*)\*\//i),
+allowRules = allowLine && allowLine[1],
+allowRuleset = {};
+if (allowRules) {
+allowRules.toLowerCase().split(",").forEach(function(allowRule) {
+allowRuleset[allowRule.trim()] = true;
+});
+if (Object.keys(allowRuleset).length > 0) {
+allow[lineno + 1] = allowRuleset;
+}
+}
+});
+var ignoreStart = null,
+ignoreEnd = null;
+CSSLint.Util.forEach(lines, function (line, lineno) {
+// Keep oldest, "unclosest" ignore:start
+if (ignoreStart === null && line.match(/\/\*[ \t]*csslint[ \t]+ignore:start[ \t]*\*\//i)) {
+ignoreStart = lineno;
+}
+if (line.match(/\/\*[ \t]*csslint[ \t]+ignore:end[ \t]*\*\//i)) {
+ignoreEnd = lineno;
+}
+if (ignoreStart !== null && ignoreEnd !== null) {
+ignore.push([ignoreStart, ignoreEnd]);
+ignoreStart = ignoreEnd = null;
+}
+});
+// Close remaining ignore block, if any
+if (ignoreStart !== null) {
+ignore.push([ignoreStart, lines.length]);
+}
+if (!ruleset) {
+ruleset = this.getRuleset();
+}
+if (embeddedRuleset.test(text)) {
+// defensively copy so that caller's version does not get modified
+ruleset = clone(ruleset);
+ruleset = applyEmbeddedRuleset(text, ruleset);
+}
+reporter = new Reporter(lines, ruleset, allow, ignore);
+ruleset.errors = 2;       // always report parsing errors as errors
+for (i in ruleset) {
+if (ruleset.hasOwnProperty(i) && ruleset[i]) {
+if (rules[i]) {
+rules[i].init(parser, reporter);
+}
+}
+}
+// capture most horrible error type
+try {
+parser.parse(text);
+} catch (ex) {
+reporter.error("Fatal error, cannot continue: " + ex.message, ex.line, ex.col, {});
+}
+report = {
+messages    : reporter.messages,
+stats       : reporter.stats,
+ruleset     : reporter.ruleset,
+allow       : reporter.allow,
+ignore      : reporter.ignore
+};
+// sort by line numbers, rollups at the bottom
+report.messages.sort(function (a, b) {
+if (a.rollup && !b.rollup) {
+return 1;
+} else if (!a.rollup && b.rollup) {
+return -1;
+} else {
+return a.line - b.line;
+}
+});
+return report;
+};
+//-------------------------------------------------------------------------
+// Publish the API
+//-------------------------------------------------------------------------
+return api;
+})();
+/**
+* An instance of Report is used to report results of the
+* verification back to the main API.
+* @class Reporter
+* @constructor
+* @param {String[]} lines The text lines of the source.
+* @param {Object} ruleset The set of rules to work with, including if
+*      they are errors or warnings.
+* @param {Object} explicitly allowed lines
+* @param {[][]} ingore list of line ranges to be ignored
+*/
+function Reporter(lines, ruleset, allow, ignore) {
+"use strict";
+/**
+* List of messages being reported.
+* @property messages
+* @type String[]
+*/
+this.messages = [];
+/**
+* List of statistics being reported.
+* @property stats
+* @type String[]
+*/
+this.stats = [];
+/**
+* Lines of code being reported on. Used to provide contextual information
+* for messages.
+* @property lines
+* @type String[]
+*/
+this.lines = lines;
+/**
+* Information about the rules. Used to determine whether an issue is an
+* error or warning.
+* @property ruleset
+* @type Object
+*/
+this.ruleset = ruleset;
+/**
+* Lines with specific rule messages to leave out of the report.
+* @property allow
+* @type Object
+*/
+this.allow = allow;
+if (!this.allow) {
+this.allow = {};
+}
+/**
+* Linesets not to include in the report.
+* @property ignore
+* @type [][]
+*/
+this.ignore = ignore;
+if (!this.ignore) {
+this.ignore = [];
+}
+}
+Reporter.prototype = {
+// restore constructor
+constructor: Reporter,
+/**
+* Report an error.
+* @param {String} message The message to store.
+* @param {int} line The line number.
+* @param {int} col The column number.
+* @param {Object} rule The rule this message relates to.
+* @method error
+*/
+error: function(message, line, col, rule) {
+"use strict";
+this.messages.push({
+type    : "error",
+line    : line,
+col     : col,
+message : message,
+evidence: this.lines[line-1],
+rule    : rule || {}
+});
+},
+/**
+* Report an warning.
+* @param {String} message The message to store.
+* @param {int} line The line number.
+* @param {int} col The column number.
+* @param {Object} rule The rule this message relates to.
+* @method warn
+* @deprecated Use report instead.
+*/
+warn: function(message, line, col, rule) {
+"use strict";
+this.report(message, line, col, rule);
+},
+/**
+* Report an issue.
+* @param {String} message The message to store.
+* @param {int} line The line number.
+* @param {int} col The column number.
+* @param {Object} rule The rule this message relates to.
+* @method report
+*/
+report: function(message, line, col, rule) {
+"use strict";
+// Check if rule violation should be allowed
+if (this.allow.hasOwnProperty(line) && this.allow[line].hasOwnProperty(rule.id)) {
+return;
+}
+var ignore = false;
+CSSLint.Util.forEach(this.ignore, function (range) {
+if (range[0] <= line && line <= range[1]) {
+ignore = true;
+}
+});
+if (ignore) {
+return;
+}
+this.messages.push({
+type    : this.ruleset[rule.id] === 2 ? "error" : "warning",
+line    : line,
+col     : col,
+message : message,
+evidence: this.lines[line-1],
+rule    : rule
+});
+},
+/**
+* Report some informational text.
+* @param {String} message The message to store.
+* @param {int} line The line number.
+* @param {int} col The column number.
+* @param {Object} rule The rule this message relates to.
+* @method info
+*/
+info: function(message, line, col, rule) {
+"use strict";
+this.messages.push({
+type    : "info",
+line    : line,
+col     : col,
+message : message,
+evidence: this.lines[line-1],
+rule    : rule
+});
+},
+/**
+* Report some rollup error information.
+* @param {String} message The message to store.
+* @param {Object} rule The rule this message relates to.
+* @method rollupError
+*/
+rollupError: function(message, rule) {
+"use strict";
+this.messages.push({
+type    : "error",
+rollup  : true,
+message : message,
+rule    : rule
+});
+},
+/**
+* Report some rollup warning information.
+* @param {String} message The message to store.
+* @param {Object} rule The rule this message relates to.
+* @method rollupWarn
+*/
+rollupWarn: function(message, rule) {
+"use strict";
+this.messages.push({
+type    : "warning",
+rollup  : true,
+message : message,
+rule    : rule
+});
+},
+/**
+* Report a statistic.
+* @param {String} name The name of the stat to store.
+* @param {Variant} value The value of the stat.
+* @method stat
+*/
+stat: function(name, value) {
+"use strict";
+this.stats[name] = value;
+}
+};
+// expose for testing purposes
+CSSLint._Reporter = Reporter;
+/*
+* Utility functions that make life easier.
+*/
+CSSLint.Util = {
+/*
+* Adds all properties from supplier onto receiver,
+* overwriting if the same name already exists on
+* receiver.
+* @param {Object} The object to receive the properties.
+* @param {Object} The object to provide the properties.
+* @return {Object} The receiver
+*/
+mix: function(receiver, supplier) {
+"use strict";
+var prop;
+for (prop in supplier) {
+if (supplier.hasOwnProperty(prop)) {
+receiver[prop] = supplier[prop];
+}
+}
+return prop;
+},
+/*
+* Polyfill for array indexOf() method.
+* @param {Array} values The array to search.
+* @param {Variant} value The value to search for.
+* @return {int} The index of the value if found, -1 if not.
+*/
+indexOf: function(values, value) {
+"use strict";
+if (values.indexOf) {
+return values.indexOf(value);
+} else {
+for (var i=0, len=values.length; i < len; i++) {
+if (values[i] === value) {
+return i;
+}
+}
+return -1;
+}
+},
+/*
+* Polyfill for array forEach() method.
+* @param {Array} values The array to operate on.
+* @param {Function} func The function to call on each item.
+* @return {void}
+*/
+forEach: function(values, func) {
+"use strict";
+if (values.forEach) {
+return values.forEach(func);
+} else {
+for (var i=0, len=values.length; i < len; i++) {
+func(values[i], i, values);
+}
+}
+}
+};
+/*
+* Rule: Don't use adjoining classes (.foo.bar).
+*/
+CSSLint.addRule({
+// rule information
+id: "adjoining-classes",
+name: "Disallow adjoining classes",
+desc: "Don't use adjoining classes.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-adjoining-classes",
+browsers: "IE6",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+modifier,
+classCount,
+i, j, k;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+for (j=0; j < selector.parts.length; j++) {
+part = selector.parts[j];
+if (part.type === parser.SELECTOR_PART_TYPE) {
+classCount = 0;
+for (k=0; k < part.modifiers.length; k++) {
+modifier = part.modifiers[k];
+if (modifier.type === "class") {
+classCount++;
+}
+if (classCount > 1){
+reporter.report("Adjoining classes: "+selectors[i].text, part.line, part.col, rule);
+}
+}
+}
+}
+}
+});
+}
+});
+/*
+* Rule: Don't use width or height when using padding or border.
+*/
+CSSLint.addRule({
+// rule information
+id: "box-model",
+name: "Beware of broken box size",
+desc: "Don't use width or height when using padding or border.",
+url: "https://github.com/CSSLint/csslint/wiki/Beware-of-box-model-size",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+widthProperties = {
+border: 1,
+"border-left": 1,
+"border-right": 1,
+padding: 1,
+"padding-left": 1,
+"padding-right": 1
+},
+heightProperties = {
+border: 1,
+"border-bottom": 1,
+"border-top": 1,
+padding: 1,
+"padding-bottom": 1,
+"padding-top": 1
+},
+properties,
+boxSizing = false;
+function startRule() {
+properties = {};
+boxSizing = false;
+}
+function endRule() {
+var prop, value;
+if (!boxSizing) {
+if (properties.height) {
+for (prop in heightProperties) {
+if (heightProperties.hasOwnProperty(prop) && properties[prop]) {
+value = properties[prop].value;
+// special case for padding
+if (!(prop === "padding" && value.parts.length === 2 && value.parts[0].value === 0)) {
+reporter.report("Using height with " + prop + " can sometimes make elements larger than you expect.", properties[prop].line, properties[prop].col, rule);
+}
+}
+}
+}
+if (properties.width) {
+for (prop in widthProperties) {
+if (widthProperties.hasOwnProperty(prop) && properties[prop]) {
+value = properties[prop].value;
+if (!(prop === "padding" && value.parts.length === 2 && value.parts[1].value === 0)) {
+reporter.report("Using width with " + prop + " can sometimes make elements larger than you expect.", properties[prop].line, properties[prop].col, rule);
+}
+}
+}
+}
+}
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var name = event.property.text.toLowerCase();
+if (heightProperties[name] || widthProperties[name]) {
+if (!/^0\S*$/.test(event.value) && !(name === "border" && event.value.toString() === "none")) {
+properties[name] = {
+line: event.property.line,
+col: event.property.col,
+value: event.value
+};
+}
+} else {
+if (/^(width|height)/i.test(name) && /^(length|percentage)/.test(event.value.parts[0].type)) {
+properties[name] = 1;
+} else if (name === "box-sizing") {
+boxSizing = true;
+}
+}
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+parser.addListener("endpage", endRule);
+parser.addListener("endpagemargin", endRule);
+parser.addListener("endkeyframerule", endRule);
+parser.addListener("endviewport", endRule);
+}
+});
+/*
+* Rule: box-sizing doesn't work in IE6 and IE7.
+*/
+CSSLint.addRule({
+// rule information
+id: "box-sizing",
+name: "Disallow use of box-sizing",
+desc: "The box-sizing properties isn't supported in IE6 and IE7.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-box-sizing",
+browsers: "IE6, IE7",
+tags: ["Compatibility"],
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("property", function(event) {
+var name = event.property.text.toLowerCase();
+if (name === "box-sizing") {
+reporter.report("The box-sizing property isn't supported in IE6 and IE7.", event.line, event.col, rule);
+}
+});
+}
+});
+/*
+* Rule: Use the bulletproof @font-face syntax to avoid 404's in old IE
+* (http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax)
+*/
+CSSLint.addRule({
+// rule information
+id: "bulletproof-font-face",
+name: "Use the bulletproof @font-face syntax",
+desc: "Use the bulletproof @font-face syntax to avoid 404's in old IE (http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax).",
+url: "https://github.com/CSSLint/csslint/wiki/Bulletproof-font-face",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+fontFaceRule = false,
+firstSrc = true,
+ruleFailed = false,
+line, col;
+// Mark the start of a @font-face declaration so we only test properties inside it
+parser.addListener("startfontface", function() {
+fontFaceRule = true;
+});
+parser.addListener("property", function(event) {
+// If we aren't inside an @font-face declaration then just return
+if (!fontFaceRule) {
+return;
+}
+var propertyName = event.property.toString().toLowerCase(),
+value = event.value.toString();
+// Set the line and col numbers for use in the endfontface listener
+line = event.line;
+col = event.col;
+// This is the property that we care about, we can ignore the rest
+if (propertyName === "src") {
+var regex = /^\s?url\(['"].+\.eot\?.*['"]\)\s*format\(['"]embedded-opentype['"]\).*$/i;
+// We need to handle the advanced syntax with two src properties
+if (!value.match(regex) && firstSrc) {
+ruleFailed = true;
+firstSrc = false;
+} else if (value.match(regex) && !firstSrc) {
+ruleFailed = false;
+}
+}
+});
+// Back to normal rules that we don't need to test
+parser.addListener("endfontface", function() {
+fontFaceRule = false;
+if (ruleFailed) {
+reporter.report("@font-face declaration doesn't follow the fontspring bulletproof syntax.", line, col, rule);
+}
+});
+}
+});
+/*
+* Rule: Include all compatible vendor prefixes to reach a wider
+* range of users.
+*/
+CSSLint.addRule({
+// rule information
+id: "compatible-vendor-prefixes",
+name: "Require compatible vendor prefixes",
+desc: "Include all compatible vendor prefixes to reach a wider range of users.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-compatible-vendor-prefixes",
+browsers: "All",
+// initialization
+init: function (parser, reporter) {
+"use strict";
+var rule = this,
+compatiblePrefixes,
+properties,
+prop,
+variations,
+prefixed,
+i,
+len,
+inKeyFrame = false,
+arrayPush = Array.prototype.push,
+applyTo = [];
+// See http://peter.sh/experiments/vendor-prefixed-css-property-overview/ for details
+compatiblePrefixes = {
+"animation"                  : "webkit",
+"animation-delay"            : "webkit",
+"animation-direction"        : "webkit",
+"animation-duration"         : "webkit",
+"animation-fill-mode"        : "webkit",
+"animation-iteration-count"  : "webkit",
+"animation-name"             : "webkit",
+"animation-play-state"       : "webkit",
+"animation-timing-function"  : "webkit",
+"appearance"                 : "webkit moz",
+"border-end"                 : "webkit moz",
+"border-end-color"           : "webkit moz",
+"border-end-style"           : "webkit moz",
+"border-end-width"           : "webkit moz",
+"border-image"               : "webkit moz o",
+"border-radius"              : "webkit",
+"border-start"               : "webkit moz",
+"border-start-color"         : "webkit moz",
+"border-start-style"         : "webkit moz",
+"border-start-width"         : "webkit moz",
+"box-align"                  : "webkit moz ms",
+"box-direction"              : "webkit moz ms",
+"box-flex"                   : "webkit moz ms",
+"box-lines"                  : "webkit ms",
+"box-ordinal-group"          : "webkit moz ms",
+"box-orient"                 : "webkit moz ms",
+"box-pack"                   : "webkit moz ms",
+"box-sizing"                 : "",
+"box-shadow"                 : "",
+"column-count"               : "webkit moz ms",
+"column-gap"                 : "webkit moz ms",
+"column-rule"                : "webkit moz ms",
+"column-rule-color"          : "webkit moz ms",
+"column-rule-style"          : "webkit moz ms",
+"column-rule-width"          : "webkit moz ms",
+"column-width"               : "webkit moz ms",
+"hyphens"                    : "epub moz",
+"line-break"                 : "webkit ms",
+"margin-end"                 : "webkit moz",
+"margin-start"               : "webkit moz",
+"marquee-speed"              : "webkit wap",
+"marquee-style"              : "webkit wap",
+"padding-end"                : "webkit moz",
+"padding-start"              : "webkit moz",
+"tab-size"                   : "moz o",
+"text-size-adjust"           : "webkit ms",
+"transform"                  : "webkit ms",
+"transform-origin"           : "webkit ms",
+"transition"                 : "",
+"transition-delay"           : "",
+"transition-duration"        : "",
+"transition-property"        : "",
+"transition-timing-function" : "",
+"user-modify"                : "webkit moz",
+"user-select"                : "webkit moz ms",
+"word-break"                 : "epub ms",
+"writing-mode"               : "epub ms"
+};
+for (prop in compatiblePrefixes) {
+if (compatiblePrefixes.hasOwnProperty(prop)) {
+variations = [];
+prefixed = compatiblePrefixes[prop].split(" ");
+for (i = 0, len = prefixed.length; i < len; i++) {
+variations.push("-" + prefixed[i] + "-" + prop);
+}
+compatiblePrefixes[prop] = variations;
+arrayPush.apply(applyTo, variations);
+}
+}
+parser.addListener("startrule", function () {
+properties = [];
+});
+parser.addListener("startkeyframes", function (event) {
+inKeyFrame = event.prefix || true;
+});
+parser.addListener("endkeyframes", function () {
+inKeyFrame = false;
+});
+parser.addListener("property", function (event) {
+var name = event.property;
+if (CSSLint.Util.indexOf(applyTo, name.text) > -1) {
+// e.g., -moz-transform is okay to be alone in @-moz-keyframes
+if (!inKeyFrame || typeof inKeyFrame !== "string" ||
+name.text.indexOf("-" + inKeyFrame + "-") !== 0) {
+properties.push(name);
+}
+}
+});
+parser.addListener("endrule", function () {
+if (!properties.length) {
+return;
+}
+var propertyGroups = {},
+i,
+len,
+name,
+prop,
+variations,
+value,
+full,
+actual,
+item,
+propertiesSpecified;
+for (i = 0, len = properties.length; i < len; i++) {
+name = properties[i];
+for (prop in compatiblePrefixes) {
+if (compatiblePrefixes.hasOwnProperty(prop)) {
+variations = compatiblePrefixes[prop];
+if (CSSLint.Util.indexOf(variations, name.text) > -1) {
+if (!propertyGroups[prop]) {
+propertyGroups[prop] = {
+full: variations.slice(0),
+actual: [],
+actualNodes: []
+};
+}
+if (CSSLint.Util.indexOf(propertyGroups[prop].actual, name.text) === -1) {
+propertyGroups[prop].actual.push(name.text);
+propertyGroups[prop].actualNodes.push(name);
+}
+}
+}
+}
+}
+for (prop in propertyGroups) {
+if (propertyGroups.hasOwnProperty(prop)) {
+value = propertyGroups[prop];
+full = value.full;
+actual = value.actual;
+if (full.length > actual.length) {
+for (i = 0, len = full.length; i < len; i++) {
+item = full[i];
+if (CSSLint.Util.indexOf(actual, item) === -1) {
+propertiesSpecified = (actual.length === 1) ? actual[0] : (actual.length === 2) ? actual.join(" and ") : actual.join(", ");
+reporter.report("The property " + item + " is compatible with " + propertiesSpecified + " and should be included as well.", value.actualNodes[0].line, value.actualNodes[0].col, rule);
+}
+}
+}
+}
+}
+});
+}
+});
+/*
+* Rule: Certain properties don't play well with certain display values.
+* - float should not be used with inline-block
+* - height, width, margin-top, margin-bottom, float should not be used with inline
+* - vertical-align should not be used with block
+* - margin, float should not be used with table-*
+*/
+CSSLint.addRule({
+// rule information
+id: "display-property-grouping",
+name: "Require properties appropriate for display",
+desc: "Certain properties shouldn't be used with certain display property values.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-properties-appropriate-for-display",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+var propertiesToCheck = {
+display: 1,
+"float": "none",
+height: 1,
+width: 1,
+margin: 1,
+"margin-left": 1,
+"margin-right": 1,
+"margin-bottom": 1,
+"margin-top": 1,
+padding: 1,
+"padding-left": 1,
+"padding-right": 1,
+"padding-bottom": 1,
+"padding-top": 1,
+"vertical-align": 1
+},
+properties;
+function reportProperty(name, display, msg) {
+if (properties[name]) {
+if (typeof propertiesToCheck[name] !== "string" || properties[name].value.toLowerCase() !== propertiesToCheck[name]) {
+reporter.report(msg || name + " can't be used with display: " + display + ".", properties[name].line, properties[name].col, rule);
+}
+}
+}
+function startRule() {
+properties = {};
+}
+function endRule() {
+var display = properties.display ? properties.display.value : null;
+if (display) {
+switch (display) {
+case "inline":
+// height, width, margin-top, margin-bottom, float should not be used with inline
+reportProperty("height", display);
+reportProperty("width", display);
+reportProperty("margin", display);
+reportProperty("margin-top", display);
+reportProperty("margin-bottom", display);
+reportProperty("float", display, "display:inline has no effect on floated elements (but may be used to fix the IE6 double-margin bug).");
+break;
+case "block":
+// vertical-align should not be used with block
+reportProperty("vertical-align", display);
+break;
+case "inline-block":
+// float should not be used with inline-block
+reportProperty("float", display);
+break;
+default:
+// margin, float should not be used with table
+if (display.indexOf("table-") === 0) {
+reportProperty("margin", display);
+reportProperty("margin-left", display);
+reportProperty("margin-right", display);
+reportProperty("margin-top", display);
+reportProperty("margin-bottom", display);
+reportProperty("float", display);
+}
+// otherwise do nothing
+}
+}
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var name = event.property.text.toLowerCase();
+if (propertiesToCheck[name]) {
+properties[name] = {
+value: event.value.text,
+line: event.property.line,
+col: event.property.col
+};
+}
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+parser.addListener("endkeyframerule", endRule);
+parser.addListener("endpagemargin", endRule);
+parser.addListener("endpage", endRule);
+parser.addListener("endviewport", endRule);
+}
+});
+/*
+* Rule: Disallow duplicate background-images (using url).
+*/
+CSSLint.addRule({
+// rule information
+id: "duplicate-background-images",
+name: "Disallow duplicate background images",
+desc: "Every background-image should be unique. Use a common class for e.g. sprites.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-duplicate-background-images",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+stack = {};
+parser.addListener("property", function(event) {
+var name = event.property.text,
+value = event.value,
+i, len;
+if (name.match(/background/i)) {
+for (i=0, len=value.parts.length; i < len; i++) {
+if (value.parts[i].type === "uri") {
+if (typeof stack[value.parts[i].uri] === "undefined") {
+stack[value.parts[i].uri] = event;
+} else {
+reporter.report("Background image '" + value.parts[i].uri + "' was used multiple times, first declared at line " + stack[value.parts[i].uri].line + ", col " + stack[value.parts[i].uri].col + ".", event.line, event.col, rule);
+}
+}
+}
+}
+});
+}
+});
+/*
+* Rule: Duplicate properties must appear one after the other. If an already-defined
+* property appears somewhere else in the rule, then it's likely an error.
+*/
+CSSLint.addRule({
+// rule information
+id: "duplicate-properties",
+name: "Disallow duplicate properties",
+desc: "Duplicate properties must appear one after the other.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-duplicate-properties",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+properties,
+lastProperty;
+function startRule() {
+properties = {};
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var property = event.property,
+name = property.text.toLowerCase();
+if (properties[name] && (lastProperty !== name || properties[name] === event.value.text)) {
+reporter.report("Duplicate property '" + event.property + "' found.", event.line, event.col, rule);
+}
+properties[name] = event.value.text;
+lastProperty = name;
+});
+}
+});
+/*
+* Rule: Style rules without any properties defined should be removed.
+*/
+CSSLint.addRule({
+// rule information
+id: "empty-rules",
+name: "Disallow empty rules",
+desc: "Rules without any properties specified should be removed.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-empty-rules",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+count = 0;
+parser.addListener("startrule", function() {
+count=0;
+});
+parser.addListener("property", function() {
+count++;
+});
+parser.addListener("endrule", function(event) {
+var selectors = event.selectors;
+if (count === 0) {
+reporter.report("Rule is empty.", selectors[0].line, selectors[0].col, rule);
+}
+});
+}
+});
+/*
+* Rule: There should be no syntax errors. (Duh.)
+*/
+CSSLint.addRule({
+// rule information
+id: "errors",
+name: "Parsing Errors",
+desc: "This rule looks for recoverable syntax errors.",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("error", function(event) {
+reporter.error(event.message, event.line, event.col, rule);
+});
+}
+});
+CSSLint.addRule({
+// rule information
+id: "fallback-colors",
+name: "Require fallback colors",
+desc: "For older browsers that don't support RGBA, HSL, or HSLA, provide a fallback color.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-fallback-colors",
+browsers: "IE6,IE7,IE8",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+lastProperty,
+propertiesToCheck = {
+color: 1,
+background: 1,
+"border-color": 1,
+"border-top-color": 1,
+"border-right-color": 1,
+"border-bottom-color": 1,
+"border-left-color": 1,
+border: 1,
+"border-top": 1,
+"border-right": 1,
+"border-bottom": 1,
+"border-left": 1,
+"background-color": 1
+};
+function startRule() {
+lastProperty = null;
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var property = event.property,
+name = property.text.toLowerCase(),
+parts = event.value.parts,
+i = 0,
+colorType = "",
+len = parts.length;
+if (propertiesToCheck[name]) {
+while (i < len) {
+if (parts[i].type === "color") {
+if ("alpha" in parts[i] || "hue" in parts[i]) {
+if (/([^\)]+)\(/.test(parts[i])) {
+colorType = RegExp.$1.toUpperCase();
+}
+if (!lastProperty || (lastProperty.property.text.toLowerCase() !== name || lastProperty.colorType !== "compat")) {
+reporter.report("Fallback " + name + " (hex or RGB) should precede " + colorType + " " + name + ".", event.line, event.col, rule);
+}
+} else {
+event.colorType = "compat";
+}
+}
+i++;
+}
+}
+lastProperty = event;
+});
+}
+});
+/*
+* Rule: You shouldn't use more than 10 floats. If you do, there's probably
+* room for some abstraction.
+*/
+CSSLint.addRule({
+// rule information
+id: "floats",
+name: "Disallow too many floats",
+desc: "This rule tests if the float property is used too many times",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-too-many-floats",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+var count = 0;
+// count how many times "float" is used
+parser.addListener("property", function(event) {
+if (event.property.text.toLowerCase() === "float" &&
+event.value.text.toLowerCase() !== "none") {
+count++;
+}
+});
+// report the results
+parser.addListener("endstylesheet", function() {
+reporter.stat("floats", count);
+if (count >= 10) {
+reporter.rollupWarn("Too many floats (" + count + "), you're probably using them for layout. Consider using a grid system instead.", rule);
+}
+});
+}
+});
+/*
+* Rule: Avoid too many @font-face declarations in the same stylesheet.
+*/
+CSSLint.addRule({
+// rule information
+id: "font-faces",
+name: "Don't use too many web fonts",
+desc: "Too many different web fonts in the same stylesheet.",
+url: "https://github.com/CSSLint/csslint/wiki/Don%27t-use-too-many-web-fonts",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+count = 0;
+parser.addListener("startfontface", function() {
+count++;
+});
+parser.addListener("endstylesheet", function() {
+if (count > 5) {
+reporter.rollupWarn("Too many @font-face declarations (" + count + ").", rule);
+}
+});
+}
+});
+/*
+* Rule: You shouldn't need more than 9 font-size declarations.
+*/
+CSSLint.addRule({
+// rule information
+id: "font-sizes",
+name: "Disallow too many font sizes",
+desc: "Checks the number of font-size declarations.",
+url: "https://github.com/CSSLint/csslint/wiki/Don%27t-use-too-many-font-size-declarations",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+count = 0;
+// check for use of "font-size"
+parser.addListener("property", function(event) {
+if (event.property.toString() === "font-size") {
+count++;
+}
+});
+// report the results
+parser.addListener("endstylesheet", function() {
+reporter.stat("font-sizes", count);
+if (count >= 10) {
+reporter.rollupWarn("Too many font-size declarations (" + count + "), abstraction needed.", rule);
+}
+});
+}
+});
+/*
+* Rule: When using a vendor-prefixed gradient, make sure to use them all.
+*/
+CSSLint.addRule({
+// rule information
+id: "gradients",
+name: "Require all gradient definitions",
+desc: "When using a vendor-prefixed gradient, make sure to use them all.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-all-gradient-definitions",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+gradients;
+parser.addListener("startrule", function() {
+gradients = {
+moz: 0,
+webkit: 0,
+oldWebkit: 0,
+o: 0
+};
+});
+parser.addListener("property", function(event) {
+if (/\-(moz|o|webkit)(?:\-(?:linear|radial))\-gradient/i.test(event.value)) {
+gradients[RegExp.$1] = 1;
+} else if (/\-webkit\-gradient/i.test(event.value)) {
+gradients.oldWebkit = 1;
+}
+});
+parser.addListener("endrule", function(event) {
+var missing = [];
+if (!gradients.moz) {
+missing.push("Firefox 3.6+");
+}
+if (!gradients.webkit) {
+missing.push("Webkit (Safari 5+, Chrome)");
+}
+if (!gradients.oldWebkit) {
+missing.push("Old Webkit (Safari 4+, Chrome)");
+}
+if (!gradients.o) {
+missing.push("Opera 11.1+");
+}
+if (missing.length && missing.length < 4) {
+reporter.report("Missing vendor-prefixed CSS gradients for " + missing.join(", ") + ".", event.selectors[0].line, event.selectors[0].col, rule);
+}
+});
+}
+});
+/*
+* Rule: Don't use IDs for selectors.
+*/
+CSSLint.addRule({
+// rule information
+id: "ids",
+name: "Disallow IDs in selectors",
+desc: "Selectors should not contain IDs.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-IDs-in-selectors",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+modifier,
+idCount,
+i, j, k;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+idCount = 0;
+for (j=0; j < selector.parts.length; j++) {
+part = selector.parts[j];
+if (part.type === parser.SELECTOR_PART_TYPE) {
+for (k=0; k < part.modifiers.length; k++) {
+modifier = part.modifiers[k];
+if (modifier.type === "id") {
+idCount++;
+}
+}
+}
+}
+if (idCount === 1) {
+reporter.report("Don't use IDs in selectors.", selector.line, selector.col, rule);
+} else if (idCount > 1) {
+reporter.report(idCount + " IDs in the selector, really?", selector.line, selector.col, rule);
+}
+}
+});
+}
+});
+/*
+* Rule: IE6-9 supports up to 31 stylesheet import.
+* Reference:
+* http://blogs.msdn.com/b/ieinternals/archive/2011/05/14/internet-explorer-stylesheet-rule-selector-import-sheet-limit-maximum.aspx
+*/
+CSSLint.addRule({
+// rule information
+id: "import-ie-limit",
+name: "@import limit on IE6-IE9",
+desc: "IE6-9 supports up to 31 @import per stylesheet",
+browsers: "IE6, IE7, IE8, IE9",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+MAX_IMPORT_COUNT = 31,
+count = 0;
+function startPage() {
+count = 0;
+}
+parser.addListener("startpage", startPage);
+parser.addListener("import", function() {
+count++;
+});
+parser.addListener("endstylesheet", function() {
+if (count > MAX_IMPORT_COUNT) {
+reporter.rollupError(
+"Too many @import rules (" + count + "). IE6-9 supports up to 31 import per stylesheet.",
+rule
+);
+}
+});
+}
+});
+/*
+* Rule: Don't use @import, use <link> instead.
+*/
+CSSLint.addRule({
+// rule information
+id: "import",
+name: "Disallow @import",
+desc: "Don't use @import, use <link> instead.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-%40import",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("import", function(event) {
+reporter.report("@import prevents parallel downloads, use <link> instead.", event.line, event.col, rule);
+});
+}
+});
+/*
+* Rule: Make sure !important is not overused, this could lead to specificity
+* war. Display a warning on !important declarations, an error if it's
+* used more at least 10 times.
+*/
+CSSLint.addRule({
+// rule information
+id: "important",
+name: "Disallow !important",
+desc: "Be careful when using !important declaration",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-%21important",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+count = 0;
+// warn that important is used and increment the declaration counter
+parser.addListener("property", function(event) {
+if (event.important === true) {
+count++;
+reporter.report("Use of !important", event.line, event.col, rule);
+}
+});
+// if there are more than 10, show an error
+parser.addListener("endstylesheet", function() {
+reporter.stat("important", count);
+if (count >= 10) {
+reporter.rollupWarn("Too many !important declarations (" + count + "), try to use less than 10 to avoid specificity issues.", rule);
+}
+});
+}
+});
+/*
+* Rule: Properties should be known (listed in CSS3 specification) or
+* be a vendor-prefixed property.
+*/
+CSSLint.addRule({
+// rule information
+id: "known-properties",
+name: "Require use of known properties",
+desc: "Properties should be known (listed in CSS3 specification) or be a vendor-prefixed property.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-use-of-known-properties",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("property", function(event) {
+// the check is handled entirely by the parser-lib (https://github.com/nzakas/parser-lib)
+if (event.invalid) {
+reporter.report(event.invalid.message, event.line, event.col, rule);
+}
+});
+}
+});
+/*
+* Rule: All properties should be in alphabetical order.
+*/
+CSSLint.addRule({
+// rule information
+id: "order-alphabetical",
+name: "Alphabetical order",
+desc: "Assure properties are in alphabetical order",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+properties;
+var startRule = function () {
+properties = [];
+};
+var endRule = function(event) {
+var currentProperties = properties.join(","),
+expectedProperties = properties.sort().join(",");
+if (currentProperties !== expectedProperties) {
+reporter.report("Rule doesn't have all its properties in alphabetical order.", event.line, event.col, rule);
+}
+};
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var name = event.property.text,
+lowerCasePrefixLessName = name.toLowerCase().replace(/^-.*?-/, "");
+properties.push(lowerCasePrefixLessName);
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+parser.addListener("endpage", endRule);
+parser.addListener("endpagemargin", endRule);
+parser.addListener("endkeyframerule", endRule);
+parser.addListener("endviewport", endRule);
+}
+});
+/*
+* Rule: outline: none or outline: 0 should only be used in a :focus rule
+*       and only if there are other properties in the same rule.
+*/
+CSSLint.addRule({
+// rule information
+id: "outline-none",
+name: "Disallow outline: none",
+desc: "Use of outline: none or outline: 0 should be limited to :focus rules.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-outline%3Anone",
+browsers: "All",
+tags: ["Accessibility"],
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+lastRule;
+function startRule(event) {
+if (event.selectors) {
+lastRule = {
+line: event.line,
+col: event.col,
+selectors: event.selectors,
+propCount: 0,
+outline: false
+};
+} else {
+lastRule = null;
+}
+}
+function endRule() {
+if (lastRule) {
+if (lastRule.outline) {
+if (lastRule.selectors.toString().toLowerCase().indexOf(":focus") === -1) {
+reporter.report("Outlines should only be modified using :focus.", lastRule.line, lastRule.col, rule);
+} else if (lastRule.propCount === 1) {
+reporter.report("Outlines shouldn't be hidden unless other visual changes are made.", lastRule.line, lastRule.col, rule);
+}
+}
+}
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var name = event.property.text.toLowerCase(),
+value = event.value;
+if (lastRule) {
+lastRule.propCount++;
+if (name === "outline" && (value.toString() === "none" || value.toString() === "0")) {
+lastRule.outline = true;
+}
+}
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+parser.addListener("endpage", endRule);
+parser.addListener("endpagemargin", endRule);
+parser.addListener("endkeyframerule", endRule);
+parser.addListener("endviewport", endRule);
+}
+});
+/*
+* Rule: Don't use classes or IDs with elements (a.foo or a#foo).
+*/
+CSSLint.addRule({
+// rule information
+id: "overqualified-elements",
+name: "Disallow overqualified elements",
+desc: "Don't use classes or IDs with elements (a.foo or a#foo).",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-overqualified-elements",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+classes = {};
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+modifier,
+i, j, k;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+for (j=0; j < selector.parts.length; j++) {
+part = selector.parts[j];
+if (part.type === parser.SELECTOR_PART_TYPE) {
+for (k=0; k < part.modifiers.length; k++) {
+modifier = part.modifiers[k];
+if (part.elementName && modifier.type === "id") {
+reporter.report("Element (" + part + ") is overqualified, just use " + modifier + " without element name.", part.line, part.col, rule);
+} else if (modifier.type === "class") {
+if (!classes[modifier]) {
+classes[modifier] = [];
+}
+classes[modifier].push({
+modifier: modifier,
+part: part
+});
+}
+}
+}
+}
+}
+});
+parser.addListener("endstylesheet", function() {
+var prop;
+for (prop in classes) {
+if (classes.hasOwnProperty(prop)) {
+// one use means that this is overqualified
+if (classes[prop].length === 1 && classes[prop][0].part.elementName) {
+reporter.report("Element (" + classes[prop][0].part + ") is overqualified, just use " + classes[prop][0].modifier + " without element name.", classes[prop][0].part.line, classes[prop][0].part.col, rule);
+}
+}
+}
+});
+}
+});
+/*
+* Rule: Headings (h1-h6) should not be qualified (namespaced).
+*/
+CSSLint.addRule({
+// rule information
+id: "qualified-headings",
+name: "Disallow qualified headings",
+desc: "Headings should not be qualified (namespaced).",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-qualified-headings",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+i, j;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+for (j=0; j < selector.parts.length; j++) {
+part = selector.parts[j];
+if (part.type === parser.SELECTOR_PART_TYPE) {
+if (part.elementName && /h[1-6]/.test(part.elementName.toString()) && j > 0) {
+reporter.report("Heading (" + part.elementName + ") should not be qualified.", part.line, part.col, rule);
+}
+}
+}
+}
+});
+}
+});
+/*
+* Rule: Selectors that look like regular expressions are slow and should be avoided.
+*/
+CSSLint.addRule({
+// rule information
+id: "regex-selectors",
+name: "Disallow selectors that look like regexs",
+desc: "Selectors that look like regular expressions are slow and should be avoided.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-selectors-that-look-like-regular-expressions",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+modifier,
+i, j, k;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+for (j=0; j < selector.parts.length; j++) {
+part = selector.parts[j];
+if (part.type === parser.SELECTOR_PART_TYPE) {
+for (k=0; k < part.modifiers.length; k++) {
+modifier = part.modifiers[k];
+if (modifier.type === "attribute") {
+if (/([~\|\^\$\*]=)/.test(modifier)) {
+reporter.report("Attribute selectors with " + RegExp.$1 + " are slow!", modifier.line, modifier.col, rule);
+}
+}
+}
+}
+}
+}
+});
+}
+});
+/*
+* Rule: Total number of rules should not exceed x.
+*/
+CSSLint.addRule({
+// rule information
+id: "rules-count",
+name: "Rules Count",
+desc: "Track how many rules there are.",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var count = 0;
+// count each rule
+parser.addListener("startrule", function() {
+count++;
+});
+parser.addListener("endstylesheet", function() {
+reporter.stat("rule-count", count);
+});
+}
+});
+/*
+* Rule: Warn people with approaching the IE 4095 limit
+*/
+CSSLint.addRule({
+// rule information
+id: "selector-max-approaching",
+name: "Warn when approaching the 4095 selector limit for IE",
+desc: "Will warn when selector count is >= 3800 selectors.",
+browsers: "IE",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this, count = 0;
+parser.addListener("startrule", function(event) {
+count += event.selectors.length;
+});
+parser.addListener("endstylesheet", function() {
+if (count >= 3800) {
+reporter.report("You have " + count + " selectors. Internet Explorer supports a maximum of 4095 selectors per stylesheet. Consider refactoring.", 0, 0, rule);
+}
+});
+}
+});
+/*
+* Rule: Warn people past the IE 4095 limit
+*/
+CSSLint.addRule({
+// rule information
+id: "selector-max",
+name: "Error when past the 4095 selector limit for IE",
+desc: "Will error when selector count is > 4095.",
+browsers: "IE",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this, count = 0;
+parser.addListener("startrule", function(event) {
+count += event.selectors.length;
+});
+parser.addListener("endstylesheet", function() {
+if (count > 4095) {
+reporter.report("You have " + count + " selectors. Internet Explorer supports a maximum of 4095 selectors per stylesheet. Consider refactoring.", 0, 0, rule);
+}
+});
+}
+});
+/*
+* Rule: Avoid new-line characters in selectors.
+*/
+CSSLint.addRule({
+// rule information
+id: "selector-newline",
+name: "Disallow new-line characters in selectors",
+desc: "New-line characters in selectors are usually a forgotten comma and not a descendant combinator.",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+function startRule(event) {
+var i, len, selector, p, n, pLen, part, part2, type, currentLine, nextLine,
+selectors = event.selectors;
+for (i = 0, len = selectors.length; i < len; i++) {
+selector = selectors[i];
+for (p = 0, pLen = selector.parts.length; p < pLen; p++) {
+for (n = p + 1; n < pLen; n++) {
+part = selector.parts[p];
+part2 = selector.parts[n];
+type = part.type;
+currentLine = part.line;
+nextLine = part2.line;
+if (type === "descendant" && nextLine > currentLine) {
+reporter.report("newline character found in selector (forgot a comma?)", currentLine, selectors[i].parts[0].col, rule);
+}
+}
+}
+}
+}
+parser.addListener("startrule", startRule);
+}
+});
+/*
+* Rule: Use shorthand properties where possible.
+*
+*/
+CSSLint.addRule({
+// rule information
+id: "shorthand",
+name: "Require shorthand properties",
+desc: "Use shorthand properties where possible.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-shorthand-properties",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+prop, i, len,
+propertiesToCheck = {},
+properties,
+mapping = {
+"margin": [
+"margin-top",
+"margin-bottom",
+"margin-left",
+"margin-right"
+],
+"padding": [
+"padding-top",
+"padding-bottom",
+"padding-left",
+"padding-right"
+]
+};
+// initialize propertiesToCheck
+for (prop in mapping) {
+if (mapping.hasOwnProperty(prop)) {
+for (i=0, len=mapping[prop].length; i < len; i++) {
+propertiesToCheck[mapping[prop][i]] = prop;
+}
+}
+}
+function startRule() {
+properties = {};
+}
+// event handler for end of rules
+function endRule(event) {
+var prop, i, len, total;
+// check which properties this rule has
+for (prop in mapping) {
+if (mapping.hasOwnProperty(prop)) {
+total=0;
+for (i=0, len=mapping[prop].length; i < len; i++) {
+total += properties[mapping[prop][i]] ? 1 : 0;
+}
+if (total === mapping[prop].length) {
+reporter.report("The properties " + mapping[prop].join(", ") + " can be replaced by " + prop + ".", event.line, event.col, rule);
+}
+}
+}
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+// check for use of "font-size"
+parser.addListener("property", function(event) {
+var name = event.property.toString().toLowerCase();
+if (propertiesToCheck[name]) {
+properties[name] = 1;
+}
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+}
+});
+/*
+* Rule: Don't use properties with a star prefix.
+*
+*/
+CSSLint.addRule({
+// rule information
+id: "star-property-hack",
+name: "Disallow properties with a star prefix",
+desc: "Checks for the star property hack (targets IE6/7)",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-star-hack",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+// check if property name starts with "*"
+parser.addListener("property", function(event) {
+var property = event.property;
+if (property.hack === "*") {
+reporter.report("Property with star prefix found.", event.property.line, event.property.col, rule);
+}
+});
+}
+});
+/*
+* Rule: Don't use text-indent for image replacement if you need to support rtl.
+*
+*/
+CSSLint.addRule({
+// rule information
+id: "text-indent",
+name: "Disallow negative text-indent",
+desc: "Checks for text indent less than -99px",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-negative-text-indent",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+textIndent,
+direction;
+function startRule() {
+textIndent = false;
+direction = "inherit";
+}
+// event handler for end of rules
+function endRule() {
+if (textIndent && direction !== "ltr") {
+reporter.report("Negative text-indent doesn't work well with RTL. If you use text-indent for image replacement explicitly set direction for that item to ltr.", textIndent.line, textIndent.col, rule);
+}
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+// check for use of "font-size"
+parser.addListener("property", function(event) {
+var name = event.property.toString().toLowerCase(),
+value = event.value;
+if (name === "text-indent" && value.parts[0].value < -99) {
+textIndent = event.property;
+} else if (name === "direction" && value.toString() === "ltr") {
+direction = "ltr";
+}
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+}
+});
+/*
+* Rule: Don't use properties with a underscore prefix.
+*
+*/
+CSSLint.addRule({
+// rule information
+id: "underscore-property-hack",
+name: "Disallow properties with an underscore prefix",
+desc: "Checks for the underscore property hack (targets IE6)",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-underscore-hack",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+// check if property name starts with "_"
+parser.addListener("property", function(event) {
+var property = event.property;
+if (property.hack === "_") {
+reporter.report("Property with underscore prefix found.", event.property.line, event.property.col, rule);
+}
+});
+}
+});
+/*
+* Rule: Headings (h1-h6) should be defined only once.
+*/
+CSSLint.addRule({
+// rule information
+id: "unique-headings",
+name: "Headings should only be defined once",
+desc: "Headings should be defined only once.",
+url: "https://github.com/CSSLint/csslint/wiki/Headings-should-only-be-defined-once",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+var headings = {
+h1: 0,
+h2: 0,
+h3: 0,
+h4: 0,
+h5: 0,
+h6: 0
+};
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+pseudo,
+i, j;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+part = selector.parts[selector.parts.length-1];
+if (part.elementName && /(h[1-6])/i.test(part.elementName.toString())) {
+for (j=0; j < part.modifiers.length; j++) {
+if (part.modifiers[j].type === "pseudo") {
+pseudo = true;
+break;
+}
+}
+if (!pseudo) {
+headings[RegExp.$1]++;
+if (headings[RegExp.$1] > 1) {
+reporter.report("Heading (" + part.elementName + ") has already been defined.", part.line, part.col, rule);
+}
+}
+}
+}
+});
+parser.addListener("endstylesheet", function() {
+var prop,
+messages = [];
+for (prop in headings) {
+if (headings.hasOwnProperty(prop)) {
+if (headings[prop] > 1) {
+messages.push(headings[prop] + " " + prop + "s");
+}
+}
+}
+if (messages.length) {
+reporter.rollupWarn("You have " + messages.join(", ") + " defined in this stylesheet.", rule);
+}
+});
+}
+});
+/*
+* Rule: Don't use universal selector because it's slow.
+*/
+CSSLint.addRule({
+// rule information
+id: "universal-selector",
+name: "Disallow universal selector",
+desc: "The universal selector (*) is known to be slow.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-universal-selector",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selector,
+part,
+i;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+part = selector.parts[selector.parts.length-1];
+if (part.elementName === "*") {
+reporter.report(rule.desc, part.line, part.col, rule);
+}
+}
+});
+}
+});
+/*
+* Rule: Don't use unqualified attribute selectors because they're just like universal selectors.
+*/
+CSSLint.addRule({
+// rule information
+id: "unqualified-attributes",
+name: "Disallow unqualified attribute selectors",
+desc: "Unqualified attribute selectors are known to be slow.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-unqualified-attribute-selectors",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+parser.addListener("startrule", function(event) {
+var selectors = event.selectors,
+selectorContainsClassOrId = false,
+selector,
+part,
+modifier,
+i, k;
+for (i=0; i < selectors.length; i++) {
+selector = selectors[i];
+part = selector.parts[selector.parts.length-1];
+if (part.type === parser.SELECTOR_PART_TYPE) {
+for (k=0; k < part.modifiers.length; k++) {
+modifier = part.modifiers[k];
+if (modifier.type === "class" || modifier.type === "id") {
+selectorContainsClassOrId = true;
+break;
+}
+}
+if (!selectorContainsClassOrId) {
+for (k=0; k < part.modifiers.length; k++) {
+modifier = part.modifiers[k];
+if (modifier.type === "attribute" && (!part.elementName || part.elementName === "*")) {
+reporter.report(rule.desc, part.line, part.col, rule);
+}
+}
+}
+}
+}
+});
+}
+});
+/*
+* Rule: When using a vendor-prefixed property, make sure to
+* include the standard one.
+*/
+CSSLint.addRule({
+// rule information
+id: "vendor-prefix",
+name: "Require standard property with vendor prefix",
+desc: "When using a vendor-prefixed property, make sure to include the standard one.",
+url: "https://github.com/CSSLint/csslint/wiki/Require-standard-property-with-vendor-prefix",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this,
+properties,
+num,
+propertiesToCheck = {
+"-webkit-border-radius": "border-radius",
+"-webkit-border-top-left-radius": "border-top-left-radius",
+"-webkit-border-top-right-radius": "border-top-right-radius",
+"-webkit-border-bottom-left-radius": "border-bottom-left-radius",
+"-webkit-border-bottom-right-radius": "border-bottom-right-radius",
+"-o-border-radius": "border-radius",
+"-o-border-top-left-radius": "border-top-left-radius",
+"-o-border-top-right-radius": "border-top-right-radius",
+"-o-border-bottom-left-radius": "border-bottom-left-radius",
+"-o-border-bottom-right-radius": "border-bottom-right-radius",
+"-moz-border-radius": "border-radius",
+"-moz-border-radius-topleft": "border-top-left-radius",
+"-moz-border-radius-topright": "border-top-right-radius",
+"-moz-border-radius-bottomleft": "border-bottom-left-radius",
+"-moz-border-radius-bottomright": "border-bottom-right-radius",
+"-moz-column-count": "column-count",
+"-webkit-column-count": "column-count",
+"-moz-column-gap": "column-gap",
+"-webkit-column-gap": "column-gap",
+"-moz-column-rule": "column-rule",
+"-webkit-column-rule": "column-rule",
+"-moz-column-rule-style": "column-rule-style",
+"-webkit-column-rule-style": "column-rule-style",
+"-moz-column-rule-color": "column-rule-color",
+"-webkit-column-rule-color": "column-rule-color",
+"-moz-column-rule-width": "column-rule-width",
+"-webkit-column-rule-width": "column-rule-width",
+"-moz-column-width": "column-width",
+"-webkit-column-width": "column-width",
+"-webkit-column-span": "column-span",
+"-webkit-columns": "columns",
+"-moz-box-shadow": "box-shadow",
+"-webkit-box-shadow": "box-shadow",
+"-moz-transform": "transform",
+"-webkit-transform": "transform",
+"-o-transform": "transform",
+"-ms-transform": "transform",
+"-moz-transform-origin": "transform-origin",
+"-webkit-transform-origin": "transform-origin",
+"-o-transform-origin": "transform-origin",
+"-ms-transform-origin": "transform-origin",
+"-moz-box-sizing": "box-sizing",
+"-webkit-box-sizing": "box-sizing"
+};
+// event handler for beginning of rules
+function startRule() {
+properties = {};
+num = 1;
+}
+// event handler for end of rules
+function endRule() {
+var prop,
+i,
+len,
+needed,
+actual,
+needsStandard = [];
+for (prop in properties) {
+if (propertiesToCheck[prop]) {
+needsStandard.push({
+actual: prop,
+needed: propertiesToCheck[prop]
+});
+}
+}
+for (i=0, len=needsStandard.length; i < len; i++) {
+needed = needsStandard[i].needed;
+actual = needsStandard[i].actual;
+if (!properties[needed]) {
+reporter.report("Missing standard property '" + needed + "' to go along with '" + actual + "'.", properties[actual][0].name.line, properties[actual][0].name.col, rule);
+} else {
+// make sure standard property is last
+if (properties[needed][0].pos < properties[actual][0].pos) {
+reporter.report("Standard property '" + needed + "' should come after vendor-prefixed property '" + actual + "'.", properties[actual][0].name.line, properties[actual][0].name.col, rule);
+}
+}
+}
+}
+parser.addListener("startrule", startRule);
+parser.addListener("startfontface", startRule);
+parser.addListener("startpage", startRule);
+parser.addListener("startpagemargin", startRule);
+parser.addListener("startkeyframerule", startRule);
+parser.addListener("startviewport", startRule);
+parser.addListener("property", function(event) {
+var name = event.property.text.toLowerCase();
+if (!properties[name]) {
+properties[name] = [];
+}
+properties[name].push({
+name: event.property,
+value: event.value,
+pos: num++
+});
+});
+parser.addListener("endrule", endRule);
+parser.addListener("endfontface", endRule);
+parser.addListener("endpage", endRule);
+parser.addListener("endpagemargin", endRule);
+parser.addListener("endkeyframerule", endRule);
+parser.addListener("endviewport", endRule);
+}
+});
+/*
+* Rule: You don't need to specify units when a value is 0.
+*/
+CSSLint.addRule({
+// rule information
+id: "zero-units",
+name: "Disallow units for 0 values",
+desc: "You don't need to specify units when a value is 0.",
+url: "https://github.com/CSSLint/csslint/wiki/Disallow-units-for-zero-values",
+browsers: "All",
+// initialization
+init: function(parser, reporter) {
+"use strict";
+var rule = this;
+// count how many times "float" is used
+parser.addListener("property", function(event) {
+var parts = event.value.parts,
+i = 0,
+len = parts.length;
+while (i < len) {
+if ((parts[i].units || parts[i].type === "percentage") && parts[i].value === 0 && parts[i].type !== "time") {
+reporter.report("Values of 0 shouldn't have units specified.", parts[i].line, parts[i].col, rule);
+}
+i++;
+}
+});
+}
+});
+(function() {
+"use strict";
+/**
+* Replace special characters before write to output.
+*
+* Rules:
+*  - single quotes is the escape sequence for double-quotes
+*  - &amp; is the escape sequence for &
+*  - &lt; is the escape sequence for <
+*  - &gt; is the escape sequence for >
+*
+* @param {String} message to escape
+* @return escaped message as {String}
+*/
+var xmlEscape = function(str) {
+if (!str || str.constructor !== String) {
+return "";
+}
+return str.replace(/["&><]/g, function(match) {
+switch (match) {
+case "\"":
+return "&quot;";
+case "&":
+return "&amp;";
+case "<":
+return "&lt;";
+case ">":
+return "&gt;";
+}
+});
+};
+CSSLint.addFormatter({
+// format information
+id: "checkstyle-xml",
+name: "Checkstyle XML format",
+/**
+* Return opening root XML tag.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+return "<?xml version=\"1.0\" encoding=\"utf-8\"?><checkstyle>";
+},
+/**
+* Return closing root XML tag.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+return "</checkstyle>";
+},
+/**
+* Returns message when there is a file read error.
+* @param {String} filename The name of the file that caused the error.
+* @param {String} message The error message
+* @return {String} The error message.
+*/
+readError: function(filename, message) {
+return "<file name=\"" + xmlEscape(filename) + "\"><error line=\"0\" column=\"0\" severty=\"error\" message=\"" + xmlEscape(message) + "\"></error></file>";
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path
+* @param options {Object} (UNUSED for now) specifies special handling of output
+* @return {String} output for results
+*/
+formatResults: function(results, filename/*, options*/) {
+var messages = results.messages,
+output = [];
+/**
+* Generate a source string for a rule.
+* Checkstyle source strings usually resemble Java class names e.g
+* net.csslint.SomeRuleName
+* @param {Object} rule
+* @return rule source as {String}
+*/
+var generateSource = function(rule) {
+if (!rule || !("name" in rule)) {
+return "";
+}
+return "net.csslint." + rule.name.replace(/\s/g, "");
+};
+if (messages.length > 0) {
+output.push("<file name=\""+filename+"\">");
+CSSLint.Util.forEach(messages, function (message) {
+// ignore rollups for now
+if (!message.rollup) {
+output.push("<error line=\"" + message.line + "\" column=\"" + message.col + "\" severity=\"" + message.type + "\"" +
+" message=\"" + xmlEscape(message.message) + "\" source=\"" + generateSource(message.rule) +"\"/>");
+}
+});
+output.push("</file>");
+}
+return output.join("");
+}
+});
+}());
+CSSLint.addFormatter({
+// format information
+id: "compact",
+name: "Compact, 'porcelain' format",
+/**
+* Return content to be printed before all file results.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+"use strict";
+return "";
+},
+/**
+* Return content to be printed after all file results.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+"use strict";
+return "";
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path
+* @param options {Object} (Optional) specifies special handling of output
+* @return {String} output for results
+*/
+formatResults: function(results, filename, options) {
+"use strict";
+var messages = results.messages,
+output = "";
+options = options || {};
+/**
+* Capitalize and return given string.
+* @param str {String} to capitalize
+* @return {String} capitalized
+*/
+var capitalize = function(str) {
+return str.charAt(0).toUpperCase() + str.slice(1);
+};
+if (messages.length === 0) {
+return options.quiet ? "" : filename + ": Lint Free!";
+}
+CSSLint.Util.forEach(messages, function(message) {
+if (message.rollup) {
+output += filename + ": " + capitalize(message.type) + " - " + message.message + " (" + message.rule.id + ")\n";
+} else {
+output += filename + ": line " + message.line +
+", col " + message.col + ", " + capitalize(message.type) + " - " + message.message + " (" + message.rule.id + ")\n";
+}
+});
+return output;
+}
+});
+CSSLint.addFormatter({
+// format information
+id: "csslint-xml",
+name: "CSSLint XML format",
+/**
+* Return opening root XML tag.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+"use strict";
+return "<?xml version=\"1.0\" encoding=\"utf-8\"?><csslint>";
+},
+/**
+* Return closing root XML tag.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+"use strict";
+return "</csslint>";
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path
+* @param options {Object} (UNUSED for now) specifies special handling of output
+* @return {String} output for results
+*/
+formatResults: function(results, filename/*, options*/) {
+"use strict";
+var messages = results.messages,
+output = [];
+/**
+* Replace special characters before write to output.
+*
+* Rules:
+*  - single quotes is the escape sequence for double-quotes
+*  - &amp; is the escape sequence for &
+*  - &lt; is the escape sequence for <
+*  - &gt; is the escape sequence for >
+*
+* @param {String} message to escape
+* @return escaped message as {String}
+*/
+var escapeSpecialCharacters = function(str) {
+if (!str || str.constructor !== String) {
+return "";
+}
+return str.replace(/"/g, "'").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+if (messages.length > 0) {
+output.push("<file name=\""+filename+"\">");
+CSSLint.Util.forEach(messages, function (message) {
+if (message.rollup) {
+output.push("<issue severity=\"" + message.type + "\" reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
+} else {
+output.push("<issue line=\"" + message.line + "\" char=\"" + message.col + "\" severity=\"" + message.type + "\"" +
+" reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
+}
+});
+output.push("</file>");
+}
+return output.join("");
+}
+});
+/* globals JSON: true */
+CSSLint.addFormatter({
+// format information
+id: "json",
+name: "JSON",
+/**
+* Return content to be printed before all file results.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+"use strict";
+this.json = [];
+return "";
+},
+/**
+* Return content to be printed after all file results.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+"use strict";
+var ret = "";
+if (this.json.length > 0) {
+if (this.json.length === 1) {
+ret = JSON.stringify(this.json[0]);
+} else {
+ret = JSON.stringify(this.json);
+}
+}
+return ret;
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path (Unused)
+* @return {String} output for results
+*/
+formatResults: function(results, filename, options) {
+"use strict";
+if (results.messages.length > 0 || !options.quiet) {
+this.json.push({
+filename: filename,
+messages: results.messages,
+stats: results.stats
+});
+}
+return "";
+}
+});
+CSSLint.addFormatter({
+// format information
+id: "junit-xml",
+name: "JUNIT XML format",
+/**
+* Return opening root XML tag.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+"use strict";
+return "<?xml version=\"1.0\" encoding=\"utf-8\"?><testsuites>";
+},
+/**
+* Return closing root XML tag.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+"use strict";
+return "</testsuites>";
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path
+* @param options {Object} (UNUSED for now) specifies special handling of output
+* @return {String} output for results
+*/
+formatResults: function(results, filename/*, options*/) {
+"use strict";
+var messages = results.messages,
+output = [],
+tests = {
+"error": 0,
+"failure": 0
+};
+/**
+* Generate a source string for a rule.
+* JUNIT source strings usually resemble Java class names e.g
+* net.csslint.SomeRuleName
+* @param {Object} rule
+* @return rule source as {String}
+*/
+var generateSource = function(rule) {
+if (!rule || !("name" in rule)) {
+return "";
+}
+return "net.csslint." + rule.name.replace(/\s/g, "");
+};
+/**
+* Replace special characters before write to output.
+*
+* Rules:
+*  - single quotes is the escape sequence for double-quotes
+*  - &lt; is the escape sequence for <
+*  - &gt; is the escape sequence for >
+*
+* @param {String} message to escape
+* @return escaped message as {String}
+*/
+var escapeSpecialCharacters = function(str) {
+if (!str || str.constructor !== String) {
+return "";
+}
+return str.replace(/"/g, "'").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+if (messages.length > 0) {
+messages.forEach(function (message) {
+// since junit has no warning class
+// all issues as errors
+var type = message.type === "warning" ? "error" : message.type;
+// ignore rollups for now
+if (!message.rollup) {
+// build the test case separately, once joined
+// we'll add it to a custom array filtered by type
+output.push("<testcase time=\"0\" name=\"" + generateSource(message.rule) + "\">");
+output.push("<" + type + " message=\"" + escapeSpecialCharacters(message.message) + "\"><![CDATA[" + message.line + ":" + message.col + ":" + escapeSpecialCharacters(message.evidence) + "]]></" + type + ">");
+output.push("</testcase>");
+tests[type] += 1;
+}
+});
+output.unshift("<testsuite time=\"0\" tests=\"" + messages.length + "\" skipped=\"0\" errors=\"" + tests.error + "\" failures=\"" + tests.failure + "\" package=\"net.csslint\" name=\"" + filename + "\">");
+output.push("</testsuite>");
+}
+return output.join("");
+}
+});
+CSSLint.addFormatter({
+// format information
+id: "lint-xml",
+name: "Lint XML format",
+/**
+* Return opening root XML tag.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+"use strict";
+return "<?xml version=\"1.0\" encoding=\"utf-8\"?><lint>";
+},
+/**
+* Return closing root XML tag.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+"use strict";
+return "</lint>";
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path
+* @param options {Object} (UNUSED for now) specifies special handling of output
+* @return {String} output for results
+*/
+formatResults: function(results, filename/*, options*/) {
+"use strict";
+var messages = results.messages,
+output = [];
+/**
+* Replace special characters before write to output.
+*
+* Rules:
+*  - single quotes is the escape sequence for double-quotes
+*  - &amp; is the escape sequence for &
+*  - &lt; is the escape sequence for <
+*  - &gt; is the escape sequence for >
+*
+* @param {String} message to escape
+* @return escaped message as {String}
+*/
+var escapeSpecialCharacters = function(str) {
+if (!str || str.constructor !== String) {
+return "";
+}
+return str.replace(/"/g, "'").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+if (messages.length > 0) {
+output.push("<file name=\""+filename+"\">");
+CSSLint.Util.forEach(messages, function (message) {
+if (message.rollup) {
+output.push("<issue severity=\"" + message.type + "\" reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
+} else {
+var rule = "";
+if (message.rule && message.rule.id) {
+rule = "rule=\"" + escapeSpecialCharacters(message.rule.id) + "\" ";
+}
+output.push("<issue " + rule + "line=\"" + message.line + "\" char=\"" + message.col + "\" severity=\"" + message.type + "\"" +
+" reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
+}
+});
+output.push("</file>");
+}
+return output.join("");
+}
+});
+CSSLint.addFormatter({
+// format information
+id: "text",
+name: "Plain Text",
+/**
+* Return content to be printed before all file results.
+* @return {String} to prepend before all results
+*/
+startFormat: function() {
+"use strict";
+return "";
+},
+/**
+* Return content to be printed after all file results.
+* @return {String} to append after all results
+*/
+endFormat: function() {
+"use strict";
+return "";
+},
+/**
+* Given CSS Lint results for a file, return output for this format.
+* @param results {Object} with error and warning messages
+* @param filename {String} relative file path
+* @param options {Object} (Optional) specifies special handling of output
+* @return {String} output for results
+*/
+formatResults: function(results, filename, options) {
+"use strict";
+var messages = results.messages,
+output = "";
+options = options || {};
+if (messages.length === 0) {
+return options.quiet ? "" : "\n\ncsslint: No errors in " + filename + ".";
+}
+output = "\n\ncsslint: There ";
+if (messages.length === 1) {
+output += "is 1 problem";
+} else {
+output += "are " + messages.length + " problems";
+}
+output += " in " + filename + ".";
+var pos = filename.lastIndexOf("/"),
+shortFilename = filename;
+if (pos === -1) {
+pos = filename.lastIndexOf("\\");
+}
+if (pos > -1) {
+shortFilename = filename.substring(pos+1);
+}
+CSSLint.Util.forEach(messages, function (message, i) {
+output = output + "\n\n" + shortFilename;
+if (message.rollup) {
+output += "\n" + (i+1) + ": " + message.type;
+output += "\n" + message.message;
+} else {
+output += "\n" + (i+1) + ": " + message.type + " at line " + message.line + ", col " + message.col;
+output += "\n" + message.message;
+output += "\n" + message.evidence;
+}
+});
+return output;
+}
+});
+return CSSLint;
+})();

enmi-conf.org