@acemir/cssom 0.9.23 → 0.9.24

package/build/CSSOM.js

@@ -34,6 +34,19 @@ function getErrorConstructor(context, errorType) {
 	       eval(errorType);
 }
 
+/**
+ * Creates an appropriate error with context-aware constructor.
+ * 
+ * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
+ * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
+ * @param {string} message - The error message
+ * @param {string} [name] - Optional name for DOMException
+ */
+function createError(context, errorType, message, name) {
+	var ErrorConstructor = getErrorConstructor(context, errorType);
+	return new ErrorConstructor(message, name);
+}
+
 /**
  * Creates and throws an appropriate error with context-aware constructor.
  * 
@@ -43,9 +56,7 @@ function getErrorConstructor(context, errorType) {
  * @param {string} [name] - Optional name for DOMException
  */
 function throwError(context, errorType, message, name) {
-	var ErrorConstructor = getErrorConstructor(context, errorType);
-	var error = new ErrorConstructor(message, name);
-	throw error;
+	throw createError(context, errorType, message, name);
 }
 
 /**
@@ -98,6 +109,7 @@ function throwIndexError(context, methodName, objectName, index, maxIndex, name)
 }
 
 var errorUtils = {
+	createError: createError,
 	getErrorConstructor: getErrorConstructor,
 	throwError: throwError,
 	throwMissingArguments: throwMissingArguments,
@@ -628,12 +640,17 @@ Object.defineProperty(CSSOM.CSSStyleRule.prototype, "cssText", {
 	get: function() {
 		var text;
 		if (this.selectorText) {
-			var values = ""
+			var values = "";
 			if (this.cssRules.length) {
 				var valuesArr = [" {"];
 				this.style.cssText && valuesArr.push(this.style.cssText);
-				valuesArr.push(this.cssRules.map(function(rule){ return rule.cssText }).join("\n  "));
-				values = valuesArr.join("\n  ") + "\n}"
+				valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+					if (rule.cssText !== "") {
+						acc.push(rule.cssText);
+					}
+					return acc;
+				}, []).join("\n  "));
+				values = valuesArr.join("\n  ") + "\n}";
 			} else {
 				values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
 			}
@@ -825,7 +842,9 @@ CSSOM.MediaList.prototype = {
 	 * @param {string} value
 	 */
 	set mediaText(value) {
-		var values = value.split(",");
+		var values = value.split(",").filter(function(text){
+			return !!text;
+		});
 		var length = this.length = values.length;
 		for (var i=0; i<length; i++) {
 			this[i] = values[i].trim();
@@ -895,11 +914,18 @@ Object.defineProperties(CSSOM.CSSMediaRule.prototype, {
   },
   "cssText": {
     get: function() {
-      var cssTexts = [];
-      for (var i=0, length=this.cssRules.length; i < length; i++) {
-        cssTexts.push(this.cssRules[i].cssText);
+			var values = "";
+			var valuesArr = [" {"];
+      if (this.cssRules.length) {
+        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+          if (rule.cssText !== "") {
+            acc.push(rule.cssText);
+          }
+          return acc;
+        }, []).join("\n  "));
       }
-      return "@media " + this.media.mediaText + " {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+      values = valuesArr.join("\n  ") + "\n}";
+      return "@media " + this.media.mediaText + values;
     },
     configurable: true,
     enumerable: true
@@ -927,11 +953,18 @@ CSSOM.CSSContainerRule.prototype.type = 17;
 Object.defineProperties(CSSOM.CSSContainerRule.prototype, {
   "cssText": {
     get: function() {
-      var cssTexts = [];
-      for (var i=0, length=this.cssRules.length; i < length; i++) {
-        cssTexts.push(this.cssRules[i].cssText);
+			var values = "";
+			var valuesArr = [" {"];
+      if (this.cssRules.length) {
+        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+          if (rule.cssText !== "") {
+            acc.push(rule.cssText);
+          }
+          return acc;
+        }, []).join("\n  "));
       }
-      return "@container " + this.conditionText + " {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+      values = valuesArr.join("\n  ") + "\n}";
+      return "@container " + this.conditionText + values;
     },
     configurable: true,
     enumerable: true
@@ -975,13 +1008,18 @@ CSSOM.CSSSupportsRule.prototype.type = 12;
 
 Object.defineProperty(CSSOM.CSSSupportsRule.prototype, "cssText", {
   get: function() {
-    var cssTexts = [];
-
-    for (var i = 0, length = this.cssRules.length; i < length; i++) {
-      cssTexts.push(this.cssRules[i].cssText);
+    var values = "";
+    var valuesArr = [" {"];
+    if (this.cssRules.length) {
+      valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+        if (rule.cssText !== "") {
+          acc.push(rule.cssText);
+        }
+        return acc;
+      }, []).join("\n  "));
     }
-
-    return "@supports " + this.conditionText + " {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+    values = valuesArr.join("\n  ") + "\n}";
+    return "@supports " + this.conditionText + values;
   }
 });
 
@@ -1368,6 +1406,8 @@ Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "cssText", {
 /**
  * @constructor
  * @see http://www.w3.org/TR/shadow-dom/#host-at-rule
+ * @see http://html5index.org/Shadow%20DOM%20-%20CSSHostRule.html
+ * @deprecated This rule was part of early Shadow DOM drafts but was removed in favor of the more flexible :host and :host-context() pseudo-classes in modern CSS for Web Components.
  */
 CSSOM.CSSHostRule = function CSSHostRule() {
 	CSSOM.CSSRule.call(this);
@@ -1383,11 +1423,18 @@ CSSOM.CSSHostRule.prototype.type = 1001;
 
 Object.defineProperty(CSSOM.CSSHostRule.prototype, "cssText", {
 	get: function() {
-		var cssTexts = [];
-		for (var i=0, length=this.cssRules.length; i < length; i++) {
-			cssTexts.push(this.cssRules[i].cssText);
+		var values = "";
+		var valuesArr = [" {"];
+		if (this.cssRules.length) {
+			valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+			if (rule.cssText !== "") {
+				acc.push(rule.cssText);
+			}
+			return acc;
+			}, []).join("\n  "));
 		}
-		return "@host {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+		values = valuesArr.join("\n  ") + "\n}";
+		return "@host" + values;
 	}
 });
 
@@ -1413,11 +1460,18 @@ CSSOM.CSSStartingStyleRule.prototype.type = 1002;
 
 Object.defineProperty(CSSOM.CSSStartingStyleRule.prototype, "cssText", {
 	get: function() {
-		var cssTexts = [];
-		for (var i=0, length=this.cssRules.length; i < length; i++) {
-			cssTexts.push(this.cssRules[i].cssText);
+		var values = "";
+		var valuesArr = [" {"];
+		if (this.cssRules.length) {
+			valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+			if (rule.cssText !== "") {
+				acc.push(rule.cssText);
+			}
+			return acc;
+			}, []).join("\n  "));
 		}
-		return "@starting-style {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+		values = valuesArr.join("\n  ") + "\n}";
+		return "@starting-style" + values;
 	}
 });
 
@@ -1465,6 +1519,7 @@ Object.defineProperties(CSSOM.StyleSheet.prototype, {
  */
 CSSOM.CSSStyleSheet = function CSSStyleSheet() {
 	CSSOM.StyleSheet.call(this);
+	this.__constructed = true;
 	this.cssRules = new CSSOM.CSSRuleList();
 };
 
@@ -1677,6 +1732,84 @@ CSSOM.CSSStyleSheet.prototype.removeRule = function(index) {
 	this.deleteRule(index);
 };
 
+
+/**
+ * Replaces the rules of a {@link CSSStyleSheet}
+ * 
+ * @returns a promise
+ * @see https://www.w3.org/TR/cssom-1/#dom-cssstylesheet-replace
+ */
+CSSOM.CSSStyleSheet.prototype.replace = function(text) {
+	var _Promise;
+	if (this.__globalObject) {
+		_Promise = this.__globalObject['Promise'];
+	} else {
+		_Promise = Promise;
+	}
+	var sheet = this;
+	return new _Promise(function (resolve, reject) {
+		// If the constructed flag is not set, or the disallow modification flag is set, throw a NotAllowedError DOMException.
+		if (!sheet.__constructed || sheet.__disallowModification) {
+			reject(errorUtils.createError(sheet, 'DOMException',
+				"Failed to execute 'replaceSync' on '" + sheet.constructor.name + "': Not allowed.",
+				'NotAllowedError'));
+		}
+		// Set the disallow modification flag.
+		sheet.__disallowModification = true;
+
+		// In parallel, do these steps:
+		setTimeout(function() {
+			// Let rules be the result of running parse a stylesheet's contents from text.
+			var rules = new CSSOM.CSSRuleList();
+			CSSOM.parse(text, { styleSheet: sheet, cssRules: rules });
+			// If rules contains one or more @import rules, remove those rules from rules.
+			var i = 0;
+			while (i < rules.length) {
+				if (rules[i].constructor.name === 'CSSImportRule') {
+					rules.splice(i, 1);
+				} else {
+					i++;
+				}
+			}
+			// Set sheet's CSS rules to rules.
+			sheet.cssRules = rules;
+			// Unset sheet’s disallow modification flag.
+			delete sheet.__disallowModification;
+			// Resolve promise with sheet.
+			resolve(sheet);
+		})
+	});
+}
+
+/**
+ * Synchronously replaces the rules of a {@link CSSStyleSheet}
+ * 
+ * @see https://www.w3.org/TR/cssom-1/#dom-cssstylesheet-replacesync
+ */
+CSSOM.CSSStyleSheet.prototype.replaceSync = function(text) {
+	var sheet = this;
+	// If the constructed flag is not set, or the disallow modification flag is set, throw a NotAllowedError DOMException.
+	if (!sheet.__constructed || sheet.__disallowModification) {
+		errorUtils.throwError(sheet, 'DOMException',
+			"Failed to execute 'replaceSync' on '" + sheet.constructor.name + "': Not allowed.",
+			'NotAllowedError');
+	}
+	// Let rules be the result of running parse a stylesheet's contents from text.
+	var rules = new CSSOM.CSSRuleList();
+	CSSOM.parse(text, { styleSheet: sheet, cssRules: rules });
+	// If rules contains one or more @import rules, remove those rules from rules.
+	var i = 0;
+	while (i < rules.length) {
+		if (rules[i].constructor.name === 'CSSImportRule') {
+			rules.splice(i, 1);
+		} else {
+			i++;
+		}
+	}
+	// Set sheet's CSS rules to rules.
+	sheet.cssRules = rules;
+}
+
 /**
  * NON-STANDARD
  * @return {string} serialize stylesheet
@@ -1743,13 +1876,20 @@ CSSOM.CSSKeyframesRule.prototype.type = 7;
 // http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframesRule.cpp
 Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "cssText", {
   get: function() {
-    var cssTexts = [];
-    for (var i=0, length=this.cssRules.length; i < length; i++) {
-      cssTexts.push(this.cssRules[i].cssText);
-    }
+    var values = "";
+	var valuesArr = [" {"];
+	if (this.cssRules.length) {
+	valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+		if (rule.cssText !== "") {
+		acc.push(rule.cssText);
+		}
+		return acc;
+	}, []).join("\n  "));
+	}
+	values = valuesArr.join("\n  ") + "\n}";
     var cssWideKeywords = ['initial', 'inherit', 'revert', 'revert-layer', 'unset', 'none'];
     var processedName = cssWideKeywords.includes(this.name) ? '"' + this.name + '"' : this.name;
-    return "@" + (this._vendorPrefix || '') + "keyframes " + processedName + (processedName && " ") + "{" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+    return "@" + (this._vendorPrefix || '') + "keyframes " + processedName + values;
   }
 });
 
@@ -2024,6 +2164,7 @@ CSSOM.MatcherList.prototype = {
 /**
  * @constructor
  * @see https://developer.mozilla.org/en/CSS/@-moz-document
+ * @deprecated This rule is a non-standard Mozilla-specific extension and is not part of any official CSS specification.
  */
 CSSOM.CSSDocumentRule = function CSSDocumentRule() {
     CSSOM.CSSRule.call(this);
@@ -2450,11 +2591,18 @@ Object.defineProperties(CSSOM.CSSScopeRule.prototype, {
   },
   cssText: {
     get: function () {
-      var cssTexts = [];
-      for (var i = 0, length = this.cssRules.length; i < length; i++) {
-        cssTexts.push(this.cssRules[i].cssText);
+			var values = "";
+			var valuesArr = [" {"];
+      if (this.cssRules.length) {
+        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+          if (rule.cssText !== "") {
+            acc.push(rule.cssText);
+          }
+          return acc;
+        }, []).join("\n  "));
       }
-      return "@scope " + (this.start ? "(" + this.start + ") " : "") + (this.end ? "to (" + this.end + ") " : "") + "{" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+      values = valuesArr.join("\n  ") + "\n}";
+      return "@scope" + (this.start ? " (" + this.start + ")" : "") + (this.end ? " to (" + this.end + ")" : "") + values;
     },
     configurable: true,
     enumerable: true,
@@ -2490,11 +2638,18 @@ CSSOM.CSSLayerBlockRule.prototype.type = 18;
 Object.defineProperties(CSSOM.CSSLayerBlockRule.prototype, {
   cssText: {
     get: function () {
-      var cssTexts = [];
-      for (var i = 0, length = this.cssRules.length; i < length; i++) {
-        cssTexts.push(this.cssRules[i].cssText);
+			var values = "";
+			var valuesArr = [" {"];
+      if (this.cssRules.length) {
+        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+          if (rule.cssText !== "") {
+            acc.push(rule.cssText);
+          }
+          return acc;
+        }, []).join("\n  "));
       }
-      return "@layer " + this.name + (this.name && " ") + "{" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+      values = valuesArr.join("\n  ") + "\n}";
+      return "@layer" + (this.name ? " " + this.name : "") + values;
     },
     configurable: true,
     enumerable: true,
@@ -2623,12 +2778,17 @@ Object.defineProperty(CSSOM.CSSPageRule.prototype, "style", {
 
 Object.defineProperty(CSSOM.CSSPageRule.prototype, "cssText", {
 	get: function() {
-        var values = ""
+        var values = "";
         if (this.cssRules.length) {
             var valuesArr = [" {"];
             this.style.cssText && valuesArr.push(this.style.cssText);
-            valuesArr.push(this.cssRules.map(function(rule){ return rule.cssText }).join("\n  "));
-            values = valuesArr.join("\n  ") + "\n}"
+            valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
+				if (rule.cssText !== "") {
+					acc.push(rule.cssText);
+				}
+				return acc;
+			}, []).join("\n  "));
+            values = valuesArr.join("\n  ") + "\n}";
         } else {
             values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
         }
@@ -2797,6 +2957,8 @@ CSSOM.CSSPageRule.parse = function(ruleText) {
  * @param {string} token - The CSS string to parse.
  * @param {object} [opts] - Optional parsing options.
  * @param {object} [opts.globalObject] - An optional global object to attach to the stylesheet. Useful on jsdom webplatform tests.
+ * @param {CSSOM.CSSStyleSheet} [opts.styleSheet] - Reuse a style sheet instead of creating a new one (e.g. as `parentStyleSheet`)
+ * @param {CSSOM.CSSRuleList} [opts.cssRules] - Prepare all rules in this list instead of mutating the style sheet continually
  * @param {function|boolean} [errorHandler] - Optional error handler function or `true` to use `console.error`.
  * @returns {CSSOM.CSSStyleSheet} The parsed CSSStyleSheet object.
  */
@@ -2843,14 +3005,26 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 		"pageBlock": true
 	};
 
-	var styleSheet = new CSSOM.CSSStyleSheet();
+	var styleSheet;
+	if (opts && opts.styleSheet) {
+		styleSheet = opts.styleSheet;
+	} else {
+		styleSheet = new CSSOM.CSSStyleSheet()
+	}
+
+	var topScope;
+	if (opts && opts.cssRules) {
+		topScope = { cssRules: opts.cssRules };
+	} else {
+		topScope = styleSheet;
+	}
 
 	if (opts && opts.globalObject) {
 		styleSheet.__globalObject = opts.globalObject;
 	}
 
 	// @type CSSStyleSheet|CSSMediaRule|CSSContainerRule|CSSSupportsRule|CSSFontFaceRule|CSSKeyframesRule|CSSDocumentRule
-	var currentScope = styleSheet;
+	var currentScope = topScope;
 
 	// @type CSSMediaRule|CSSContainerRule|CSSSupportsRule|CSSKeyframesRule|CSSDocumentRule
 	var parentRule;
@@ -3179,7 +3353,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 		var ruleRegExp = new RegExp(atRuleKey + sourceRuleRegExp.source, sourceRuleRegExp.flags);
 		var ruleSlice = token.slice(i);
 		// Not all rules can be nested, if the rule cannot be nested and is in the root scope, do not perform the check
-		var shouldPerformCheck = cannotBeNested && currentScope !== styleSheet ? false : true;
+		var shouldPerformCheck = cannotBeNested && currentScope !== topScope ? false : true;
 		// First, check if there is no invalid characters just after the at-rule
 		if (shouldPerformCheck && ruleSlice.search(ruleRegExp) === 0) {
 			// Find the closest allowed character before the at-rule (a opening or closing brace, a semicolon or a comment ending)
@@ -3311,7 +3485,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 			var ruleStatementMatch = atRulesStatemenRegExpES5Alternative(ruleSlice);
 
 			// If it's a statement inside a nested rule, ignore only the statement
-			if (ruleStatementMatch && currentScope !== styleSheet) {
+			if (ruleStatementMatch && currentScope !== topScope) {
 				var ignoreEnd = ruleStatementMatch[0].indexOf(";");
 				i += ruleStatementMatch.index + ignoreEnd;
 				return;
@@ -3336,6 +3510,255 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 		}
 	}
 
+	// Helper functions for looseSelectorValidator
+	// Defined outside to avoid recreation on every validation call
+	
+	/**
+	 * Check if character is a valid identifier start
+	 * @param {string} c - Character to check
+	 * @returns {boolean}
+	 */
+	function isIdentStart(c) {
+		return /[a-zA-Z_\u00A0-\uFFFF]/.test(c);
+	}
+
+	/**
+	 * Check if character is a valid identifier character
+	 * @param {string} c - Character to check
+	 * @returns {boolean}
+	 */
+	function isIdentChar(c) {
+		return /[a-zA-Z0-9_\u00A0-\uFFFF\-]/.test(c);
+	}
+
+	/**
+	 * Helper function to validate CSS selector syntax without regex backtracking.
+	 * Iteratively parses the selector string to identify valid components.
+	 * 
+	 * Supports:
+	 * - Escaped special characters (e.g., .class\!, #id\@name)
+	 * - Namespace selectors (ns|element, *|element, |element)
+	 * - All standard CSS selectors (class, ID, type, attribute, pseudo, etc.)
+	 * - Combinators (>, +, ~, whitespace)
+	 * - Nesting selector (&)
+	 * 
+	 * This approach eliminates exponential backtracking by using explicit character-by-character
+	 * parsing instead of nested quantifiers in regex.
+	 * 
+	 * @param {string} selector - The selector to validate
+	 * @returns {boolean} - True if valid selector syntax
+	 */
+	function looseSelectorValidator(selector) {
+		if (!selector || selector.length === 0) {
+			return false;
+		}
+
+		var i = 0;
+		var len = selector.length;
+		var hasMatchedComponent = false;
+
+		// Helper: Skip escaped character (backslash + any char)
+		function skipEscape() {
+			if (i < len && selector[i] === '\\') {
+				i += 2; // Skip backslash and next character
+				return true;
+			}
+			return false;
+		}
+
+		// Helper: Parse identifier (with possible escapes)
+		function parseIdentifier() {
+			var start = i;
+			while (i < len) {
+				if (skipEscape()) {
+					continue;
+				} else if (isIdentChar(selector[i])) {
+					i++;
+				} else {
+					break;
+				}
+			}
+			return i > start;
+		}
+
+		// Helper: Parse namespace prefix (optional)
+		function parseNamespace() {
+			var start = i;
+			
+			// Match: *| or identifier| or |
+			if (i < len && selector[i] === '*') {
+				i++;
+			} else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\')) {
+				parseIdentifier();
+			}
+			
+			if (i < len && selector[i] === '|') {
+				i++;
+				return true;
+			}
+			
+			// Rollback if no pipe found
+			i = start;
+			return false;
+		}
+
+		// Helper: Parse pseudo-class/element arguments (with balanced parens)
+		function parsePseudoArgs() {
+			if (i >= len || selector[i] !== '(') {
+				return false;
+			}
+			
+			i++; // Skip opening paren
+			var depth = 1;
+			var inString = false;
+			var stringChar = '';
+			
+			while (i < len && depth > 0) {
+				var c = selector[i];
+				
+				if (c === '\\' && i + 1 < len) {
+					i += 2; // Skip escaped character
+				} else if (!inString && (c === '"' || c === '\'')) {
+					inString = true;
+					stringChar = c;
+					i++;
+				} else if (inString && c === stringChar) {
+					inString = false;
+					i++;
+				} else if (!inString && c === '(') {
+					depth++;
+					i++;
+				} else if (!inString && c === ')') {
+					depth--;
+					i++;
+				} else {
+					i++;
+				}
+			}
+			
+			return depth === 0;
+		}
+
+		// Main parsing loop
+		while (i < len) {
+			var matched = false;
+			var start = i;
+
+			// Skip whitespace
+			while (i < len && /\s/.test(selector[i])) {
+				i++;
+			}
+			if (i > start) {
+				hasMatchedComponent = true;
+				continue;
+			}
+
+			// Match combinators: >, +, ~
+			if (i < len && /[>+~]/.test(selector[i])) {
+				i++;
+				hasMatchedComponent = true;
+				// Skip trailing whitespace
+				while (i < len && /\s/.test(selector[i])) {
+					i++;
+				}
+				continue;
+			}
+
+			// Match nesting selector: &
+			if (i < len && selector[i] === '&') {
+				i++;
+				hasMatchedComponent = true;
+				matched = true;
+			}
+			// Match class selector: .identifier
+			else if (i < len && selector[i] === '.') {
+				i++;
+				if (parseIdentifier()) {
+					hasMatchedComponent = true;
+					matched = true;
+				}
+			}
+			// Match ID selector: #identifier
+			else if (i < len && selector[i] === '#') {
+				i++;
+				if (parseIdentifier()) {
+					hasMatchedComponent = true;
+					matched = true;
+				}
+			}
+			// Match pseudo-class/element: :identifier or ::identifier
+			else if (i < len && selector[i] === ':') {
+				i++;
+				if (i < len && selector[i] === ':') {
+					i++; // Pseudo-element
+				}
+				if (parseIdentifier()) {
+					parsePseudoArgs(); // Optional arguments
+					hasMatchedComponent = true;
+					matched = true;
+				}
+			}
+			// Match attribute selector: [...]
+			else if (i < len && selector[i] === '[') {
+				i++;
+				var depth = 1;
+				while (i < len && depth > 0) {
+					if (selector[i] === '\\') {
+						i += 2;
+					} else if (selector[i] === '\'') {
+						i++;
+						while (i < len && selector[i] !== '\'') {
+							if (selector[i] === '\\') i += 2;
+							else i++;
+						}
+						if (i < len) i++; // Skip closing quote
+					} else if (selector[i] === '"') {
+						i++;
+						while (i < len && selector[i] !== '"') {
+							if (selector[i] === '\\') i += 2;
+							else i++;
+						}
+						if (i < len) i++; // Skip closing quote
+					} else if (selector[i] === '[') {
+						depth++;
+						i++;
+					} else if (selector[i] === ']') {
+						depth--;
+						i++;
+					} else {
+						i++;
+					}
+				}
+				if (depth === 0) {
+					hasMatchedComponent = true;
+					matched = true;
+				}
+			}
+			// Match type selector with optional namespace: [namespace|]identifier
+			else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\' || selector[i] === '*' || selector[i] === '|')) {
+				parseNamespace(); // Optional namespace prefix
+				
+				if (i < len && selector[i] === '*') {
+					i++; // Universal selector
+					hasMatchedComponent = true;
+					matched = true;
+				} else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\')) {
+					if (parseIdentifier()) {
+						hasMatchedComponent = true;
+						matched = true;
+					}
+				}
+			}
+
+			// If no match found, invalid selector
+			if (!matched && i === start) {
+				return false;
+			}
+		}
+
+		return hasMatchedComponent;
+	}
+
 	/**
 	 * Validates a basic CSS selector, allowing for deeply nested balanced parentheses in pseudo-classes.
 	 * This function replaces the previous basicSelectorRegExp.
@@ -3360,6 +3783,12 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 	 * @returns {boolean}
 	 */
 	function basicSelectorValidator(selector) {
+		// Guard against extremely long selectors to prevent potential regex performance issues
+		// Reasonable selectors are typically under 1000 characters
+		if (selector.length > 10000) {
+			return false;
+		}
+
 		// Validate balanced syntax with attribute tracking and stack-based parentheses matching
 		if (!validateBalancedSyntax(selector, true, true)) {
 			return false;
@@ -3382,31 +3811,69 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 		// Check for invalid pseudo-class usage with quoted strings
 		// Pseudo-classes like :lang(), :dir(), :nth-*() should not accept quoted strings
-		var pseudoPattern = /::?([a-zA-Z][\w-]*)\(([^)]+)\)/g;
-		var pseudoMatch;
-		while ((pseudoMatch = pseudoPattern.exec(selector)) !== null) {
-			var pseudoName = pseudoMatch[1];
-			var pseudoContent = pseudoMatch[2];
-			
-			// List of pseudo-classes that should not accept quoted strings
-			// :lang() - accepts language codes: en, fr-CA
-			// :dir() - accepts direction: ltr, rtl
-			// :nth-*() - accepts An+B notation: 2n+1, odd, even
-			var noQuotesPseudos = ['lang', 'dir', 'nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type'];
-			
-			for (var i = 0; i < noQuotesPseudos.length; i++) {
-				if (pseudoName === noQuotesPseudos[i] && /['"]/.test(pseudoContent)) {
-					return false;
+		// Using iterative parsing instead of regex to avoid exponential backtracking
+		var noQuotesPseudos = ['lang', 'dir', 'nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type'];
+		
+		for (var idx = 0; idx < selector.length; idx++) {
+			// Look for pseudo-class/element start
+			if (selector[idx] === ':') {
+				var pseudoStart = idx;
+				idx++;
+				
+				// Skip second colon for pseudo-elements
+				if (idx < selector.length && selector[idx] === ':') {
+					idx++;
+				}
+				
+				// Extract pseudo name
+				var nameStart = idx;
+				while (idx < selector.length && /[a-zA-Z0-9\-]/.test(selector[idx])) {
+					idx++;
+				}
+				
+				if (idx === nameStart) {
+					continue; // No name found
+				}
+				
+				var pseudoName = selector.substring(nameStart, idx).toLowerCase();
+				
+				// Check if this pseudo has arguments
+				if (idx < selector.length && selector[idx] === '(') {
+					idx++;
+					var contentStart = idx;
+					var depth = 1;
+					
+					// Find matching closing paren (handle nesting)
+					while (idx < selector.length && depth > 0) {
+						if (selector[idx] === '\\') {
+							idx += 2; // Skip escaped character
+						} else if (selector[idx] === '(') {
+							depth++;
+							idx++;
+						} else if (selector[idx] === ')') {
+							depth--;
+							idx++;
+						} else {
+							idx++;
+						}
+					}
+					
+					if (depth === 0) {
+						var pseudoContent = selector.substring(contentStart, idx - 1);
+						
+						// Check if this pseudo should not have quoted strings
+						for (var j = 0; j < noQuotesPseudos.length; j++) {
+							if (pseudoName === noQuotesPseudos[j] && /['"]/.test(pseudoContent)) {
+								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
-		// Modified to support namespace selectors: *|element, prefix|element, |element
-		// Fixed attribute selector regex to properly handle |=, ~=, ^=, $=, *= operators
-		var looseSelectorRegExp = /^((?:(?:\*|[a-zA-Z_\u00A0-\uFFFF\\][a-zA-Z0-9_\u00A0-\uFFFF\-\\]*|)\|)?[a-zA-Z_\u00A0-\uFFFF\\][a-zA-Z0-9_\u00A0-\uFFFF\-\\]*|(?:(?:\*|[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);
+		// Use the iterative validator to avoid regex backtracking issues
+		return looseSelectorValidator(selector);
 	}
 	
 	/**
@@ -3424,9 +3891,96 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 	 *   - :nth-child(2n+1)
 	 *   - :has(.sel:nth-child(3n))
 	 *   - :not(".foo, .bar")
-	 * @type {RegExp}
+	 *
+	 * REPLACED WITH FUNCTION to avoid exponential backtracking.
 	 */
-	var globalPseudoClassRegExp = /:([a-zA-Z-]+)\(((?:[^()"]+|"[^"]*"|'[^']*'|\((?:[^()"]+|"[^"]*"|'[^']*')*\))*?)\)/g;
+	
+	/**
+	 * Extract pseudo-classes with arguments from a selector using iterative parsing.
+	 * Replaces the previous globalPseudoClassRegExp to avoid exponential backtracking.
+	 * 
+	 * Handles:
+	 * - Regular content without parentheses or quotes
+	 * - Single-quoted strings
+	 * - Double-quoted strings  
+	 * - Nested parentheses (arbitrary depth)
+	 * 
+	 * @param {string} selector - The CSS selector to parse
+	 * @returns {Array} Array of matches, each with: [fullMatch, pseudoName, pseudoArgs, startIndex]
+	 */
+	function extractPseudoClasses(selector) {
+		var matches = [];
+		
+		for (var i = 0; i < selector.length; i++) {
+			// Look for pseudo-class start (single or double colon)
+			if (selector[i] === ':') {
+				var pseudoStart = i;
+				i++;
+				
+				// Skip second colon for pseudo-elements (::)
+				if (i < selector.length && selector[i] === ':') {
+					i++;
+				}
+				
+				// Extract pseudo name
+				var nameStart = i;
+				while (i < selector.length && /[a-zA-Z\-]/.test(selector[i])) {
+					i++;
+				}
+				
+				if (i === nameStart) {
+					continue; // No name found
+				}
+				
+				var pseudoName = selector.substring(nameStart, i);
+				
+				// Check if this pseudo has arguments
+				if (i < selector.length && selector[i] === '(') {
+					i++;
+					var argsStart = i;
+					var depth = 1;
+					var inSingleQuote = false;
+					var inDoubleQuote = false;
+					
+					// Find matching closing paren (handle nesting and strings)
+					while (i < selector.length && depth > 0) {
+						var ch = selector[i];
+						
+						if (ch === '\\') {
+							i += 2; // Skip escaped character
+						} else if (ch === "'" && !inDoubleQuote) {
+							inSingleQuote = !inSingleQuote;
+							i++;
+						} else if (ch === '"' && !inSingleQuote) {
+							inDoubleQuote = !inDoubleQuote;
+							i++;
+						} else if (ch === '(' && !inSingleQuote && !inDoubleQuote) {
+							depth++;
+							i++;
+						} else if (ch === ')' && !inSingleQuote && !inDoubleQuote) {
+							depth--;
+							i++;
+						} else {
+							i++;
+						}
+					}
+					
+					if (depth === 0) {
+						var pseudoArgs = selector.substring(argsStart, i - 1);
+						var fullMatch = selector.substring(pseudoStart, i);
+						
+						// Store match in same format as regex: [fullMatch, pseudoName, pseudoArgs, startIndex]
+						matches.push([fullMatch, pseudoName, pseudoArgs, pseudoStart]);
+					}
+					
+					// Move back one since loop will increment
+					i--;
+				}
+			}
+		}
+		
+		return matches;
+	}
 
 	/**
 	 * Parses a CSS selector string and splits it into parts, handling nested parentheses.
@@ -3521,13 +4075,8 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 			return validatedSelectorsCache[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) {
-			pseudoClassMatches.push(match);
-		}
+		// Use function-based parsing to extract pseudo-classes (avoids backtracking)
+		var pseudoClassMatches = extractPseudoClasses(selector);
 
 		for (var j = 0; j < pseudoClassMatches.length; j++) {
 			var pseudoClass = pseudoClassMatches[j][1];
@@ -3668,6 +4217,12 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 		return true;
 	}
 
+	function pushToAncestorRules(rule) {
+		if (ancestorRules.indexOf(rule) === -1) {
+			ancestorRules.push(rule);
+		}
+	}
+
 	function parseError(message, isNested) {
 		var lines = token.substring(0, i).split('\n');
 		var lineCount = lines.length;
@@ -3695,11 +4250,46 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 				case "namespaceRule":
 				case "layerBlock":
 					if (character !== ";") {
-						token += ";"
+						token += ";";
+						break;
+					}
+				case "value":
+					if (character !== "}") {
+						if (character === ";") {
+							token += "}"
+						} else {
+							token += ";";
+						}
+						endingIndex += 1;
+						break;
+					}
+				case "name":
+				case "before-name":
+					if (character === "}") {
+						token += " "
+					} else {
+						token += "}"
+					}
+					endingIndex += 1
+					break;
+				case "before-selector":
+					if (character !== "}" && currentScope !== styleSheet) {
+						token += "}"
+						endingIndex += 1
+						break;
 					}
 			}
 		}
 		
+		// Handle escape sequences before processing special characters
+		// If we encounter a backslash, add both the backslash and the next character to buffer
+		// and skip the next iteration to prevent the escaped character from being interpreted
+		if (character === '\\' && i + 1 < token.length) {
+			buffer += character + token.charAt(i + 1);
+			i++; // Skip the next character
+			continue;
+		}
+		
 		switch (character) {
 
 		case " ":
@@ -3797,6 +4387,15 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 		// At-rule
 		case "@":
+			if (nestedSelectorRule) {
+				if (styleRule && styleRule.constructor.name === "CSSNestedDeclarations") {
+					currentScope.cssRules.push(styleRule);
+				}
+				if (nestedSelectorRule.parentRule.constructor.name === "CSSStyleRule") {
+					styleRule = nestedSelectorRule.parentRule;
+				}
+				nestedSelectorRule = null;
+			}
 			if (token.indexOf("@-moz-document", i) === i) {
 				validateAtRule("@-moz-document", function(){
 					state = "documentRule-begin";
@@ -3931,7 +4530,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 			break;
 
 		case "{":
-			if (currentScope === styleSheet) {
+			if (currentScope === topScope) {
 				nestedSelectorRule = null;
 			}
 			if (state === 'before-selector') {
@@ -3953,7 +4552,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 				if (parentRule) {
 					styleRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 
 				currentScope = parentRule = styleRule;
@@ -3967,7 +4566,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 				if (parentRule) {
 					mediaRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 
 				currentScope = parentRule = mediaRule;
@@ -3979,7 +4578,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 				if (parentRule) {
 					containerRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 				currentScope = parentRule = containerRule;
 				containerRule.__parentStyleSheet = styleSheet;
@@ -3996,7 +4595,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 				if (parentRule) {
 					supportsRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 
 				currentScope = parentRule = supportsRule;
@@ -4018,7 +4617,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 				if (parentRule) {
 					scopeRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 				currentScope = parentRule = scopeRule;
 				scopeRule.__parentStyleSheet = styleSheet;
@@ -4032,7 +4631,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 				if (isValidName) {
 					if (parentRule) {
 						layerBlockRule.__parentRule = parentRule;
-						ancestorRules.push(parentRule);
+						pushToAncestorRules(parentRule);
 					}
 	
 					currentScope = parentRule = layerBlockRule;
@@ -4045,7 +4644,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 
 				if (parentRule) {
 					pageRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 
 				currentScope = parentRule = pageRule;
@@ -4055,7 +4654,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 				state = "before-name";
 			} else if (state === "hostRule-begin") {
 				if (parentRule) {
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 
 				currentScope = parentRule = hostRule;
@@ -4065,7 +4664,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 			} else if (state === "startingStyleRule-begin") {
 				if (parentRule) {
 					startingStyleRule.__parentRule = parentRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 				}
 
 				currentScope = parentRule = startingStyleRule;
@@ -4084,7 +4683,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 			} else if (state === "keyframesRule-begin") {
 				keyframesRule.name = buffer.trim();
 				if (parentRule) {
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 					keyframesRule.__parentRule = parentRule;
 				}
 				keyframesRule.__parentStyleSheet = styleSheet;
@@ -4101,7 +4700,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 				// FIXME: what if this '{' is in the url text of the match function?
 				documentRule.matcher.matcherText = buffer.trim();
 				if (parentRule) {
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 					documentRule.__parentRule = parentRule;
 				}
 				currentScope = parentRule = documentRule;
@@ -4114,21 +4713,21 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 						parentRule.cssRules.push(styleRule);
 						styleRule.__parentRule = parentRule;
 						styleRule.__parentStyleSheet = styleSheet;
-						ancestorRules.push(parentRule);
+						pushToAncestorRules(parentRule);
 					} else {
 						// If the styleRule is empty, we can assume that it's a nested selector
-						ancestorRules.push(parentRule);
+						pushToAncestorRules(parentRule);
 					}
 				} else {
 					currentScope = parentRule = styleRule;
-					ancestorRules.push(parentRule);
+					pushToAncestorRules(parentRule);
 					styleRule.__parentStyleSheet = styleSheet;
 				}
 				
 				styleRule = new CSSOM.CSSStyleRule();
 				var processedSelectorText = processSelectorText(buffer.trim());
 				// In a nested selector, ensure each selector contains '&' at the beginning, except for selectors that already have '&' somewhere
-				if (parentRule.constructor.name !== "CSSStyleRule" && parentRule.parentRule === null) {
+				if (parentRule.constructor.name === "CSSScopeRule" || (parentRule.constructor.name !== "CSSStyleRule" && parentRule.parentRule === null)) {
 					styleRule.selectorText = processedSelectorText;
 				} else {
 					styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).map(function(sel) {
@@ -4227,20 +4826,20 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 					state = "before-selector";
 					break;
 				case "importRule":
-					var isValid = styleSheet.cssRules.length === 0 || styleSheet.cssRules.some(function (rule) {
+					var isValid = topScope.cssRules.length === 0 || topScope.cssRules.some(function (rule) {
 						return ['CSSImportRule', 'CSSLayerStatementRule'].indexOf(rule.constructor.name) !== -1
 					});
 					if (isValid) {
 						importRule = new CSSOM.CSSImportRule();
 						importRule.__parentStyleSheet = importRule.styleSheet.__parentStyleSheet = styleSheet;
 						importRule.cssText = buffer + character;
-						styleSheet.cssRules.push(importRule);
+						topScope.cssRules.push(importRule);
 					}
 					buffer = "";
 					state = "before-selector";
 					break;
 				case "namespaceRule":
-					var isValid = styleSheet.cssRules.length === 0 || styleSheet.cssRules.every(function (rule) {
+					var isValid = topScope.cssRules.length === 0 || topScope.cssRules.every(function (rule) {
 						return ['CSSImportRule','CSSLayerStatementRule','CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
 					});
 					if (isValid) {
@@ -4251,7 +4850,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 							
 							namespaceRule = testNamespaceRule;
 							namespaceRule.__parentStyleSheet = styleSheet;
-							styleSheet.cssRules.push(namespaceRule);
+							topScope.cssRules.push(namespaceRule);
 							
 							// Track the namespace prefix for validation
 							if (namespaceRule.prefix) {
@@ -4278,7 +4877,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 						layerStatementRule.__starts = layerBlockRule.__starts;
 						layerStatementRule.__ends = i;
 						layerStatementRule.nameList = nameListStr;
-						styleSheet.cssRules.push(layerStatementRule);
+						topScope.cssRules.push(layerStatementRule);
 					}
 					buffer = "";
 					state = "before-selector";
@@ -4319,7 +4918,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 					styleRule.__parentStyleSheet = styleSheet;
 
 					if (currentScope === styleRule) {
-						currentScope = parentRule || styleSheet;
+						currentScope = parentRule || topScope;
 					}
 
 					if (styleRule.constructor.name === "CSSStyleRule" && !isValidSelectorText(styleRule.selectorText)) {
@@ -4328,7 +4927,11 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 						}
 						parseError('Invalid CSSStyleRule (selectorText = "' + styleRule.selectorText + '")', styleRule.parentRule !== null);
 					} else {
-						currentScope.cssRules.push(styleRule);
+						if (styleRule.parentRule) {
+							styleRule.parentRule.cssRules.push(styleRule);
+						} else {
+							currentScope.cssRules.push(styleRule);
+						}
 					}
 					buffer = "";
 					if (currentScope.constructor === CSSOM.CSSKeyframesRule) {
@@ -4338,7 +4941,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 					}
 
 					if (styleRule.constructor.name === "CSSNestedDeclarations") {
-						if (currentScope !== styleSheet) {
+						if (currentScope !== topScope) {
 							nestedSelectorRule = currentScope;
 						}
 						styleRule = null;
@@ -4361,7 +4964,6 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 						break;
 					}
 
-
 					while (ancestorRules.length > 0) {
 						parentRule = ancestorRules.pop();
 
@@ -4387,8 +4989,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 								}
 							} else {
 								prevScope = currentScope;
-								currentScope = parentRule;
-								currentScope !== prevScope && currentScope.cssRules.push(prevScope);
+								parentRule !== prevScope && parentRule.cssRules.push(prevScope);
 								break;
 							}
 						}
@@ -4396,12 +4997,12 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 					
 					if (currentScope.parentRule == null) {
 						currentScope.__ends = i + 1;
-						if (currentScope !== styleSheet && styleSheet.cssRules.findIndex(function (rule) {
+						if (currentScope !== topScope && topScope.cssRules.findIndex(function (rule) {
 							return rule === currentScope
 						}) === -1) {
-							styleSheet.cssRules.push(currentScope);
+							topScope.cssRules.push(currentScope);
 						}
-						currentScope = styleSheet;
+						currentScope = topScope;
 						if (nestedSelectorRule === parentRule) {
 							// Check if this selector is really starting inside another selector
 							var nestedSelectorTokenToCurrentSelectorToken = token.slice(nestedSelectorRule.__starts, i + 1);
@@ -4420,6 +5021,8 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 							parentRule = null;
 
 						}
+					} else {
+						currentScope = parentRule;
 					}
 
 					buffer = "";
@@ -4432,7 +5035,7 @@ CSSOM.parse = function parse(token, opts, errorHandler) {
 			switch (state) {
 				case "before-selector":
 					state = "selector";
-					if (styleRule && parentRule) {
+					if ((styleRule || scopeRule) && parentRule) {
 						// Assuming it's a declaration inside Nested Selector OR a Nested Declaration
 						// If Declaration inside Nested Selector let's keep the same styleRule
 						if (