@acemir/cssom 0.9.5 → 0.9.7

package/build/CSSOM.js

@@ -298,6 +298,20 @@ CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
 };
 
 
+/**
+ * @constructor
+ * @see https://drafts.csswg.org/css-counter-styles/#the-csscounterstylerule-interface
+ */
+CSSOM.CSSCounterStyleRule = function CSSCounterStyleRule() {
+	CSSOM.CSSRule.call(this);
+    this.name = "";
+};
+
+CSSOM.CSSCounterStyleRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSCounterStyleRule.prototype.constructor = CSSOM.CSSCounterStyleRule;
+CSSOM.CSSCounterStyleRule.prototype.type = 11;
+
+
 /**
  * @constructor
  * @see https://www.w3.org/TR/css-conditional-3/#the-cssconditionrule-interface
@@ -1607,6 +1621,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 		"atBlock": true,
 		"containerBlock": true,
 		"conditionBlock": true,
+		"counterStyleBlock": true,
 		'documentRule-begin': true,
 		"layerBlock": true
 	};
@@ -1622,7 +1637,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 	var ancestorRules = [];
 	var prevScope;
 
-	var name, priority="", styleRule, mediaRule, containerRule, supportsRule, importRule, fontFaceRule, keyframesRule, documentRule, hostRule, startingStyleRule, layerBlockRule, layerStatementRule, nestedSelectorRule;
+	var name, priority="", styleRule, mediaRule, containerRule, counterStyleRule, supportsRule, importRule, fontFaceRule, keyframesRule, documentRule, hostRule, startingStyleRule, layerBlockRule, layerStatementRule, nestedSelectorRule;
 
 	var atKeyframesRegExp = /@(-(?:\w+-)+)?keyframes/g; // Match @keyframes and vendor-prefixed @keyframes
 	// Regex above is not ES5 compliant
@@ -1798,13 +1813,14 @@ CSSOM.parse = function parse(token, errorHandler) {
 	}
 
 	/**
-	 * Regular expression to match a basic CSS selector.
-	 *
-	 * This regex matches the following selector components:
+	 * Validates a basic CSS selector, allowing for deeply nested balanced parentheses in pseudo-classes.
+	 * This function replaces the previous basicSelectorRegExp.
+	 * 
+	 * This function matches:
 	 * - Type selectors (e.g., `div`, `span`)
 	 * - Universal selector (`*`)
-	 * - ID selectors (e.g., `#header`)
-	 * - Class selectors (e.g., `.container`)
+	 * - ID selectors (e.g., `#header`, `#a\ b`, `#åèiöú`)
+	 * - Class selectors (e.g., `.container`, `.a\ b`, `.åèiöú`)
 	 * - Attribute selectors (e.g., `[type="text"]`)
 	 * - Pseudo-classes and pseudo-elements (e.g., `:hover`, `::before`, `:nth-child(2)`)
 	 * - Pseudo-classes with nested parentheses, including cases where parentheses are nested inside arguments,
@@ -1813,13 +1829,66 @@ CSSOM.parse = function parse(token, errorHandler) {
 	 * - Combinators (`>`, `+`, `~`) with optional whitespace
 	 * - Whitespace (descendant combinator)
 	 *
-	 * The pattern ensures that a string consists only of valid basic selector components,
-	 * possibly repeated and combined, including pseudo-classes with nested parentheses,
-	 * but does not match full CSS selector groups separated by commas.
+	 * Unicode and escape sequences are allowed in identifiers.
 	 *
-	 * @type {RegExp}
+	 * @param {string} selector
+	 * @returns {boolean}
 	 */
-	var basicSelectorRegExp = /^([a-zA-Z][a-zA-Z0-9_-]*|\*|#[a-zA-Z0-9_-]+|\.[a-zA-Z0-9_-]+|\[[^\[\]]*(?:\s+[iI])?\]|::?[a-zA-Z0-9_-]+(?:\(((?:[^()"]+|"[^"]*"|'[^']*'|\((?:[^()"]+|"[^"]*"|'[^']*')*\))*?)\))?|&|\s*[>+~]\s*|\s+)+$/;
+	function basicSelectorValidator(selector) {
+		var length = selector.length;
+		var i = 0;
+		var stack = [];
+		var inAttr = false;
+		var inSingleQuote = false;
+		var inDoubleQuote = false;
+
+		while (i < length) {
+			var char = selector[i];
+
+			if (inSingleQuote) {
+				if (char === "'" && selector[i - 1] !== "\\") {
+					inSingleQuote = false;
+				}
+			} else if (inDoubleQuote) {
+				if (char === '"' && selector[i - 1] !== "\\") {
+					inDoubleQuote = false;
+				}
+			} else if (inAttr) {
+				if (char === "]") {
+					inAttr = false;
+				} else if (char === "'") {
+					inSingleQuote = true;
+				} else if (char === '"') {
+					inDoubleQuote = true;
+				}
+			} else {
+				if (char === "[") {
+					inAttr = true;
+				} else if (char === "'") {
+					inSingleQuote = true;
+				} else if (char === '"') {
+					inDoubleQuote = true;
+				} else if (char === "(") {
+					stack.push("(");
+				} else if (char === ")") {
+					if (!stack.length || stack.pop() !== "(") {
+						return false;
+					}
+				}
+			}
+			i++;
+		}
+
+		// If any stack or quote/attr context remains, it's invalid
+		if (stack.length || inAttr || inSingleQuote || inDoubleQuote) {
+			return false;
+		}
+
+		// Fallback to a loose regexp for the overall selector structure (without deep paren matching)
+		// This is similar to the original, but without nested paren limitations
+		var looseSelectorRegExp = /^([a-zA-Z_\u00A0-\uFFFF\\][a-zA-Z0-9_\u00A0-\uFFFF\-\\]*|\*|#[a-zA-Z0-9_\u00A0-\uFFFF\-\\]+|\.[a-zA-Z0-9_\u00A0-\uFFFF\-\\]+|\[[^\[\]]*(?:\s+[iI])?\]|::?[a-zA-Z0-9_\u00A0-\uFFFF\-\\]+(?:\((.*)\))?|&|\s*[>+~]\s*|\s+)+$/;
+		return looseSelectorRegExp.test(selector);
+	}
 
 	/**
 	 * Regular expression to match CSS pseudo-classes with arguments.
@@ -1902,40 +1971,62 @@ CSSOM.parse = function parse(token, errorHandler) {
 	 * Validates a CSS selector string, including handling of nested selectors within certain pseudo-classes.
 	 *
 	 * This function checks if the provided selector is valid according to the rules defined by
-	 * `basicSelectorRegExp`. For pseudo-classes that accept selector lists (such as :not, :is, :has, :where),
+	 * `basicSelectorValidator`. For pseudo-classes that accept selector lists (such as :not, :is, :has, :where),
 	 * it recursively validates each nested selector using the same validation logic.
 	 *
 	 * @param {string} selector - The CSS selector string to validate.
 	 * @returns {boolean} Returns `true` if the selector is valid, otherwise `false`.
 	 */
+
+	// Cache to store validated selectors
+	var validatedSelectorsCache = new Map();
+
+	// Only pseudo-classes that accept selector lists should recurse
+	var selectorListPseudoClasses = {
+		'not': true,
+		'is': true,
+		'has': true,
+		'where': true
+	};
+
 	function validateSelector(selector) {
-		var match, nestedSelectors, i;
-
-		// Only pseudo-classes that accept selector lists should recurse
-		var selectorListPseudoClasses = {
-			'not': true,
-			'is': true,
-			'has': true,
-			'where': true
-		};
+		if (validatedSelectorsCache.has(selector)) {
+			return validatedSelectorsCache.get(selector);
+		}
 
-		// Reset regex lastIndex for global regex in ES5 loop
+		// Use a non-global regex to find all pseudo-classes with arguments
+		var pseudoClassMatches = [];
 		var pseudoClassRegExp = new RegExp(globalPseudoClassRegExp.source, globalPseudoClassRegExp.flags);
+		var match;
 		while ((match = pseudoClassRegExp.exec(selector)) !== null) {
-			var pseudoClass = match[1];
+			pseudoClassMatches.push(match);
+		}
+
+		for (var j = 0; j < pseudoClassMatches.length; j++) {
+			var pseudoClass = pseudoClassMatches[j][1];
 			if (selectorListPseudoClasses.hasOwnProperty(pseudoClass)) {
-				nestedSelectors = parseAndSplitNestedSelectors(match[2]);
-				// Validate each nested selector
-				for (i = 0; i < nestedSelectors.length; i++) {
-					if (!validateSelector(nestedSelectors[i])) {
+				var nestedSelectors = parseAndSplitNestedSelectors(pseudoClassMatches[j][2]);
+				for (var i = 0; i < nestedSelectors.length; i++) {
+					var nestedSelector = nestedSelectors[i];
+					if (!validatedSelectorsCache.has(nestedSelector)) {
+						var nestedSelectorValidation = validateSelector(nestedSelector);
+						validatedSelectorsCache.set(nestedSelector, nestedSelectorValidation);
+						if (!nestedSelectorValidation) {
+							validatedSelectorsCache.set(selector, false);
+							return false;
+						}
+					} else if (!validatedSelectorsCache.get(nestedSelector)) {
+						validatedSelectorsCache.set(selector, false);
 						return false;
 					}
 				}
 			}
 		}
 
-		// Allow "&" anywhere in the selector for nested selectors
-		return basicSelectorRegExp.test(selector);
+		var basicSelectorValidation = basicSelectorValidator(selector);
+		validatedSelectorsCache.set(selector, basicSelectorValidation);
+
+		return basicSelectorValidation;
 	}
 
 	/**
@@ -2078,6 +2169,15 @@ CSSOM.parse = function parse(token, errorHandler) {
 				});
 				buffer = "";
 				break;
+			} else if (token.indexOf("@counter-style", i) === i) {
+				validateAtRule("@counter-style", function(){
+					state = "counterStyleBlock"
+					counterStyleRule = new CSSOM.CSSCounterStyleRule();
+					counterStyleRule.__starts = i;
+					i += "counter-style".length;
+				}, true);
+				buffer = "";
+				break;
 			} else if (token.indexOf("@layer", i) === i) {
 				validateAtRule("@layer", function(){
 					state = "layerBlock"
@@ -2087,7 +2187,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 				});
 				buffer = "";
 				break;
-			}  else if (token.indexOf("@supports", i) === i) {
+			} else if (token.indexOf("@supports", i) === i) {
 				validateAtRule("@supports", function(){
 					state = "conditionBlock";
 					supportsRule = new CSSOM.CSSSupportsRule();
@@ -2204,6 +2304,12 @@ CSSOM.parse = function parse(token, errorHandler) {
 				containerRule.parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
+			} else if (state === "counterStyleBlock") {
+				// TODO: Validate counter-style name. At least that it cannot be empty nor multiple
+				counterStyleRule.name = buffer.trim();
+				currentScope = parentRule = counterStyleRule;
+				counterStyleRule.parentStyleSheet = styleSheet;
+				buffer = "";
 			} else if (state === "conditionBlock") {
 				supportsRule.conditionText = buffer.trim();
 
@@ -2438,6 +2544,13 @@ CSSOM.parse = function parse(token, errorHandler) {
 			break;
 
 		case "}":
+			if (state === "counterStyleBlock") {
+				// FIXME : Implement cssText get setter that parses the real implementation
+				counterStyleRule.cssText = "@counter-style " + counterStyleRule.name + " { " + buffer.trim() + " }";
+				buffer = "";
+				state = "before-selector";
+			}
+
 			switch (state) {
 				case "value":
 					styleRule.style.setProperty(name, buffer.trim(), priority, parseError);

package/lib/CSSCounterStyleRule.js

@@ -0,0 +1,23 @@
+//.CommonJS
+var CSSOM = {
+	CSSRule: require("./CSSRule").CSSRule
+};
+///CommonJS
+
+
+/**
+ * @constructor
+ * @see https://drafts.csswg.org/css-counter-styles/#the-csscounterstylerule-interface
+ */
+CSSOM.CSSCounterStyleRule = function CSSCounterStyleRule() {
+	CSSOM.CSSRule.call(this);
+    this.name = "";
+};
+
+CSSOM.CSSCounterStyleRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSCounterStyleRule.prototype.constructor = CSSOM.CSSCounterStyleRule;
+CSSOM.CSSCounterStyleRule.prototype.type = 11;
+
+//.CommonJS
+exports.CSSCounterStyleRule = CSSOM.CSSCounterStyleRule;
+///CommonJS

package/lib/index.js

@@ -4,6 +4,7 @@ exports.CSSStyleDeclaration = require('./CSSStyleDeclaration').CSSStyleDeclarati
 exports.CSSRule = require('./CSSRule').CSSRule;
 exports.CSSNestedDeclarations = require('./CSSNestedDeclarations').CSSNestedDeclarations;
 exports.CSSGroupingRule = require('./CSSGroupingRule').CSSGroupingRule;
+exports.CSSCounterStyleRule = require('./CSSCounterStyleRule').CSSCounterStyleRule;
 exports.CSSConditionRule = require('./CSSConditionRule').CSSConditionRule;
 exports.CSSStyleRule = require('./CSSStyleRule').CSSStyleRule;
 exports.MediaList = require('./MediaList').MediaList;

package/lib/parse.js

@@ -40,6 +40,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 		"atBlock": true,
 		"containerBlock": true,
 		"conditionBlock": true,
+		"counterStyleBlock": true,
 		'documentRule-begin': true,
 		"layerBlock": true
 	};
@@ -55,7 +56,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 	var ancestorRules = [];
 	var prevScope;
 
-	var name, priority="", styleRule, mediaRule, containerRule, supportsRule, importRule, fontFaceRule, keyframesRule, documentRule, hostRule, startingStyleRule, layerBlockRule, layerStatementRule, nestedSelectorRule;
+	var name, priority="", styleRule, mediaRule, containerRule, counterStyleRule, supportsRule, importRule, fontFaceRule, keyframesRule, documentRule, hostRule, startingStyleRule, layerBlockRule, layerStatementRule, nestedSelectorRule;
 
 	var atKeyframesRegExp = /@(-(?:\w+-)+)?keyframes/g; // Match @keyframes and vendor-prefixed @keyframes
 	// Regex above is not ES5 compliant
@@ -231,13 +232,14 @@ CSSOM.parse = function parse(token, errorHandler) {
 	}
 
 	/**
-	 * Regular expression to match a basic CSS selector.
-	 *
-	 * This regex matches the following selector components:
+	 * Validates a basic CSS selector, allowing for deeply nested balanced parentheses in pseudo-classes.
+	 * This function replaces the previous basicSelectorRegExp.
+	 * 
+	 * This function matches:
 	 * - Type selectors (e.g., `div`, `span`)
 	 * - Universal selector (`*`)
-	 * - ID selectors (e.g., `#header`)
-	 * - Class selectors (e.g., `.container`)
+	 * - ID selectors (e.g., `#header`, `#a\ b`, `#åèiöú`)
+	 * - Class selectors (e.g., `.container`, `.a\ b`, `.åèiöú`)
 	 * - Attribute selectors (e.g., `[type="text"]`)
 	 * - Pseudo-classes and pseudo-elements (e.g., `:hover`, `::before`, `:nth-child(2)`)
 	 * - Pseudo-classes with nested parentheses, including cases where parentheses are nested inside arguments,
@@ -246,13 +248,66 @@ CSSOM.parse = function parse(token, errorHandler) {
 	 * - Combinators (`>`, `+`, `~`) with optional whitespace
 	 * - Whitespace (descendant combinator)
 	 *
-	 * The pattern ensures that a string consists only of valid basic selector components,
-	 * possibly repeated and combined, including pseudo-classes with nested parentheses,
-	 * but does not match full CSS selector groups separated by commas.
+	 * Unicode and escape sequences are allowed in identifiers.
 	 *
-	 * @type {RegExp}
+	 * @param {string} selector
+	 * @returns {boolean}
 	 */
-	var basicSelectorRegExp = /^([a-zA-Z][a-zA-Z0-9_-]*|\*|#[a-zA-Z0-9_-]+|\.[a-zA-Z0-9_-]+|\[[^\[\]]*(?:\s+[iI])?\]|::?[a-zA-Z0-9_-]+(?:\(((?:[^()"]+|"[^"]*"|'[^']*'|\((?:[^()"]+|"[^"]*"|'[^']*')*\))*?)\))?|&|\s*[>+~]\s*|\s+)+$/;
+	function basicSelectorValidator(selector) {
+		var length = selector.length;
+		var i = 0;
+		var stack = [];
+		var inAttr = false;
+		var inSingleQuote = false;
+		var inDoubleQuote = false;
+
+		while (i < length) {
+			var char = selector[i];
+
+			if (inSingleQuote) {
+				if (char === "'" && selector[i - 1] !== "\\") {
+					inSingleQuote = false;
+				}
+			} else if (inDoubleQuote) {
+				if (char === '"' && selector[i - 1] !== "\\") {
+					inDoubleQuote = false;
+				}
+			} else if (inAttr) {
+				if (char === "]") {
+					inAttr = false;
+				} else if (char === "'") {
+					inSingleQuote = true;
+				} else if (char === '"') {
+					inDoubleQuote = true;
+				}
+			} else {
+				if (char === "[") {
+					inAttr = true;
+				} else if (char === "'") {
+					inSingleQuote = true;
+				} else if (char === '"') {
+					inDoubleQuote = true;
+				} else if (char === "(") {
+					stack.push("(");
+				} else if (char === ")") {
+					if (!stack.length || stack.pop() !== "(") {
+						return false;
+					}
+				}
+			}
+			i++;
+		}
+
+		// If any stack or quote/attr context remains, it's invalid
+		if (stack.length || inAttr || inSingleQuote || inDoubleQuote) {
+			return false;
+		}
+
+		// Fallback to a loose regexp for the overall selector structure (without deep paren matching)
+		// This is similar to the original, but without nested paren limitations
+		var looseSelectorRegExp = /^([a-zA-Z_\u00A0-\uFFFF\\][a-zA-Z0-9_\u00A0-\uFFFF\-\\]*|\*|#[a-zA-Z0-9_\u00A0-\uFFFF\-\\]+|\.[a-zA-Z0-9_\u00A0-\uFFFF\-\\]+|\[[^\[\]]*(?:\s+[iI])?\]|::?[a-zA-Z0-9_\u00A0-\uFFFF\-\\]+(?:\((.*)\))?|&|\s*[>+~]\s*|\s+)+$/;
+		return looseSelectorRegExp.test(selector);
+	}
 
 	/**
 	 * Regular expression to match CSS pseudo-classes with arguments.
@@ -335,40 +390,62 @@ CSSOM.parse = function parse(token, errorHandler) {
 	 * Validates a CSS selector string, including handling of nested selectors within certain pseudo-classes.
 	 *
 	 * This function checks if the provided selector is valid according to the rules defined by
-	 * `basicSelectorRegExp`. For pseudo-classes that accept selector lists (such as :not, :is, :has, :where),
+	 * `basicSelectorValidator`. For pseudo-classes that accept selector lists (such as :not, :is, :has, :where),
 	 * it recursively validates each nested selector using the same validation logic.
 	 *
 	 * @param {string} selector - The CSS selector string to validate.
 	 * @returns {boolean} Returns `true` if the selector is valid, otherwise `false`.
 	 */
-	function validateSelector(selector) {
-		var match, nestedSelectors, i;
 
-		// Only pseudo-classes that accept selector lists should recurse
-		var selectorListPseudoClasses = {
-			'not': true,
-			'is': true,
-			'has': true,
-			'where': true
-		};
+	// Cache to store validated selectors
+	var validatedSelectorsCache = new Map();
+
+	// Only pseudo-classes that accept selector lists should recurse
+	var selectorListPseudoClasses = {
+		'not': true,
+		'is': true,
+		'has': true,
+		'where': true
+	};
 
-		// Reset regex lastIndex for global regex in ES5 loop
+	function validateSelector(selector) {
+		if (validatedSelectorsCache.has(selector)) {
+			return validatedSelectorsCache.get(selector);
+		}
+
+		// Use a non-global regex to find all pseudo-classes with arguments
+		var pseudoClassMatches = [];
 		var pseudoClassRegExp = new RegExp(globalPseudoClassRegExp.source, globalPseudoClassRegExp.flags);
+		var match;
 		while ((match = pseudoClassRegExp.exec(selector)) !== null) {
-			var pseudoClass = match[1];
+			pseudoClassMatches.push(match);
+		}
+
+		for (var j = 0; j < pseudoClassMatches.length; j++) {
+			var pseudoClass = pseudoClassMatches[j][1];
 			if (selectorListPseudoClasses.hasOwnProperty(pseudoClass)) {
-				nestedSelectors = parseAndSplitNestedSelectors(match[2]);
-				// Validate each nested selector
-				for (i = 0; i < nestedSelectors.length; i++) {
-					if (!validateSelector(nestedSelectors[i])) {
+				var nestedSelectors = parseAndSplitNestedSelectors(pseudoClassMatches[j][2]);
+				for (var i = 0; i < nestedSelectors.length; i++) {
+					var nestedSelector = nestedSelectors[i];
+					if (!validatedSelectorsCache.has(nestedSelector)) {
+						var nestedSelectorValidation = validateSelector(nestedSelector);
+						validatedSelectorsCache.set(nestedSelector, nestedSelectorValidation);
+						if (!nestedSelectorValidation) {
+							validatedSelectorsCache.set(selector, false);
+							return false;
+						}
+					} else if (!validatedSelectorsCache.get(nestedSelector)) {
+						validatedSelectorsCache.set(selector, false);
 						return false;
 					}
 				}
 			}
 		}
 
-		// Allow "&" anywhere in the selector for nested selectors
-		return basicSelectorRegExp.test(selector);
+		var basicSelectorValidation = basicSelectorValidator(selector);
+		validatedSelectorsCache.set(selector, basicSelectorValidation);
+
+		return basicSelectorValidation;
 	}
 
 	/**
@@ -511,6 +588,15 @@ CSSOM.parse = function parse(token, errorHandler) {
 				});
 				buffer = "";
 				break;
+			} else if (token.indexOf("@counter-style", i) === i) {
+				validateAtRule("@counter-style", function(){
+					state = "counterStyleBlock"
+					counterStyleRule = new CSSOM.CSSCounterStyleRule();
+					counterStyleRule.__starts = i;
+					i += "counter-style".length;
+				}, true);
+				buffer = "";
+				break;
 			} else if (token.indexOf("@layer", i) === i) {
 				validateAtRule("@layer", function(){
 					state = "layerBlock"
@@ -520,7 +606,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 				});
 				buffer = "";
 				break;
-			}  else if (token.indexOf("@supports", i) === i) {
+			} else if (token.indexOf("@supports", i) === i) {
 				validateAtRule("@supports", function(){
 					state = "conditionBlock";
 					supportsRule = new CSSOM.CSSSupportsRule();
@@ -637,6 +723,12 @@ CSSOM.parse = function parse(token, errorHandler) {
 				containerRule.parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
+			} else if (state === "counterStyleBlock") {
+				// TODO: Validate counter-style name. At least that it cannot be empty nor multiple
+				counterStyleRule.name = buffer.trim();
+				currentScope = parentRule = counterStyleRule;
+				counterStyleRule.parentStyleSheet = styleSheet;
+				buffer = "";
 			} else if (state === "conditionBlock") {
 				supportsRule.conditionText = buffer.trim();
 
@@ -871,6 +963,13 @@ CSSOM.parse = function parse(token, errorHandler) {
 			break;
 
 		case "}":
+			if (state === "counterStyleBlock") {
+				// FIXME : Implement cssText get setter that parses the real implementation
+				counterStyleRule.cssText = "@counter-style " + counterStyleRule.name + " { " + buffer.trim() + " }";
+				buffer = "";
+				state = "before-selector";
+			}
+
 			switch (state) {
 				case "value":
 					styleRule.style.setProperty(name, buffer.trim(), priority, parseError);
@@ -1076,6 +1175,7 @@ CSSOM.CSSNestedDeclarations = require("./CSSNestedDeclarations").CSSNestedDeclar
 CSSOM.CSSImportRule = require("./CSSImportRule").CSSImportRule;
 CSSOM.CSSGroupingRule = require("./CSSGroupingRule").CSSGroupingRule;
 CSSOM.CSSMediaRule = require("./CSSMediaRule").CSSMediaRule;
+CSSOM.CSSCounterStyleRule = require("./CSSCounterStyleRule").CSSCounterStyleRule;
 CSSOM.CSSContainerRule = require("./CSSContainerRule").CSSContainerRule;
 CSSOM.CSSConditionRule = require("./CSSConditionRule").CSSConditionRule;
 CSSOM.CSSSupportsRule = require("./CSSSupportsRule").CSSSupportsRule;

package/package.json

@@ -7,7 +7,7 @@
     "parser",
     "styleSheet"
   ],
-  "version": "0.9.5",
+  "version": "0.9.7",
   "author": "Nikita Vasilyev <me@elv1s.ru>",
   "contributors": [
     "Acemir Sousa Mendes <acemirsm@gmail.com>"