@acemir/cssom 0.9.24 → 0.9.25

package/lib/CSSConditionRule.js

@@ -16,9 +16,11 @@ CSSOM.CSSConditionRule = function CSSConditionRule() {
   this.__conditionText = '';
 };
 
-CSSOM.CSSConditionRule.prototype = new CSSOM.CSSGroupingRule();
+CSSOM.CSSConditionRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
 CSSOM.CSSConditionRule.prototype.constructor = CSSOM.CSSConditionRule;
 
+Object.setPrototypeOf(CSSOM.CSSConditionRule, CSSOM.CSSGroupingRule);
+
 Object.defineProperty(CSSOM.CSSConditionRule.prototype, "conditionText", {
   get: function () {
     return this.__conditionText;

package/lib/CSSContainerRule.js

@@ -17,9 +17,15 @@ CSSOM.CSSContainerRule = function CSSContainerRule() {
 	CSSOM.CSSConditionRule.call(this);
 };
 
-CSSOM.CSSContainerRule.prototype = new CSSOM.CSSConditionRule();
+CSSOM.CSSContainerRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
 CSSOM.CSSContainerRule.prototype.constructor = CSSOM.CSSContainerRule;
-CSSOM.CSSContainerRule.prototype.type = 17;
+
+Object.setPrototypeOf(CSSOM.CSSContainerRule, CSSOM.CSSConditionRule);
+
+Object.defineProperty(CSSOM.CSSContainerRule.prototype, "type", {
+	value: 17,
+	writable: false
+});
 
 Object.defineProperties(CSSOM.CSSContainerRule.prototype, {
   "cssText": {
@@ -36,9 +42,7 @@ Object.defineProperties(CSSOM.CSSContainerRule.prototype, {
       }
       values = valuesArr.join("\n  ") + "\n}";
       return "@container " + this.conditionText + values;
-    },
-    configurable: true,
-    enumerable: true
+    }
   },
   "containerName": {
       get: function() {

package/lib/CSSCounterStyleRule.js

@@ -12,11 +12,45 @@ var CSSOM = {
 CSSOM.CSSCounterStyleRule = function CSSCounterStyleRule() {
 	CSSOM.CSSRule.call(this);
     this.name = "";
+	this.__props = "";
 };
 
-CSSOM.CSSCounterStyleRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSCounterStyleRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSCounterStyleRule.prototype.constructor = CSSOM.CSSCounterStyleRule;
-CSSOM.CSSCounterStyleRule.prototype.type = 11;
+
+Object.setPrototypeOf(CSSOM.CSSCounterStyleRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "type", {
+	value: 11,
+	writable: false
+});
+
+Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "cssText", {
+	get: function() {
+		// FIXME : Implement real cssText generation based on properties
+		return "@counter-style " + this.name + " { " + this.__props + " }";
+	}
+});
+
+/**
+ * NON-STANDARD
+ * Rule text parser.
+ * @param {string} cssText
+ */
+Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "parse", {
+	value: function(cssText) {
+		// Extract the name from "@counter-style <name> { ... }"
+		var match = cssText.match(/@counter-style\s+([^\s{]+)\s*\{([^]*)\}/);
+		if (match) {
+			this.name = match[1];
+			// Get the text inside the brackets and clean it up
+			var propsText = match[2];
+			this.__props = propsText.trim().replace(/\n/g, " ").replace(/(['"])(?:\\.|[^\\])*?\1|(\s{2,})/g, function (match, quote) {
+				return quote ? match : ' ';
+			});
+		}
+	}
+});
 
 //.CommonJS
 exports.CSSCounterStyleRule = CSSOM.CSSCounterStyleRule;

package/lib/CSSDocumentRule.js

@@ -18,9 +18,16 @@ CSSOM.CSSDocumentRule = function CSSDocumentRule() {
     this.cssRules = new CSSOM.CSSRuleList();
 };
 
-CSSOM.CSSDocumentRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSDocumentRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSDocumentRule.prototype.constructor = CSSOM.CSSDocumentRule;
-CSSOM.CSSDocumentRule.prototype.type = 10;
+
+Object.setPrototypeOf(CSSOM.CSSDocumentRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSDocumentRule.prototype, "type", {
+	value: 10,
+	writable: false
+});
+
 //FIXME
 //CSSOM.CSSDocumentRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
 //CSSOM.CSSDocumentRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;

package/lib/CSSFontFaceRule.js

@@ -22,9 +22,16 @@ CSSOM.CSSFontFaceRule = function CSSFontFaceRule() {
 	this.__style.parentRule = this;
 };
 
-CSSOM.CSSFontFaceRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSFontFaceRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSFontFaceRule.prototype.constructor = CSSOM.CSSFontFaceRule;
-CSSOM.CSSFontFaceRule.prototype.type = 5;
+
+Object.setPrototypeOf(CSSOM.CSSFontFaceRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "type", {
+	value: 5,
+	writable: false
+});
+
 //FIXME
 //CSSOM.CSSFontFaceRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
 //CSSOM.CSSFontFaceRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;

package/lib/CSSGroupingRule.js

@@ -14,12 +14,19 @@ var errorUtils = require("./errorUtils").errorUtils;
  */
 CSSOM.CSSGroupingRule = function CSSGroupingRule() {
 	CSSOM.CSSRule.call(this);
-	this.cssRules = new CSSOM.CSSRuleList();
+	this.__cssRules = new CSSOM.CSSRuleList();
 };
 
-CSSOM.CSSGroupingRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSGroupingRule.prototype  = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
 
+Object.setPrototypeOf(CSSOM.CSSGroupingRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSGroupingRule.prototype, "cssRules", {
+	get: function() {
+		return this.__cssRules;
+	}
+});
 
 /**
  * Used to insert a new CSS rule to a list of CSS rules.
@@ -51,13 +58,60 @@ CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
 	if (index > this.cssRules.length) {
 		errorUtils.throwIndexError(this, 'insertRule', this.constructor.name, index, this.cssRules.length);
 	}
-	
-	var ruleToParse = String(rule);
-	var parsedSheet = CSSOM.parse(ruleToParse);
-	if (parsedSheet.cssRules.length !== 1) {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
+	var ruleToParse = processedRuleToParse = String(rule);
+	ruleToParse = ruleToParse.trim().replace(/^\/\*[\s\S]*?\*\/\s*/, "");
+	var isNestedSelector = this.constructor.name === "CSSStyleRule";
+	if (isNestedSelector === false) {
+		var currentRule = this;
+		while (currentRule.parentRule) {
+			currentRule = currentRule.parentRule;
+			if (currentRule.constructor.name === "CSSStyleRule") {
+				isNestedSelector = true;
+				break;
+			}
+		}
+	}
+	if (isNestedSelector) {
+		processedRuleToParse = 's { n { } ' + ruleToParse + '}';
+	}
+	var isScopeRule = this.constructor.name === "CSSScopeRule";
+	if (isScopeRule) {
+		if (isNestedSelector) {
+			processedRuleToParse = 's { ' + '@scope {' + ruleToParse + '}}';
+		} else {
+			processedRuleToParse = '@scope {' + ruleToParse + '}';
+		}
+	}
+	var parsedRules = new CSSOM.CSSRuleList();
+	CSSOM.parse(processedRuleToParse, {
+		styleSheet: this.parentStyleSheet,
+		cssRules: parsedRules
+	});
+	if (isScopeRule) {
+		if (isNestedSelector) {
+			parsedRules = parsedRules[0].cssRules[0].cssRules;
+		} else {
+			parsedRules = parsedRules[0].cssRules
+		}
+	}
+	if (isNestedSelector) {
+		parsedRules = parsedRules[0].cssRules.slice(1);
+	}
+	if (parsedRules.length !== 1) {
+		if (isNestedSelector && parsedRules.length === 0 && ruleToParse.indexOf('@font-face') === 0) {
+			errorUtils.throwError(this, 'DOMException', 
+				"Failed to execute 'insertRule' on '" + this.constructor.name + "': " +
+				"Only conditional nested group rules, style rules, @scope rules, @apply rules, and nested declaration rules may be nested.",
+				'HierarchyRequestError');
+		} else {
+			errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
+		}
+	}
+	var cssRule = parsedRules[0];
+
+	if (cssRule.constructor.name === 'CSSNestedDeclarations' && cssRule.style.length === 0) {
+		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');	
 	}
-	var cssRule = parsedSheet.cssRules[0];
 	
 	// Check for rules that cannot be inserted inside a CSSGroupingRule
 	if (cssRule.constructor.name === 'CSSImportRule' || cssRule.constructor.name === 'CSSNamespaceRule') {
@@ -101,7 +155,9 @@ CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
 	if (index >= this.cssRules.length) {
 		errorUtils.throwIndexError(this, 'deleteRule', this.constructor.name, index, this.cssRules.length);
 	}
-	this.cssRules.splice(index, 1)[0].__parentRule = null;
+	this.cssRules[index].__parentRule = null;
+	this.cssRules[index].__parentStyleSheet = null;
+	this.cssRules.splice(index, 1);
 };
 
 //.CommonJS

package/lib/CSSHostRule.js

@@ -17,9 +17,16 @@ CSSOM.CSSHostRule = function CSSHostRule() {
 	this.cssRules = new CSSOM.CSSRuleList();
 };
 
-CSSOM.CSSHostRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSHostRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSHostRule.prototype.constructor = CSSOM.CSSHostRule;
-CSSOM.CSSHostRule.prototype.type = 1001;
+
+Object.setPrototypeOf(CSSOM.CSSHostRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSHostRule.prototype, "type", {
+	value: 1001,
+	writable: false
+});
+
 //FIXME
 //CSSOM.CSSHostRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
 //CSSOM.CSSHostRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;

package/lib/CSSImportRule.js

@@ -21,9 +21,11 @@ CSSOM.CSSImportRule = function CSSImportRule() {
 	this.__styleSheet = new CSSOM.CSSStyleSheet();
 };
 
-CSSOM.CSSImportRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSImportRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSImportRule.prototype.constructor = CSSOM.CSSImportRule;
 
+Object.setPrototypeOf(CSSOM.CSSImportRule, CSSOM.CSSRule);
+
 Object.defineProperty(CSSOM.CSSImportRule.prototype, "type", {
 	value: 3,
 	writable: false
@@ -33,8 +35,53 @@ Object.defineProperty(CSSOM.CSSImportRule.prototype, "cssText", {
   get: function() {
     var mediaText = this.media.mediaText;
     return "@import url(\"" + this.href.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + "\")" + (this.layerName !== null ? " layer" + (this.layerName && "(" + this.layerName + ")") : "" ) + (this.supportsText ? " supports(" + this.supportsText + ")" : "" ) + (mediaText ? " " + mediaText : "") + ";";
+  }
+});
+
+Object.defineProperty(CSSOM.CSSImportRule.prototype, "href", {
+  get: function() {
+    return this.__href;
+  }
+});
+
+Object.defineProperty(CSSOM.CSSImportRule.prototype, "media", {
+  get: function() {
+    return this.__media;
   },
-  set: function(cssText) {
+	set: function(value) {
+		if (typeof value === "string") {
+			this.__media.mediaText = value;
+		} else {
+			this.__media = value;
+		}
+	}
+});
+
+Object.defineProperty(CSSOM.CSSImportRule.prototype, "layerName", {
+  get: function() {
+    return this.__layerName;
+  }
+});
+
+Object.defineProperty(CSSOM.CSSImportRule.prototype, "supportsText", {
+  get: function() {
+    return this.__supportsText;
+  }
+});
+
+Object.defineProperty(CSSOM.CSSImportRule.prototype, "styleSheet", {
+  get: function() {
+    return this.__styleSheet;
+  }
+});
+
+/**
+ * NON-STANDARD
+ * Rule text parser.
+ * @param {string} cssText
+ */
+Object.defineProperty(CSSOM.CSSImportRule.prototype, "parse", {
+  value: function(cssText) {
     var i = 0;
 
     /**
@@ -213,43 +260,6 @@ Object.defineProperty(CSSOM.CSSImportRule.prototype, "cssText", {
   }
 });
 
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "href", {
-  get: function() {
-    return this.__href;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "media", {
-  get: function() {
-    return this.__media;
-  },
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__media.mediaText = value;
-		} else {
-			this.__media = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "layerName", {
-  get: function() {
-    return this.__layerName;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "supportsText", {
-  get: function() {
-    return this.__supportsText;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "styleSheet", {
-  get: function() {
-    return this.__styleSheet;
-  }
-});
-
 
 //.CommonJS
 exports.CSSImportRule = CSSOM.CSSImportRule;

package/lib/CSSKeyframeRule.js

@@ -23,9 +23,16 @@ CSSOM.CSSKeyframeRule = function CSSKeyframeRule() {
 	this.__style.parentRule = this;
 };
 
-CSSOM.CSSKeyframeRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSKeyframeRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSKeyframeRule.prototype.constructor = CSSOM.CSSKeyframeRule;
-CSSOM.CSSKeyframeRule.prototype.type = 8;
+
+Object.setPrototypeOf(CSSOM.CSSKeyframeRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "type", {
+	value: 8,
+	writable: false
+});
+
 //FIXME
 //CSSOM.CSSKeyframeRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
 //CSSOM.CSSKeyframeRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;

package/lib/CSSKeyframesRule.js

@@ -49,9 +49,15 @@ CSSOM.CSSKeyframesRule = function CSSKeyframesRule() {
 	});
 };
 
-CSSOM.CSSKeyframesRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSKeyframesRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSKeyframesRule.prototype.constructor = CSSOM.CSSKeyframesRule;
-CSSOM.CSSKeyframesRule.prototype.type = 7;
+
+Object.setPrototypeOf(CSSOM.CSSKeyframesRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "type", {
+	value: 7,
+	writable: false
+});
 
 // http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframesRule.cpp
 Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "cssText", {

package/lib/CSSLayerBlockRule.js

@@ -15,9 +15,15 @@ CSSOM.CSSLayerBlockRule = function CSSLayerBlockRule() {
   this.name = "";
 };
 
-CSSOM.CSSLayerBlockRule.prototype = new CSSOM.CSSGroupingRule();
+CSSOM.CSSLayerBlockRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
 CSSOM.CSSLayerBlockRule.prototype.constructor = CSSOM.CSSLayerBlockRule;
-CSSOM.CSSLayerBlockRule.prototype.type = 18;
+
+Object.setPrototypeOf(CSSOM.CSSLayerBlockRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSLayerBlockRule.prototype, "type", {
+	value: 18,
+	writable: false
+});
 
 Object.defineProperties(CSSOM.CSSLayerBlockRule.prototype, {
   cssText: {
@@ -34,9 +40,7 @@ Object.defineProperties(CSSOM.CSSLayerBlockRule.prototype, {
       }
       values = valuesArr.join("\n  ") + "\n}";
       return "@layer" + (this.name ? " " + this.name : "") + values;
-    },
-    configurable: true,
-    enumerable: true,
+    }
   },
 });
 

package/lib/CSSLayerStatementRule.js

@@ -13,17 +13,21 @@ CSSOM.CSSLayerStatementRule = function CSSLayerStatementRule() {
   this.nameList = [];
 };
 
-CSSOM.CSSLayerStatementRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSLayerStatementRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSLayerStatementRule.prototype.constructor = CSSOM.CSSLayerStatementRule;
-CSSOM.CSSLayerStatementRule.prototype.type = 0;
+
+Object.setPrototypeOf(CSSOM.CSSLayerStatementRule, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSLayerStatementRule.prototype, "type", {
+	value: 0,
+	writable: false
+});
 
 Object.defineProperties(CSSOM.CSSLayerStatementRule.prototype, {
   cssText: {
     get: function () {
       return "@layer " + this.nameList.join(", ") + ";";
-    },
-    configurable: true,
-    enumerable: true,
+    }
   },
 });
 

package/lib/CSSMediaRule.js

@@ -19,9 +19,15 @@ CSSOM.CSSMediaRule = function CSSMediaRule() {
 	this.__media = new CSSOM.MediaList();
 };
 
-CSSOM.CSSMediaRule.prototype = new CSSOM.CSSConditionRule();
+CSSOM.CSSMediaRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
 CSSOM.CSSMediaRule.prototype.constructor = CSSOM.CSSMediaRule;
-CSSOM.CSSMediaRule.prototype.type = 4;
+
+Object.setPrototypeOf(CSSOM.CSSMediaRule, CSSOM.CSSConditionRule);
+
+Object.defineProperty(CSSOM.CSSMediaRule.prototype, "type", {
+	value: 4,
+	writable: false
+});
 
 // https://opensource.apple.com/source/WebCore/WebCore-7611.1.21.161.3/css/CSSMediaRule.cpp
 Object.defineProperties(CSSOM.CSSMediaRule.prototype, {
@@ -57,9 +63,7 @@ Object.defineProperties(CSSOM.CSSMediaRule.prototype, {
       }
       values = valuesArr.join("\n  ") + "\n}";
       return "@media " + this.media.mediaText + values;
-    },
-    configurable: true,
-    enumerable: true
+    }
   }
 });
 

package/lib/CSSNamespaceRule.js

@@ -16,19 +16,42 @@ CSSOM.CSSNamespaceRule = function CSSNamespaceRule() {
 	this.__namespaceURI = "";
 };
 
-CSSOM.CSSNamespaceRule.prototype = new CSSOM.CSSRule();
+CSSOM.CSSNamespaceRule.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSNamespaceRule.prototype.constructor = CSSOM.CSSNamespaceRule;
 
+Object.setPrototypeOf(CSSOM.CSSNamespaceRule, CSSOM.CSSRule);
+
 Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "type", {
   value: 10,
-	writable: false
+  writable: false
 });
 
 Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "cssText", {
   get: function() {
     return "@namespace" + (this.prefix && " " + this.prefix) + " url(\"" + this.namespaceURI + "\");";
-  },
-  set: function(cssText) {
+  }
+});
+
+Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "prefix", {
+  get: function() {
+    return this.__prefix;
+  }
+});
+
+Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "namespaceURI", {
+  get: function() {
+    return this.__namespaceURI;
+  }
+});
+
+
+/**
+ * NON-STANDARD
+ * Rule text parser.
+ * @param {string} cssText
+ */
+Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "parse", {
+  value: function(cssText) {
     var newPrefix = "";
     var newNamespaceURI = "";
 
@@ -75,19 +98,6 @@ Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "cssText", {
     }
   }
 });
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "prefix", {
-  get: function() {
-    return this.__prefix;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "namespaceURI", {
-  get: function() {
-    return this.__namespaceURI;
-  }
-});
-
 //.CommonJS
 exports.CSSNamespaceRule = CSSOM.CSSNamespaceRule;
 ///CommonJS

package/lib/CSSNestedDeclarations.js

@@ -22,9 +22,15 @@ CSSOM.CSSNestedDeclarations = function CSSNestedDeclarations() {
   this.__style.parentRule = this;
 };
 
-CSSOM.CSSNestedDeclarations.prototype = new CSSOM.CSSRule();
+CSSOM.CSSNestedDeclarations.prototype = Object.create(CSSOM.CSSRule.prototype);
 CSSOM.CSSNestedDeclarations.prototype.constructor = CSSOM.CSSNestedDeclarations;
-CSSOM.CSSNestedDeclarations.prototype.type = 0;
+
+Object.setPrototypeOf(CSSOM.CSSNestedDeclarations, CSSOM.CSSRule);
+
+Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "type", {
+  value: 0,
+  writable: false
+});
 
 Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "style", {
 	get: function() {
@@ -42,9 +48,7 @@ Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "style", {
 Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "cssText", {
   get: function () {
     return this.style.cssText;
-  },
-  configurable: true,
-  enumerable: true,
+  }
 });
 
 //.CommonJS

package/lib/CSSOM.js

@@ -1,3 +1,18 @@
-var CSSOM = {};
+var __globalObject = null;
 
+var CSSOM = {
+    setup: function(opts) {
+        if (opts.globalObject) {
+            __globalObject = opts.globalObject;
+        }
+    },
+    getGlobalObject: function() {
+        return __globalObject;
+    }
+};
+
+//.CommonJS
+exports.setup = CSSOM.setup;
+exports.getGlobalObject = CSSOM.getGlobalObject;
+///CommonJS