@acemir/cssom 0.9.19 → 0.9.21

package/lib/CSSPageRule.js

@@ -0,0 +1,275 @@
+//.CommonJS
+var CSSOM = {
+	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
+	CSSRule: require("./CSSRule").CSSRule,
+	CSSRuleList: require("./CSSRuleList").CSSRuleList,
+	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
+};
+// Use cssstyle if available
+try {
+	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
+} catch (e) {
+	// ignore
+}
+///CommonJS
+
+
+/**
+ * @constructor
+ * @see https://drafts.csswg.org/cssom/#the-csspagerule-interface
+ */
+CSSOM.CSSPageRule = function CSSPageRule() {
+	CSSOM.CSSGroupingRule.call(this);
+	this.__style = new CSSOM.CSSStyleDeclaration();
+	this.__style.parentRule = this;
+};
+
+CSSOM.CSSPageRule.prototype = new CSSOM.CSSGroupingRule();
+CSSOM.CSSPageRule.prototype.constructor = CSSOM.CSSPageRule;
+
+Object.defineProperty(CSSOM.CSSPageRule.prototype, "type", {
+	value: 6,
+	writable: false
+});
+
+Object.defineProperty(CSSOM.CSSPageRule.prototype, "selectorText", {
+    get: function() {
+        return this.__selectorText;	
+    },
+    set: function(value) {
+        if (typeof value === "string") {
+            var trimmedValue = value.trim();
+            
+            // Empty selector is valid for @page
+            if (trimmedValue === '') {
+                this.__selectorText = '';
+                return;
+            }
+            
+            // Parse @page selectorText for page name and pseudo-pages
+            // Valid formats:
+            // - (empty - no name, no pseudo-page)
+            // - :left, :right, :first, :blank (pseudo-page only)
+            // - named (named page only)
+            // - named:first (named page with single pseudo-page)
+            // - named:first:left (named page with multiple pseudo-pages)
+			var atPageRuleSelectorRegExp = /^([^\s:]+)?((?::\w+)*)$/;
+            var match = trimmedValue.match(atPageRuleSelectorRegExp);
+            if (match) {
+				var pageName = match[1] || '';
+                var pseudoPages = match[2] || '';
+
+				// Validate page name if present
+				if (pageName) {
+					var cssCustomIdentifierRegExp = /^(-?[_a-zA-Z]+(\.[_a-zA-Z]+)*[_a-zA-Z0-9-]*)$/; // Validates a css custom identifier
+					// Page name can be an identifier or a string
+					if (!cssCustomIdentifierRegExp.test(pageName)) {
+						return;
+					}
+				}
+                
+                // Validate pseudo-pages if present
+                if (pseudoPages) {
+                    var pseudos = pseudoPages.split(':').filter(function(p) { return p; });
+                    var validPseudos = ['left', 'right', 'first', 'blank'];
+                    var allValid = true;
+                    for (var j = 0; j < pseudos.length; j++) {
+                        if (validPseudos.indexOf(pseudos[j].toLowerCase()) === -1) {
+                            allValid = false;
+                            break;
+                        }
+                    }
+                    
+                    if (!allValid) {
+                        return; // Invalid pseudo-page, do nothing
+                    }
+                }
+                
+				this.__selectorText = pageName + pseudoPages.toLowerCase();
+            }
+        }
+    }
+});
+
+Object.defineProperty(CSSOM.CSSPageRule.prototype, "style", {
+	get: function() {
+		return this.__style;	
+	},
+	set: function(value) {
+		if (typeof value === "string") {
+			this.__style.cssText = value;
+		} else {
+			this.__style = value;
+		}
+	}
+});
+
+Object.defineProperty(CSSOM.CSSPageRule.prototype, "cssText", {
+	get: function() {
+        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}"
+        } else {
+            values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
+        }
+		return "@page" + (this.selectorText ? " " + this.selectorText : "") + values;
+	},
+	set: function(cssText) {
+		if (typeof value === "string") {
+			var rule = CSSOM.CSSPageRule.parse(cssText);
+			this.__style = rule.style;
+			this.selectorText = rule.selectorText;
+		}
+	}
+});
+
+/**
+ * NON-STANDARD
+ * lightweight version of parse.js.
+ * @param {string} ruleText
+ * @return CSSPageRule
+ */
+CSSOM.CSSPageRule.parse = function(ruleText) {
+	var i = 0;
+	var state = "selector";
+	var index;
+	var j = i;
+	var buffer = "";
+
+	var SIGNIFICANT_WHITESPACE = {
+		"selector": true,
+		"value": true
+	};
+
+	var pageRule = new CSSOM.CSSPageRule();
+	var name, priority="";
+
+	for (var character; (character = ruleText.charAt(i)); i++) {
+
+		switch (character) {
+
+		case " ":
+		case "\t":
+		case "\r":
+		case "\n":
+		case "\f":
+			if (SIGNIFICANT_WHITESPACE[state]) {
+				// Squash 2 or more white-spaces in the row into 1
+				switch (ruleText.charAt(i - 1)) {
+					case " ":
+					case "\t":
+					case "\r":
+					case "\n":
+					case "\f":
+						break;
+					default:
+						buffer += " ";
+						break;
+				}
+			}
+			break;
+
+		// String
+		case '"':
+			j = i + 1;
+			index = ruleText.indexOf('"', j) + 1;
+			if (!index) {
+				throw '" is missing';
+			}
+			buffer += ruleText.slice(i, index);
+			i = index - 1;
+			break;
+
+		case "'":
+			j = i + 1;
+			index = ruleText.indexOf("'", j) + 1;
+			if (!index) {
+				throw "' is missing";
+			}
+			buffer += ruleText.slice(i, index);
+			i = index - 1;
+			break;
+
+		// Comment
+		case "/":
+			if (ruleText.charAt(i + 1) === "*") {
+				i += 2;
+				index = ruleText.indexOf("*/", i);
+				if (index === -1) {
+					throw new SyntaxError("Missing */");
+				} else {
+					i = index + 1;
+				}
+			} else {
+				buffer += character;
+			}
+			break;
+
+		case "{":
+			if (state === "selector") {
+				pageRule.selectorText = buffer.trim();
+				buffer = "";
+				state = "name";
+			}
+			break;
+
+		case ":":
+			if (state === "name") {
+				name = buffer.trim();
+				buffer = "";
+				state = "value";
+			} else {
+				buffer += character;
+			}
+			break;
+
+		case "!":
+			if (state === "value" && ruleText.indexOf("!important", i) === i) {
+				priority = "important";
+				i += "important".length;
+			} else {
+				buffer += character;
+			}
+			break;
+
+		case ";":
+			if (state === "value") {
+				pageRule.style.setProperty(name, buffer.trim(), priority);
+				priority = "";
+				buffer = "";
+				state = "name";
+			} else {
+				buffer += character;
+			}
+			break;
+
+		case "}":
+			if (state === "value") {
+				pageRule.style.setProperty(name, buffer.trim(), priority);
+				priority = "";
+				buffer = "";
+			} else if (state === "name") {
+				break;
+			} else {
+				buffer += character;
+			}
+			state = "selector";
+			break;
+
+		default:
+			buffer += character;
+			break;
+
+		}
+	}
+
+	return pageRule;
+
+};
+
+//.CommonJS
+exports.CSSPageRule = CSSOM.CSSPageRule;
+///CommonJS

package/lib/CSSRule.js

@@ -37,6 +37,12 @@ Object.defineProperties(CSSOM.CSSRule.prototype, {
 
   constructor: { value: CSSOM.CSSRule },
 
+  cssRule: {
+    value: "",
+    configurable: true,
+    enumerable: true
+  },
+
   parentRule: {
     get: function() {
       return this.__parentRule

package/lib/CSSRuleList.js

@@ -0,0 +1,26 @@
+//.CommonJS
+var CSSOM = {};
+///CommonJS
+
+
+/**
+ * @constructor
+ * @see https://drafts.csswg.org/cssom/#the-cssrulelist-interface
+ */
+CSSOM.CSSRuleList = function CSSRuleList(){
+  const arr = new Array();
+  Object.setPrototypeOf(arr, CSSOM.CSSRuleList.prototype);
+  return arr;
+};
+
+CSSOM.CSSRuleList.prototype = Object.create(Array.prototype);
+CSSOM.CSSRuleList.prototype.constructor = CSSOM.CSSRuleList;
+
+CSSOM.CSSRuleList.prototype.item = function(index) {
+    return this[index] || null;
+};
+
+
+//.CommonJS
+exports.CSSRuleList = CSSOM.CSSRuleList;
+///CommonJS

package/lib/CSSScopeRule.js

@@ -0,0 +1,53 @@
+//.CommonJS
+var CSSOM = {
+  CSSRule: require("./CSSRule").CSSRule,
+  CSSRuleList: require("./CSSRuleList").CSSRuleList,
+  CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
+};
+///CommonJS
+
+/**
+ * @constructor
+ * @see https://drafts.csswg.org/css-cascade-6/#cssscoperule
+ */
+CSSOM.CSSScopeRule = function CSSScopeRule() {
+  CSSOM.CSSGroupingRule.call(this);
+  this.__start = null;
+  this.__end = null;
+};
+
+CSSOM.CSSScopeRule.prototype = new CSSOM.CSSGroupingRule();
+CSSOM.CSSScopeRule.prototype.constructor = CSSOM.CSSScopeRule;
+
+
+Object.defineProperties(CSSOM.CSSScopeRule.prototype, {
+  type: {
+    value: 0,
+    writable: false,
+  },
+  cssText: {
+    get: function () {
+      var cssTexts = [];
+      for (var i = 0, length = this.cssRules.length; i < length; i++) {
+        cssTexts.push(this.cssRules[i].cssText);
+      }
+      return "@scope " + (this.start ? "(" + this.start + ") " : "") + (this.end ? "to (" + this.end + ") " : "") + "{" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
+    },
+    configurable: true,
+    enumerable: true,
+  },
+  start: {
+    get: function () {
+      return this.__start;
+    }
+  },
+  end: {
+    get: function () {
+      return this.__end;
+    }
+  }
+});
+
+//.CommonJS
+exports.CSSScopeRule = CSSOM.CSSScopeRule;
+///CommonJS

package/lib/CSSStartingStyleRule.js

@@ -1,6 +1,8 @@
 //.CommonJS
 var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule
+	CSSRule: require("./CSSRule").CSSRule,
+	CSSRuleList: require("./CSSRuleList").CSSRuleList,
+	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule
 };
 ///CommonJS
 
@@ -10,11 +12,10 @@ var CSSOM = {
  * @see http://www.w3.org/TR/shadow-dom/#host-at-rule
  */
 CSSOM.CSSStartingStyleRule = function CSSStartingStyleRule() {
-	CSSOM.CSSRule.call(this);
-	this.cssRules = [];
+	CSSOM.CSSGroupingRule.call(this);
 };
 
-CSSOM.CSSStartingStyleRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSStartingStyleRule.prototype = new CSSOM.CSSGroupingRule();
 CSSOM.CSSStartingStyleRule.prototype.constructor = CSSOM.CSSStartingStyleRule;
 CSSOM.CSSStartingStyleRule.prototype.type = 1002;
 //FIXME

package/lib/CSSStyleRule.js

@@ -1,8 +1,9 @@
 //.CommonJS
 var CSSOM = {
 	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
+	CSSRule: require("./CSSRule").CSSRule,
+	CSSRuleList: require("./CSSRuleList").CSSRuleList,
 	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-	CSSRule: require("./CSSRule").CSSRule
 };
 // Use cssstyle if available
 try {
@@ -38,7 +39,20 @@ Object.defineProperty(CSSOM.CSSStyleRule.prototype, "selectorText", {
 		return this.__selectorText;	
 	},
 	set: function(value) {
-		this.__selectorText = value;
+		if (typeof value === "string") {
+			var trimmedValue = value.trim();
+
+			if (trimmedValue === '') {
+				return;
+			}
+
+			// TODO: Setting invalid selectorText should be ignored
+			// There are some validations already on lib/parse.js
+			// but the same validations should be applied here.
+			// Check if we can move these validation logic to a shared function.
+
+			this.__selectorText = trimmedValue;
+		}
 	}
 });
 
@@ -75,9 +89,11 @@ Object.defineProperty(CSSOM.CSSStyleRule.prototype, "cssText", {
 		return text;
 	},
 	set: function(cssText) {
-		var rule = CSSOM.CSSStyleRule.parse(cssText);
-		this.__style = rule.style;
-		this.__selectorText = rule.selectorText;
+		if (typeof cssText === "string") {
+			var rule = CSSOM.CSSStyleRule.parse(cssText);
+			this.__style = rule.style;
+			this.selectorText = rule.selectorText;
+		}
 	}
 });
 

package/lib/CSSStyleSheet.js

@@ -1,7 +1,9 @@
 //.CommonJS
 var CSSOM = {
+	MediaList: require("./MediaList").MediaList,
 	StyleSheet: require("./StyleSheet").StyleSheet,
-	CSSStyleRule: require("./CSSStyleRule").CSSStyleRule
+	CSSRuleList: require("./CSSRuleList").CSSRuleList,
+	CSSStyleRule: require("./CSSStyleRule").CSSStyleRule,
 };
 var errorUtils = require("./errorUtils").errorUtils;
 ///CommonJS
@@ -13,13 +15,18 @@ var errorUtils = require("./errorUtils").errorUtils;
  */
 CSSOM.CSSStyleSheet = function CSSStyleSheet() {
 	CSSOM.StyleSheet.call(this);
-	this.cssRules = [];
+	this.cssRules = new CSSOM.CSSRuleList();
 };
 
 
 CSSOM.CSSStyleSheet.prototype = new CSSOM.StyleSheet();
 CSSOM.CSSStyleSheet.prototype.constructor = CSSOM.CSSStyleSheet;
 
+Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "rules", {
+	get: function() {
+		return this.cssRules;
+	}
+});
 
 /**
  * Used to insert a new rule into the style sheet. The new rule now becomes part of the cascade.
@@ -53,7 +60,10 @@ CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) {
 	}
 	
 	var ruleToParse = String(rule);
-	var parsedSheet = CSSOM.parse(ruleToParse);
+	var parseErrors = [];
+	var parsedSheet = CSSOM.parse(ruleToParse, undefined, function(err) {
+		parseErrors.push(err);
+	} );
 	if (parsedSheet.cssRules.length !== 1) {
 		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
 	}
@@ -121,12 +131,21 @@ CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) {
 				'HierarchyRequestError');
 		}
 		
+		// Cannot insert if there are already non-special rules
+		if (firstNonImportNamespaceIndex < this.cssRules.length) {
+			errorUtils.throwError(this, 'DOMException',
+				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
+				'InvalidStateError');
+		}
+		
 		// Cannot insert after other types of rules
 		if (index > firstNonImportNamespaceIndex) {
 			errorUtils.throwError(this, 'DOMException',
 				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
 				'HierarchyRequestError');
 		}
+
+		
 	} else if (cssRule.constructor.name === 'CSSLayerStatementRule') {
 		// @layer statement rules can be inserted anywhere before @import and @namespace
 		// No additional restrictions beyond what's already handled
@@ -143,6 +162,10 @@ CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) {
 				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
 				'HierarchyRequestError');
 		}
+
+		if (parseErrors.length !== 0) {
+			errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
+		}
 	}
 	
 	cssRule.__parentStyleSheet = this;
@@ -150,6 +173,13 @@ CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) {
 	return index;
 };
 
+CSSOM.CSSStyleSheet.prototype.addRule = function(selector, styleBlock, index) {
+	if (index === void 0) {
+		index = this.cssRules.length;
+	}
+	this.insertRule(selector + "{" + styleBlock + "}", index);
+	return -1;
+};
 
 /**
  * Used to delete a rule from the style sheet.
@@ -175,17 +205,27 @@ CSSOM.CSSStyleSheet.prototype.deleteRule = function(index) {
 	if (index >= this.cssRules.length) {
 		errorUtils.throwIndexError(this, 'deleteRule', this.constructor.name, index, this.cssRules.length);
 	}
-	if (this.cssRules[index] && this.cssRules[index].constructor.name == "CSSNamespaceRule") {
-		var shouldContinue = this.cssRules.every(function (rule) {
-			return ['CSSImportRule','CSSLayerStatementRule','CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
-		});
-		if (!shouldContinue) {
-			errorUtils.throwError(this, 'DOMException', "Failed to execute 'deleteRule' on '" + this.constructor.name + "': Failed to delete rule.", "InvalidStateError");
+	if (this.cssRules[index]) {		
+		if (this.cssRules[index].constructor.name == "CSSNamespaceRule") {
+			var shouldContinue = this.cssRules.every(function (rule) {
+				return ['CSSImportRule','CSSLayerStatementRule','CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
+			});
+			if (!shouldContinue) {
+				errorUtils.throwError(this, 'DOMException', "Failed to execute 'deleteRule' on '" + this.constructor.name + "': Failed to delete rule.", "InvalidStateError");
+			}
+		}
+		if (this.cssRules[index].constructor.name == "CSSImportRule") {
+			this.cssRules[index].styleSheet.__parentStyleSheet = null;
 		}
+
+		this.cssRules[index].__parentStyleSheet = null;
 	}
 	this.cssRules.splice(index, 1);
 };
 
+CSSOM.CSSStyleSheet.prototype.removeRule = function(index) {
+	this.deleteRule(index);
+};
 
 /**
  * NON-STANDARD

package/lib/CSSSupportsRule.js

@@ -1,6 +1,7 @@
 //.CommonJS
 var CSSOM = {
   CSSRule: require("./CSSRule").CSSRule,
+  CSSRuleList: require("./CSSRuleList").CSSRuleList,
   CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
   CSSConditionRule: require("./CSSConditionRule").CSSConditionRule
 };

package/lib/StyleSheet.js

@@ -1,5 +1,7 @@
 //.CommonJS
-var CSSOM = {};
+var CSSOM = {
+	MediaList: require("./MediaList").MediaList
+};
 ///CommonJS
 
 
@@ -8,10 +10,23 @@ var CSSOM = {};
  * @see http://dev.w3.org/csswg/cssom/#the-stylesheet-interface
  */
 CSSOM.StyleSheet = function StyleSheet() {
+	this.__media = new CSSOM.MediaList();
 	this.__parentStyleSheet = null;
 };
 
 Object.defineProperties(CSSOM.StyleSheet.prototype, {
+	media: {
+		get: function() {
+			return this.__media;
+		},
+		set: function(value) {
+			if (typeof value === "string") {
+				this.__media.mediaText = value;
+			} else {
+				this.__media = value;
+			}
+		}
+	},
 	parentStyleSheet: {
 		get: function() {
 			return this.__parentStyleSheet;

package/lib/clone.js

@@ -12,6 +12,7 @@ var CSSOM = {
 	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
 	CSSKeyframeRule: require('./CSSKeyframeRule').CSSKeyframeRule,
 	CSSKeyframesRule: require('./CSSKeyframesRule').CSSKeyframesRule,
+	CSSScopeRule: require('./CSSScopeRule').CSSScopeRule,
 	CSSLayerBlockRule: require('./CSSLayerBlockRule').CSSLayerBlockRule,
 	CSSLayerStatementRule: require('./CSSLayerStatementRule').CSSLayerStatementRule
 };

package/lib/index.js

@@ -7,6 +7,7 @@ exports.CSSStyleDeclaration = require('./CSSStyleDeclaration').CSSStyleDeclarati
 require('./cssstyleTryCatchBlock');
 
 exports.CSSRule = require('./CSSRule').CSSRule;
+exports.CSSRuleList = require('./CSSRuleList').CSSRuleList;
 exports.CSSNestedDeclarations = require('./CSSNestedDeclarations').CSSNestedDeclarations;
 exports.CSSGroupingRule = require('./CSSGroupingRule').CSSGroupingRule;
 exports.CSSCounterStyleRule = require('./CSSCounterStyleRule').CSSCounterStyleRule;
@@ -29,7 +30,9 @@ exports.MatcherList = require('./MatcherList').MatcherList;
 exports.CSSDocumentRule = require('./CSSDocumentRule').CSSDocumentRule;
 exports.CSSValue = require('./CSSValue').CSSValue;
 exports.CSSValueExpression = require('./CSSValueExpression').CSSValueExpression;
+exports.CSSScopeRule = require('./CSSScopeRule').CSSScopeRule;
 exports.CSSLayerBlockRule = require('./CSSLayerBlockRule').CSSLayerBlockRule;
 exports.CSSLayerStatementRule = require('./CSSLayerStatementRule').CSSLayerStatementRule;
+exports.CSSPageRule = require('./CSSPageRule').CSSPageRule;
 exports.parse = require('./parse').parse;
 exports.clone = require('./clone').clone;