@master/css 2.0.0-rc.6 → 2.0.0-rc.60

package/dist/index.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./config/index.cjs');
+var common = require('./common.cjs');
+var core = require('./core.cjs');
+var syntaxRule = require('./syntax-rule.cjs');
+var rule = require('./rule.cjs');
+var layer = require('./layer.cjs');
+var syntaxLayer = require('./syntax-layer.cjs');
+var nonLayer = require('./non-layer.cjs');
+var syntaxRuleType = require('./syntax-rule-type.cjs');
+var withSyntaxLayer = require('./factories/with-syntax-layer.cjs');
+var extendConfig = require('./utils/extend-config.cjs');
+var reorderForReadableClasses = require('./utils/reorder-for-readable-classes.cjs');
+var areRuleModesEqual = require('./utils/are-rule-modes-equal.cjs');
+var areRuleAtEqual = require('./utils/are-rule-at-equal.cjs');
+var areRuleSelectorsEqual = require('./utils/are-rule-selectors-equal.cjs');
+var areRuleStatesEqual = require('./utils/are-rule-states-equal.cjs');
+var areRulesDuplicated = require('./utils/are-rules-duplicated.cjs');
+var generateCss = require('./utils/generate-css.cjs');
+var isCoreRule = require('./utils/is-core-rule.cjs');
+var at = require('./config/at.cjs');
+var selectors = require('./config/selectors.cjs');
+var utilities = require('./config/utilities.cjs');
+var rules = require('./config/rules.cjs');
+var functions = require('./config/functions.cjs');
+var animations = require('./config/animations.cjs');
+var variables = require('./config/variables.cjs');
+var modes = require('./config/modes.cjs');
+
+
+
+exports.config = index.config;
+exports.ANIMATION_SIGN = common.ANIMATION_SIGN;
+exports.AT_SIGN = common.AT_SIGN;
+exports.BASE_UNIT_REGEX = common.BASE_UNIT_REGEX;
+exports.BORDER_STYLE_VALUES = common.BORDER_STYLE_VALUES;
+exports.CLASS_ATTRIBUTES = common.CLASS_ATTRIBUTES;
+exports.CLASS_DECLARATIONS = common.CLASS_DECLARATIONS;
+exports.CLASS_FUNCTIONS = common.CLASS_FUNCTIONS;
+exports.COLOR_VALUE_REGEX = common.COLOR_VALUE_REGEX;
+exports.DELIMITER_SIGN = common.DELIMITER_SIGN;
+exports.IMAGE_VALUE_REGEX = common.IMAGE_VALUE_REGEX;
+exports.NUMBER_VALUE_REGEX = common.NUMBER_VALUE_REGEX;
+exports.OFFICIAL_URL = common.OFFICIAL_URL;
+exports.QUERY_COMPARISON_OPERATORS = common.QUERY_COMPARISON_OPERATORS;
+exports.QUERY_LOGICAL_OPERATORS = common.QUERY_LOGICAL_OPERATORS;
+exports.SELECTOR_SIGNS = common.SELECTOR_SIGNS;
+exports.SEPARATOR_SIGN = common.SEPARATOR_SIGN;
+exports.SEPARATOR_SIGNS = common.SEPARATOR_SIGNS;
+exports.TRANSITION_SIGN = common.TRANSITION_SIGN;
+exports.UNIT_REGEX = common.UNIT_REGEX;
+exports.VALUE_DELIMITERS = common.VALUE_DELIMITERS;
+exports.VALUE_UNITS = common.VALUE_UNITS;
+exports.MasterCSS = core;
+exports.default = core;
+exports.SyntaxRule = syntaxRule.SyntaxRule;
+exports.Rule = rule.Rule;
+exports.Layer = layer;
+exports.SyntaxLayer = syntaxLayer;
+exports.NonLayer = nonLayer;
+exports.SyntaxRuleType = syntaxRuleType;
+exports.withSyntaxLayer = withSyntaxLayer;
+exports.extendConfig = extendConfig;
+exports.reorderForReadableClasses = reorderForReadableClasses;
+exports.areRuleModesEqual = areRuleModesEqual;
+exports.areRuleAtEqual = areRuleAtEqual;
+exports.areRuleSelectorsEqual = areRuleSelectorsEqual;
+exports.areRuleStatesEqual = areRuleStatesEqual;
+exports.areRulesDuplicated = areRulesDuplicated;
+exports.generateCSS = generateCss;
+exports.isCoreRule = isCoreRule;
+exports.at = at;
+exports.selectors = selectors;
+exports.utilities = utilities;
+exports.rules = rules;
+exports.functions = functions;
+exports.animations = animations;
+exports.variables = variables;
+exports.modes = modes;

package/dist/index.d.ts

@@ -1,10 +1,22 @@
-export { MasterCSS, MasterCSS as default } from './core';
-export { Rule } from './rule';
-export type { NativeRule, MediaFeatureComponent, MediaQuery } from './rule';
-export { CONFIG_TEXT } from './constants/config-text';
-export { CONFIG_ESM_TEXT } from './constants/config-esm-text';
-export { CONFIG_TS_TEXT } from './constants/config-ts-text';
-export { Layer } from './layer';
-export { default as extend } from '@techor/extend';
-export { default as reorderForReadableClasses } from './functions/reorder-for-readable-classes';
 export * from './config';
+export * from './common';
+export * from './core';
+export * from './syntax-rule';
+export * from './rule';
+export { default as Layer } from './layer';
+export { default as SyntaxLayer } from './syntax-layer';
+export { default as NonLayer } from './non-layer';
+export { default as SyntaxRuleType } from './syntax-rule-type';
+export { default as MasterCSS, default } from './core';
+export * from './types/config';
+export * from './types/syntax';
+export { default as withSyntaxLayer } from './factories/with-syntax-layer';
+export { default as extendConfig } from './utils/extend-config';
+export { default as reorderForReadableClasses } from './utils/reorder-for-readable-classes';
+export { default as areRuleModesEqual } from './utils/are-rule-modes-equal';
+export { default as areRuleAtEqual } from './utils/are-rule-at-equal';
+export { default as areRuleSelectorsEqual } from './utils/are-rule-selectors-equal';
+export { default as areRuleStatesEqual } from './utils/are-rule-states-equal';
+export { default as areRulesDuplicated } from './utils/are-rules-duplicated';
+export { default as generateCSS } from './utils/generate-css';
+export { default as isCoreRule } from './utils/is-core-rule';

package/dist/index.mjs

@@ -0,0 +1,27 @@
+export { config } from './config/index.mjs';
+export { ANIMATION_SIGN, AT_SIGN, BASE_UNIT_REGEX, BORDER_STYLE_VALUES, CLASS_ATTRIBUTES, CLASS_DECLARATIONS, CLASS_FUNCTIONS, COLOR_VALUE_REGEX, DELIMITER_SIGN, IMAGE_VALUE_REGEX, NUMBER_VALUE_REGEX, OFFICIAL_URL, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, SELECTOR_SIGNS, SEPARATOR_SIGN, SEPARATOR_SIGNS, TRANSITION_SIGN, UNIT_REGEX, VALUE_DELIMITERS, VALUE_UNITS } from './common.mjs';
+export { default as MasterCSS, default } from './core.mjs';
+export { SyntaxRule } from './syntax-rule.mjs';
+export { Rule } from './rule.mjs';
+export { default as Layer } from './layer.mjs';
+export { default as SyntaxLayer } from './syntax-layer.mjs';
+export { default as NonLayer } from './non-layer.mjs';
+export { default as SyntaxRuleType } from './syntax-rule-type.mjs';
+export { default as withSyntaxLayer } from './factories/with-syntax-layer.mjs';
+export { default as extendConfig } from './utils/extend-config.mjs';
+export { default as reorderForReadableClasses } from './utils/reorder-for-readable-classes.mjs';
+export { default as areRuleModesEqual } from './utils/are-rule-modes-equal.mjs';
+export { default as areRuleAtEqual } from './utils/are-rule-at-equal.mjs';
+export { default as areRuleSelectorsEqual } from './utils/are-rule-selectors-equal.mjs';
+export { default as areRuleStatesEqual } from './utils/are-rule-states-equal.mjs';
+export { default as areRulesDuplicated } from './utils/are-rules-duplicated.mjs';
+export { default as generateCSS } from './utils/generate-css.mjs';
+export { default as isCoreRule } from './utils/is-core-rule.mjs';
+export { default as at } from './config/at.mjs';
+export { default as selectors } from './config/selectors.mjs';
+export { default as utilities } from './config/utilities.mjs';
+export { default as rules } from './config/rules.mjs';
+export { default as functions } from './config/functions.mjs';
+export { default as animations } from './config/animations.mjs';
+export { default as variables } from './config/variables.mjs';
+export { default as modes } from './config/modes.mjs';

package/dist/layer.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+class Layer {
+    name;
+    css;
+    rules;
+    tokenCounts;
+    constructor(name, css){
+        this.name = name;
+        this.css = css;
+        this.rules = [];
+        this.tokenCounts = new Map();
+    }
+    attach() {
+        this.css.rules.push(this);
+    }
+    detach() {
+        this.css.rules.splice(this.css.rules.indexOf(this), 1);
+    }
+    insert(rule, index = this.rules.length) {
+        if (this.rules.find(({ key })=>key === rule.key)) return;
+        if (!this.css.rules.includes(this)) {
+            this.attach();
+        }
+        this.rules.splice(index, 0, rule);
+        return index;
+    }
+    delete(key) {
+        const rule = this.rules.find((rule)=>rule.key === key);
+        if (!rule) return;
+        if (this.rules.length === 1) {
+            this.detach();
+        }
+        this.rules.splice(this.rules.indexOf(rule), 1);
+        return rule;
+    }
+    reset() {
+        this.rules.length = 0;
+        const indexOfLayer = this.css.rules.indexOf(this);
+        if (indexOfLayer !== -1) {
+            this.css.rules.splice(indexOfLayer, 1);
+        }
+        this.tokenCounts.clear();
+    }
+    get text() {
+        return '@layer ' + this.name + '{' + this.rules.map(({ text })=>text).join('') + '}';
+    }
+}
+
+module.exports = Layer;

package/dist/layer.d.ts

@@ -1,11 +1,15 @@
-export declare const enum Layer {
-    Semantic = -8,
-    CoreNativeShorthand = -7,
-    NativeShorthand = -6,
-    CoreShorthand = -5,
-    Shorthand = -4,
-    CoreNative = -3,
-    Native = -2,
-    Core = -1,
-    Normal = 0
+import { Rule } from './rule';
+import MasterCSS from './core';
+export default class Layer {
+    name: string;
+    css: MasterCSS;
+    readonly rules: Rule[];
+    readonly tokenCounts: Map<string, number>;
+    constructor(name: string, css: MasterCSS);
+    attach(): void;
+    detach(): void;
+    insert(rule: Rule, index?: number): number | undefined;
+    delete(key: string): Rule | undefined;
+    reset(): void;
+    get text(): string;
 }

package/dist/layer.mjs

@@ -0,0 +1,48 @@
+class Layer {
+    name;
+    css;
+    rules;
+    tokenCounts;
+    constructor(name, css){
+        this.name = name;
+        this.css = css;
+        this.rules = [];
+        this.tokenCounts = new Map();
+    }
+    attach() {
+        this.css.rules.push(this);
+    }
+    detach() {
+        this.css.rules.splice(this.css.rules.indexOf(this), 1);
+    }
+    insert(rule, index = this.rules.length) {
+        if (this.rules.find(({ key })=>key === rule.key)) return;
+        if (!this.css.rules.includes(this)) {
+            this.attach();
+        }
+        this.rules.splice(index, 0, rule);
+        return index;
+    }
+    delete(key) {
+        const rule = this.rules.find((rule)=>rule.key === key);
+        if (!rule) return;
+        if (this.rules.length === 1) {
+            this.detach();
+        }
+        this.rules.splice(this.rules.indexOf(rule), 1);
+        return rule;
+    }
+    reset() {
+        this.rules.length = 0;
+        const indexOfLayer = this.css.rules.indexOf(this);
+        if (indexOfLayer !== -1) {
+            this.css.rules.splice(indexOfLayer, 1);
+        }
+        this.tokenCounts.clear();
+    }
+    get text() {
+        return '@layer ' + this.name + '{' + this.rules.map(({ text })=>text).join('') + '}';
+    }
+}
+
+export { Layer as default };

package/dist/non-layer.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+var findNativeCssRuleIndex = require('./shared/utils/find-native-css-rule-index.cjs');
+
+class NonLayer {
+    css;
+    rules;
+    tokenCounts;
+    constructor(css){
+        this.css = css;
+        this.rules = [];
+        this.tokenCounts = new Map();
+    }
+    insert(rule) {
+        if (this.rules.includes(rule)) return;
+        const sheet = this.css.style?.sheet;
+        if (sheet) {
+            for(let i = 0; i < rule.nodes.length;){
+                try {
+                    const nativeRule = rule.nodes[i];
+                    const insertedIndex = sheet.insertRule(nativeRule.text, sheet.cssRules.length);
+                    nativeRule.native = sheet.cssRules[insertedIndex];
+                    i++;
+                } catch (error) {
+                    console.error(error);
+                    rule.nodes.splice(i, 1);
+                }
+            }
+        }
+        this.rules.push(rule);
+        this.css.rules.push(rule);
+    }
+    delete(key) {
+        const rule = this.rules.find((rule)=>rule.key === key);
+        if (!rule) return;
+        const sheet = this.css.style?.sheet;
+        if (sheet) {
+            for (const node of rule.nodes){
+                const foundIndex = findNativeCssRuleIndex(sheet.cssRules, node.native);
+                if (foundIndex !== -1) {
+                    sheet.deleteRule(foundIndex);
+                }
+            }
+        }
+        this.rules.splice(this.rules.indexOf(rule), 1);
+        this.css.rules.splice(this.css.rules.indexOf(rule), 1);
+        return rule;
+    }
+    get text() {
+        return this.rules.map(({ text })=>text).join('');
+    }
+    reset() {
+        for (const rule of this.rules){
+            const foundIndex = this.css.rules.indexOf(rule);
+            if (foundIndex !== -1) {
+                this.css.rules.splice(foundIndex, 1);
+            }
+        }
+        this.rules.length = 0;
+        this.tokenCounts.clear();
+    }
+}
+
+module.exports = NonLayer;

package/dist/non-layer.d.ts

@@ -0,0 +1,12 @@
+import MasterCSS from './core';
+import { Rule } from './rule';
+export default class NonLayer {
+    css: MasterCSS;
+    readonly rules: Rule[];
+    readonly tokenCounts: Map<string, number>;
+    constructor(css: MasterCSS);
+    insert(rule: Rule): void;
+    delete(key: string): Rule | undefined;
+    get text(): string;
+    reset(): void;
+}

package/dist/non-layer.mjs

@@ -0,0 +1,62 @@
+import findNativeCSSRuleIndex from './shared/utils/find-native-css-rule-index.mjs';
+
+class NonLayer {
+    css;
+    rules;
+    tokenCounts;
+    constructor(css){
+        this.css = css;
+        this.rules = [];
+        this.tokenCounts = new Map();
+    }
+    insert(rule) {
+        if (this.rules.includes(rule)) return;
+        const sheet = this.css.style?.sheet;
+        if (sheet) {
+            for(let i = 0; i < rule.nodes.length;){
+                try {
+                    const nativeRule = rule.nodes[i];
+                    const insertedIndex = sheet.insertRule(nativeRule.text, sheet.cssRules.length);
+                    nativeRule.native = sheet.cssRules[insertedIndex];
+                    i++;
+                } catch (error) {
+                    console.error(error);
+                    rule.nodes.splice(i, 1);
+                }
+            }
+        }
+        this.rules.push(rule);
+        this.css.rules.push(rule);
+    }
+    delete(key) {
+        const rule = this.rules.find((rule)=>rule.key === key);
+        if (!rule) return;
+        const sheet = this.css.style?.sheet;
+        if (sheet) {
+            for (const node of rule.nodes){
+                const foundIndex = findNativeCSSRuleIndex(sheet.cssRules, node.native);
+                if (foundIndex !== -1) {
+                    sheet.deleteRule(foundIndex);
+                }
+            }
+        }
+        this.rules.splice(this.rules.indexOf(rule), 1);
+        this.css.rules.splice(this.css.rules.indexOf(rule), 1);
+        return rule;
+    }
+    get text() {
+        return this.rules.map(({ text })=>text).join('');
+    }
+    reset() {
+        for (const rule of this.rules){
+            const foundIndex = this.css.rules.indexOf(rule);
+            if (foundIndex !== -1) {
+                this.css.rules.splice(foundIndex, 1);
+            }
+        }
+        this.rules.length = 0;
+        this.tokenCounts.clear();
+    }
+}
+
+export { NonLayer as default };

package/dist/polyfills/css-escape.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var _commonjsHelpers = require('../_virtual/_commonjsHelpers.cjs');
+var cssEscape$1 = require('./css-escape2.cjs');
+
+var cssEscapeExports = cssEscape$1.__require();
+var cssEscape = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(cssEscapeExports);
+
+module.exports = cssEscape;

package/dist/polyfills/css-escape.mjs

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from '../_virtual/_commonjsHelpers.mjs';
+import { __require as requireCssEscape } from './css-escape2.mjs';
+
+var cssEscapeExports = requireCssEscape();
+var cssEscape = /*@__PURE__*/getDefaultExportFromCjs(cssEscapeExports);
+
+export { cssEscape as default };

package/dist/polyfills/css-escape2.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var _commonjsHelpers = require('../_virtual/_commonjsHelpers.cjs');
+var cssEscape = require('../_virtual/css-escape.cjs');
+
+var hasRequiredCssEscape;
+
+function requireCssEscape () {
+	if (hasRequiredCssEscape) return cssEscape.__exports;
+	hasRequiredCssEscape = 1;
+	(()=>{
+	    const root = typeof _commonjsHelpers.commonjsGlobal !== 'undefined' ? _commonjsHelpers.commonjsGlobal : window;
+	    if (!root.CSS && !root.CSS?.escape) {
+	        // https://drafts.csswg.org/cssom/#serialize-an-identifier
+	        const cssEscape = function(value) {
+	            if (arguments.length == 0) {
+	                throw new TypeError('`CSS.escape` requires an argument.');
+	            }
+	            const string = String(value);
+	            const length = string.length;
+	            let index = -1;
+	            let result = '';
+	            let codeUnit;
+	            const firstCodeUnit = string.charCodeAt(0);
+	            if (// If the character is the first character and is a `-` (U+002D), and
+	            // there is no second character, […]
+	            length == 1 && firstCodeUnit == 0x002D) {
+	                return '\\' + string;
+	            }
+	            while(++index < length){
+	                codeUnit = string.charCodeAt(index);
+	                // Note: there’s no need to special-case astral symbols, surrogate
+	                // pairs, or lone surrogates.
+	                // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+	                // (U+FFFD).
+	                if (codeUnit == 0x0000) {
+	                    result += '\uFFFD';
+	                    continue;
+	                }
+	                if (// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+	                // U+007F, […]
+	                codeUnit >= 0x0001 && codeUnit <= 0x001F || codeUnit == 0x007F || // If the character is the first character and is in the range [0-9]
+	                // (U+0030 to U+0039), […]
+	                index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039 || // If the character is the second character and is in the range [0-9]
+	                // (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+	                index == 1 && codeUnit >= 0x0030 && codeUnit <= 0x0039 && firstCodeUnit == 0x002D) {
+	                    // https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+	                    result += '\\' + codeUnit.toString(16) + ' ';
+	                    continue;
+	                }
+	                // If the character is not handled by one of the above syntaxes and is
+	                // greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+	                // is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+	                // U+005A), or [a-z] (U+0061 to U+007A), […]
+	                if (codeUnit >= 0x0080 || codeUnit == 0x002D || codeUnit == 0x005F || codeUnit >= 0x0030 && codeUnit <= 0x0039 || codeUnit >= 0x0041 && codeUnit <= 0x005A || codeUnit >= 0x0061 && codeUnit <= 0x007A) {
+	                    // the character itself
+	                    result += string.charAt(index);
+	                    continue;
+	                }
+	                // Otherwise, the escaped character.
+	                // https://drafts.csswg.org/cssom/#escape-a-character
+	                result += '\\' + string.charAt(index);
+	            }
+	            return result;
+	        };
+	        if (!root.CSS) {
+	            root.CSS = {};
+	        }
+	        root.CSS.escape = cssEscape;
+	        globalThis.CSS.escape = cssEscape;
+	    }
+	})();
+	return cssEscape.__exports;
+}
+
+exports.__require = requireCssEscape;

package/dist/polyfills/css-escape2.mjs

@@ -0,0 +1,74 @@
+import { commonjsGlobal } from '../_virtual/_commonjsHelpers.mjs';
+import { __exports as cssEscape } from '../_virtual/css-escape.mjs';
+
+var hasRequiredCssEscape;
+
+function requireCssEscape () {
+	if (hasRequiredCssEscape) return cssEscape;
+	hasRequiredCssEscape = 1;
+	(()=>{
+	    const root = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : window;
+	    if (!root.CSS && !root.CSS?.escape) {
+	        // https://drafts.csswg.org/cssom/#serialize-an-identifier
+	        const cssEscape = function(value) {
+	            if (arguments.length == 0) {
+	                throw new TypeError('`CSS.escape` requires an argument.');
+	            }
+	            const string = String(value);
+	            const length = string.length;
+	            let index = -1;
+	            let result = '';
+	            let codeUnit;
+	            const firstCodeUnit = string.charCodeAt(0);
+	            if (// If the character is the first character and is a `-` (U+002D), and
+	            // there is no second character, […]
+	            length == 1 && firstCodeUnit == 0x002D) {
+	                return '\\' + string;
+	            }
+	            while(++index < length){
+	                codeUnit = string.charCodeAt(index);
+	                // Note: there’s no need to special-case astral symbols, surrogate
+	                // pairs, or lone surrogates.
+	                // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+	                // (U+FFFD).
+	                if (codeUnit == 0x0000) {
+	                    result += '\uFFFD';
+	                    continue;
+	                }
+	                if (// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+	                // U+007F, […]
+	                codeUnit >= 0x0001 && codeUnit <= 0x001F || codeUnit == 0x007F || // If the character is the first character and is in the range [0-9]
+	                // (U+0030 to U+0039), […]
+	                index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039 || // If the character is the second character and is in the range [0-9]
+	                // (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+	                index == 1 && codeUnit >= 0x0030 && codeUnit <= 0x0039 && firstCodeUnit == 0x002D) {
+	                    // https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+	                    result += '\\' + codeUnit.toString(16) + ' ';
+	                    continue;
+	                }
+	                // If the character is not handled by one of the above syntaxes and is
+	                // greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+	                // is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+	                // U+005A), or [a-z] (U+0061 to U+007A), […]
+	                if (codeUnit >= 0x0080 || codeUnit == 0x002D || codeUnit == 0x005F || codeUnit >= 0x0030 && codeUnit <= 0x0039 || codeUnit >= 0x0041 && codeUnit <= 0x005A || codeUnit >= 0x0061 && codeUnit <= 0x007A) {
+	                    // the character itself
+	                    result += string.charAt(index);
+	                    continue;
+	                }
+	                // Otherwise, the escaped character.
+	                // https://drafts.csswg.org/cssom/#escape-a-character
+	                result += '\\' + string.charAt(index);
+	            }
+	            return result;
+	        };
+	        if (!root.CSS) {
+	            root.CSS = {};
+	        }
+	        root.CSS.escape = cssEscape;
+	        globalThis.CSS.escape = cssEscape;
+	    }
+	})();
+	return cssEscape;
+}
+
+export { requireCssEscape as __require };

package/dist/register-global.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function registerGlobal(MasterCSS) {
+    if (!globalThis.MasterCSS) globalThis.MasterCSS = MasterCSS;
+}
+
+module.exports = registerGlobal;

package/dist/register-global.d.ts

@@ -0,0 +1,5 @@
+import type Core from './core';
+declare global {
+    var MasterCSS: typeof Core;
+}
+export default function registerGlobal(MasterCSS: typeof Core): void;

package/dist/register-global.mjs

@@ -0,0 +1,5 @@
+function registerGlobal(MasterCSS) {
+    if (!globalThis.MasterCSS) globalThis.MasterCSS = MasterCSS;
+}
+
+export { registerGlobal as default };

package/dist/rule.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+class Rule {
+    name;
+    nodes;
+    constructor(name, nodes = []){
+        this.name = name;
+        this.nodes = nodes;
+    }
+    get key() {
+        return this.name;
+    }
+    get text() {
+        return this.nodes.map(({ text })=>text).join('');
+    }
+}
+
+exports.Rule = Rule;