@acemir/cssom 0.9.16 → 0.9.17

package/lib/errorUtils.js

@@ -0,0 +1,118 @@
+// Utility functions for CSSOM error handling
+
+/**
+ * Gets the appropriate error constructor from the global object context.
+ * Tries to find the error constructor from parentStyleSheet._globalObject,
+ * then from _globalObject, then falls back to the native constructor.
+ * 
+ * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
+ * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
+ * @return {Function} The error constructor
+ */
+function getErrorConstructor(context, errorType) {
+	// Try parentStyleSheet._globalObject first
+	if (context.parentStyleSheet && context.parentStyleSheet._globalObject && context.parentStyleSheet._globalObject[errorType]) {
+		return context.parentStyleSheet._globalObject[errorType];
+	}
+	
+	// Try __parentStyleSheet (alternative naming)
+	if (context.__parentStyleSheet && context.__parentStyleSheet._globalObject && context.__parentStyleSheet._globalObject[errorType]) {
+		return context.__parentStyleSheet._globalObject[errorType];
+	}
+	
+	// Try _globalObject on the context itself
+	if (context._globalObject && context._globalObject[errorType]) {
+		return context._globalObject[errorType];
+	}
+	
+	// Fall back to native constructor
+	return (typeof global !== 'undefined' && global[errorType]) || 
+	       (typeof window !== 'undefined' && window[errorType]) || 
+	       eval(errorType);
+}
+
+/**
+ * Creates and throws 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 throwError(context, errorType, message, name) {
+	var ErrorConstructor = getErrorConstructor(context, errorType);
+	var error = new ErrorConstructor(message, name);
+	throw error;
+}
+
+/**
+ * Throws a TypeError for missing required arguments.
+ * 
+ * @param {Object} context - The CSSOM object
+ * @param {string} methodName - The method name (e.g., 'appendRule')
+ * @param {string} objectName - The object name (e.g., 'CSSKeyframesRule')
+ * @param {number} [required=1] - Number of required arguments
+ * @param {number} [provided=0] - Number of provided arguments
+ */
+function throwMissingArguments(context, methodName, objectName, required, provided) {
+	required = required || 1;
+	provided = provided || 0;
+	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " + 
+	              required + " argument" + (required > 1 ? "s" : "") + " required, but only " + 
+	              provided + " present.";
+	throwError(context, 'TypeError', message);
+}
+
+/**
+ * Throws a RangeError for index out of bounds.
+ * 
+ * @param {Object} context - The CSSOM object
+ * @param {string} [message] - Optional custom message, defaults to 'INDEX_SIZE_ERR'
+ */
+function throwIndexSizeError(context, message) {
+	throwError(context, 'RangeError', message || 'INDEX_SIZE_ERR');
+}
+
+/**
+ * Throws a DOMException for parse errors.
+ * 
+ * @param {Object} context - The CSSOM object
+ * @param {string} methodName - The method name
+ * @param {string} objectName - The object name
+ * @param {string} rule - The rule that failed to parse
+ * @param {string} [name='SyntaxError'] - The DOMException name
+ */
+function throwParseError(context, methodName, objectName, rule, name) {
+	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " +
+	              "Failed to parse the rule '" + rule + "'.";
+	throwError(context, 'DOMException', message, name || 'SyntaxError');
+}
+
+/**
+ * Throws a DOMException for index errors.
+ * 
+ * @param {Object} context - The CSSOM object
+ * @param {string} methodName - The method name
+ * @param {string} objectName - The object name
+ * @param {number} index - The invalid index
+ * @param {number} maxIndex - The maximum valid index
+ * @param {string} [name='IndexSizeError'] - The DOMException name
+ */
+function throwIndexError(context, methodName, objectName, index, maxIndex, name) {
+	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " +
+	              "The index provided (" + index + ") is larger than the maximum index (" + maxIndex + ").";
+	throwError(context, 'DOMException', message, name || 'IndexSizeError');
+}
+
+var errorUtils = {
+	getErrorConstructor: getErrorConstructor,
+	throwError: throwError,
+	throwMissingArguments: throwMissingArguments,
+	throwIndexSizeError: throwIndexSizeError,
+	throwParseError: throwParseError,
+	throwIndexError: throwIndexError
+};
+
+//.CommonJS
+exports.errorUtils = errorUtils;
+///CommonJS

package/lib/index.js

@@ -1,6 +1,11 @@
 'use strict';
 
+require('./errorUtils');
+
 exports.CSSStyleDeclaration = require('./CSSStyleDeclaration').CSSStyleDeclaration;
+
+require('./cssstyleTryCatchBlock');
+
 exports.CSSRule = require('./CSSRule').CSSRule;
 exports.CSSNestedDeclarations = require('./CSSNestedDeclarations').CSSNestedDeclarations;
 exports.CSSGroupingRule = require('./CSSGroupingRule').CSSGroupingRule;

package/lib/parse.js

@@ -788,7 +788,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 				}
 
 				if (parentRule) {
-					styleRule.parentRule = parentRule;
+					styleRule.__parentRule = parentRule;
 					ancestorRules.push(parentRule);
 				}
 
@@ -798,48 +798,48 @@ CSSOM.parse = function parse(token, errorHandler) {
 					return match;
 				});
 				styleRule.style.__starts = i;
-				styleRule.parentStyleSheet = styleSheet;
+				styleRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-name";
 			} else if (state === "atBlock") {
 				mediaRule.media.mediaText = buffer.trim();
 
 				if (parentRule) {
-					mediaRule.parentRule = parentRule;
+					mediaRule.__parentRule = parentRule;
 					ancestorRules.push(parentRule);
 				}
 
 				currentScope = parentRule = mediaRule;
-				mediaRule.parentStyleSheet = styleSheet;
+				mediaRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
 			} else if (state === "containerBlock") {
 				containerRule.containerText = buffer.trim();
 
 				if (parentRule) {
-					containerRule.parentRule = parentRule;
+					containerRule.__parentRule = parentRule;
 					ancestorRules.push(parentRule);
 				}
 				currentScope = parentRule = containerRule;
-				containerRule.parentStyleSheet = styleSheet;
+				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().replace(/\n/g, "");
 				currentScope = parentRule = counterStyleRule;
-				counterStyleRule.parentStyleSheet = styleSheet;
+				counterStyleRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 			} else if (state === "conditionBlock") {
 				supportsRule.conditionText = buffer.trim();
 
 				if (parentRule) {
-					supportsRule.parentRule = parentRule;
+					supportsRule.__parentRule = parentRule;
 					ancestorRules.push(parentRule);
 				}
 
 				currentScope = parentRule = supportsRule;
-				supportsRule.parentStyleSheet = styleSheet;
+				supportsRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
 			} else if (state === "layerBlock") {
@@ -849,12 +849,12 @@ CSSOM.parse = function parse(token, errorHandler) {
 
 				if (isValidName) {
 					if (parentRule) {
-						layerBlockRule.parentRule = parentRule;
+						layerBlockRule.__parentRule = parentRule;
 						ancestorRules.push(parentRule);
 					}
 	
 					currentScope = parentRule = layerBlockRule;
-					layerBlockRule.parentStyleSheet = styleSheet;
+					layerBlockRule.__parentStyleSheet = styleSheet;
 				}
 				buffer = "";
 				state = "before-selector";
@@ -864,25 +864,25 @@ CSSOM.parse = function parse(token, errorHandler) {
 				}
 
 				currentScope = parentRule = hostRule;
-				hostRule.parentStyleSheet = styleSheet;
+				hostRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
 			} else if (state === "startingStyleRule-begin") {
 				if (parentRule) {
-					startingStyleRule.parentRule = parentRule;
+					startingStyleRule.__parentRule = parentRule;
 					ancestorRules.push(parentRule);
 				}
 
 				currentScope = parentRule = startingStyleRule;
-				startingStyleRule.parentStyleSheet = styleSheet;
+				startingStyleRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
 
 			} else if (state === "fontFaceRule-begin") {
 				if (parentRule) {
-					fontFaceRule.parentRule = parentRule;
+					fontFaceRule.__parentRule = parentRule;
 				}
-				fontFaceRule.parentStyleSheet = styleSheet;
+				fontFaceRule.__parentStyleSheet = styleSheet;
 				styleRule = fontFaceRule;
 				buffer = "";
 				state = "before-name";
@@ -890,9 +890,9 @@ CSSOM.parse = function parse(token, errorHandler) {
 				keyframesRule.name = buffer.trim();
 				if (parentRule) {
 					ancestorRules.push(parentRule);
-					keyframesRule.parentRule = parentRule;
+					keyframesRule.__parentRule = parentRule;
 				}
-				keyframesRule.parentStyleSheet = styleSheet;
+				keyframesRule.__parentStyleSheet = styleSheet;
 				currentScope = parentRule = keyframesRule;
 				buffer = "";
 				state = "keyframeRule-begin";
@@ -907,18 +907,18 @@ CSSOM.parse = function parse(token, errorHandler) {
 				documentRule.matcher.matcherText = buffer.trim();
 				if (parentRule) {
 					ancestorRules.push(parentRule);
-					documentRule.parentRule = parentRule;
+					documentRule.__parentRule = parentRule;
 				}
 				currentScope = parentRule = documentRule;
-				documentRule.parentStyleSheet = styleSheet;
+				documentRule.__parentStyleSheet = styleSheet;
 				buffer = "";
 				state = "before-selector";
 			} else if (state === "before-name" || state === "name") {
 				if (styleRule.constructor.name === "CSSNestedDeclarations") {
 					if (styleRule.style.length) {
 						parentRule.cssRules.push(styleRule);
-						styleRule.parentRule = parentRule;
-						styleRule.parentStyleSheet = styleSheet;
+						styleRule.__parentRule = parentRule;
+						styleRule.__parentStyleSheet = styleSheet;
 						ancestorRules.push(parentRule);
 					} else {
 						// If the styleRule is empty, we can assume that it's a nested selector
@@ -927,7 +927,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 				} else {
 					currentScope = parentRule = styleRule;
 					ancestorRules.push(parentRule);
-					styleRule.parentStyleSheet = styleSheet;
+					styleRule.__parentStyleSheet = styleSheet;
 				}
 				
 				styleRule = new CSSOM.CSSStyleRule();
@@ -944,7 +944,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 						}).join(', ');
 				}
 				styleRule.style.__starts = i - buffer.length;
-				styleRule.parentRule = parentRule;
+				styleRule.__parentRule = parentRule;
 				nestedSelectorRule = styleRule;
 
 				buffer = "";
@@ -1039,7 +1039,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 					});
 					if (isValid) {
 						importRule = new CSSOM.CSSImportRule();
-						importRule.parentStyleSheet = importRule.styleSheet.parentStyleSheet = styleSheet;
+						importRule.__parentStyleSheet = importRule.styleSheet.__parentStyleSheet = styleSheet;
 						importRule.cssText = buffer + character;
 						styleSheet.cssRules.push(importRule);
 					}
@@ -1057,7 +1057,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 							testNamespaceRule.cssText = buffer + character;
 							
 							namespaceRule = testNamespaceRule;
-							namespaceRule.parentStyleSheet = namespaceRule.styleSheet.parentStyleSheet = styleSheet;
+							namespaceRule.__parentStyleSheet = namespaceRule.styleSheet.__parentStyleSheet = styleSheet;
 							styleSheet.cssRules.push(namespaceRule);
 							
 							// Track the namespace prefix for validation
@@ -1081,7 +1081,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 
 					if (!isInvalid) {
 						layerStatementRule = new CSSOM.CSSLayerStatementRule();
-						layerStatementRule.parentStyleSheet = styleSheet;
+						layerStatementRule.__parentStyleSheet = styleSheet;
 						layerStatementRule.__starts = layerBlockRule.__starts;
 						layerStatementRule.__ends = i;
 						layerStatementRule.nameList = nameListStr;
@@ -1121,9 +1121,9 @@ CSSOM.parse = function parse(token, errorHandler) {
 					}
 
 					if (parentRule) {
-						styleRule.parentRule = parentRule;
+						styleRule.__parentRule = parentRule;
 					}
-					styleRule.parentStyleSheet = styleSheet;
+					styleRule.__parentStyleSheet = styleSheet;
 
 					if (currentScope === styleRule) {
 						currentScope = parentRule || styleSheet;
@@ -1249,7 +1249,7 @@ CSSOM.parse = function parse(token, errorHandler) {
 							|| parentRule.constructor.name === "CSSLayerBlockRule"
 							|| parentRule.constructor.name === "CSSStartingStyleRule"
 						) {
-							// parentRule.parentRule = styleRule;
+							// parentRule.__parentRule = styleRule;
 							state = "before-name";
 							if (styleRule !== parentRule) {
 								styleRule = new CSSOM.CSSNestedDeclarations();
@@ -1329,4 +1329,10 @@ CSSOM.CSSValueExpression = require('./CSSValueExpression').CSSValueExpression;
 CSSOM.CSSDocumentRule = require('./CSSDocumentRule').CSSDocumentRule;
 CSSOM.CSSLayerBlockRule = require("./CSSLayerBlockRule").CSSLayerBlockRule;
 CSSOM.CSSLayerStatementRule = require("./CSSLayerStatementRule").CSSLayerStatementRule;
+// Use cssstyle if available
+try {
+	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
+} catch (e) {
+	// ignore
+}
 ///CommonJS

package/package.json

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