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

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;

package/dist/rule.d.ts

@@ -1,116 +1,14 @@
-import type { MasterCSS, Variable } from './core';
-import { Layer } from './layer';
-import { PropertiesHyphen } from 'csstype';
 export declare class Rule {
-    readonly className: string;
-    css: MasterCSS;
-    readonly at: Record<string, string>;
-    readonly priority: number;
-    readonly natives: NativeRule[];
-    readonly order: number;
-    readonly layer: Layer;
-    readonly stateToken: string;
-    readonly declarations?: PropertiesHyphen;
-    animationNames?: string[];
-    variableNames?: string[];
-    constructor(className: string, RegisteredRule: RegisteredRule, css: MasterCSS);
-    resolveValue: (valueComponents: ValueComponent[], unit: string, bypassVariableNames: string[], bypassParsing: boolean) => string;
+    readonly name: string;
+    nodes: RuleNode[];
+    constructor(name: string, nodes?: RuleNode[]);
+    get key(): string;
     get text(): string;
-    parseValue: (currentValueComponents: ValueComponent[], i: number, value: string, unit: string, endSymbol: string, parentFunctionName?: string, bypassParsing?: boolean, bypassVariableNames?: string[]) => number;
-    parseValueComponent(token: string | number, unit?: any): StringValueComponent | NumericValueComponent;
 }
-export type ValueComponent = StringValueComponent | NumericValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
-export interface StringValueComponent {
-    text?: string;
-    token?: string;
-    type: 'string';
-    value: string;
-}
-export interface NumericValueComponent {
-    text?: string;
-    token?: string;
-    type: 'number';
-    value: number;
-    unit?: string;
-}
-export interface FunctionValueComponent {
-    text?: string;
-    token?: string;
-    type: 'function';
-    name: string;
-    symbol: string;
-    children: ValueComponent[];
-    bypassTransform?: boolean;
-}
-export interface VariableValueComponent {
-    text?: string;
-    token?: string;
-    type: 'variable';
-    name: string;
-    alpha?: string;
-    fallback?: string;
-    variable?: Variable;
-}
-export interface SeparatorValueComponent {
-    text?: string;
-    type: 'separator';
-    value: string;
-}
-export interface Rule extends RegisteredRule {
-    colored: boolean;
-    prefix: string;
-    token: string;
-    vendorPrefixSelectors: Record<string, string[]>;
-    vendorSuffixSelectors: Record<string, string[]>;
-    important: boolean;
-    media: MediaQuery;
-    direction: string;
-    theme: string;
-    unitToken: string;
-    hasWhere: boolean;
-    valueComponents: Array<ValueComponent>;
-}
-export interface RegisteredRule {
-    id: string;
-    match?: RegExp;
-    variables?: any;
-    order: number;
-    definition: RuleDefinition;
-}
-export interface RuleDefinition {
-    layer?: Layer;
-    match?: RegExp | [string, string[]?];
-    variables?: string[];
-    separators?: string[];
-    shorthand?: string;
-    colored?: boolean;
-    numeric?: boolean;
-    unit?: any;
-    native?: boolean;
-    declarations?: PropertiesHyphen;
-    analyze?: (this: Rule, className: string) => [valueToken: string, prefixToken?: string];
-    transformValue?(this: Rule, value: string): string;
-    transformValueComponents?(this: Rule, valueComponents: ValueComponent[]): ValueComponent[];
-    declare?(this: Rule, value: string, valueComponents: ValueComponent[]): PropertiesHyphen;
-    delete?(this: Rule, className: string): void;
-    create?(this: Rule, className: string): void;
-    insert?(this: Rule): void;
-}
-export interface NativeRule {
+export interface RuleNode {
     text: string;
-    cssRule?: CSSRule;
-}
-export type MediaFeatureComponent = {
-    type: string;
-    tokenType?: string;
-    operator?: string;
-    value: number;
-    unit: string;
-};
-export interface MediaQuery {
-    token: string;
-    features: {
-        [key: string]: MediaFeatureComponent;
-    };
-    type?: string;
+    selectorText?: string;
+    native?: CSSRule;
+    suffixSelectors?: string[];
+    prefixSelectors?: string[];
 }

package/dist/rule.mjs

@@ -0,0 +1,16 @@
+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('');
+    }
+}
+
+export { Rule };

package/dist/shared/utils/css-escape.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+function cssEscape(value) {
+    if (typeof CSS !== 'undefined') return CSS.escape(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 rules 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;
+}
+
+module.exports = cssEscape;

package/dist/shared/utils/css-escape.mjs

@@ -0,0 +1,54 @@
+function cssEscape(value) {
+    if (typeof CSS !== 'undefined') return CSS.escape(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 rules 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;
+}
+
+export { cssEscape as default };

package/dist/shared/utils/find-native-css-rule-index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function findNativeCSSRuleIndex(cssRules, nativeRule) {
+    for(let i = 0; i < cssRules.length; i++){
+        if (cssRules[i] === nativeRule) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+module.exports = findNativeCSSRuleIndex;

package/dist/shared/utils/find-native-css-rule-index.mjs

@@ -0,0 +1,10 @@
+function findNativeCSSRuleIndex(cssRules, nativeRule) {
+    for(let i = 0; i < cssRules.length; i++){
+        if (cssRules[i] === nativeRule) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+export { findNativeCSSRuleIndex as default };

package/dist/syntax-layer.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var withSyntaxLayer = require('./factories/with-syntax-layer.cjs');
+var layer = require('./layer.cjs');
+
+const SyntaxLayer = withSyntaxLayer(layer);
+
+module.exports = SyntaxLayer;

package/dist/syntax-layer.d.ts

@@ -0,0 +1,18 @@
+import Layer from './layer';
+declare const SyntaxLayer: {
+    new (...args: any[]): {
+        rules: import("./syntax-rule").SyntaxRule[];
+        insert(syntaxRule: import("./syntax-rule").SyntaxRule): number | undefined;
+        delete(key: string): import("./syntax-rule").SyntaxRule | undefined;
+        insertVariables(syntaxRule: import("./syntax-rule").SyntaxRule): void;
+        insertAnimations(syntaxRule: import("./syntax-rule").SyntaxRule): void;
+        readonly tokenCounts: Map<string, number>;
+        name: string;
+        css: import("./core").default;
+        attach(): void;
+        detach(): void;
+        reset(): void;
+        readonly text: string;
+    };
+} & typeof Layer;
+export default SyntaxLayer;

package/dist/syntax-layer.mjs

@@ -0,0 +1,6 @@
+import withSyntaxLayer from './factories/with-syntax-layer.mjs';
+import Layer from './layer.mjs';
+
+const SyntaxLayer = withSyntaxLayer(Layer);
+
+export { SyntaxLayer as default };

package/dist/syntax-rule-type.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var SyntaxRuleType = /*#__PURE__*/ function(SyntaxRuleType) {
+    /**
+     * utility classes
+     * @example block, inline
+     */ SyntaxRuleType[SyntaxRuleType["Utility"] = -4] = "Utility";
+    /**
+     * native shorthand
+     * @example border, padding, margin
+     */ SyntaxRuleType[SyntaxRuleType["NativeShorthand"] = -3] = "NativeShorthand";
+    /**
+     * shorthand
+     * @example px, py, mx, my
+     */ SyntaxRuleType[SyntaxRuleType["Shorthand"] = -2] = "Shorthand";
+    /**
+     * native properties
+     * @example color, background-color, font-size
+     */ SyntaxRuleType[SyntaxRuleType["Native"] = -1] = "Native";
+    /**
+     * normal
+     * @example grid-cols
+     */ SyntaxRuleType[SyntaxRuleType["Normal"] = 0] = "Normal";
+    return SyntaxRuleType;
+}(SyntaxRuleType || {});
+
+module.exports = SyntaxRuleType;

package/dist/syntax-rule-type.d.ts

@@ -0,0 +1,28 @@
+declare const enum SyntaxRuleType {
+    /**
+     * utility classes
+     * @example block, inline
+     */
+    Utility = -4,
+    /**
+     * native shorthand
+     * @example border, padding, margin
+     */
+    NativeShorthand = -3,
+    /**
+     * shorthand
+     * @example px, py, mx, my
+     */
+    Shorthand = -2,
+    /**
+     * native properties
+     * @example color, background-color, font-size
+     */
+    Native = -1,
+    /**
+     * normal
+     * @example grid-cols
+     */
+    Normal = 0
+}
+export default SyntaxRuleType;

package/dist/syntax-rule-type.mjs

@@ -0,0 +1,25 @@
+var SyntaxRuleType = /*#__PURE__*/ function(SyntaxRuleType) {
+    /**
+     * utility classes
+     * @example block, inline
+     */ SyntaxRuleType[SyntaxRuleType["Utility"] = -4] = "Utility";
+    /**
+     * native shorthand
+     * @example border, padding, margin
+     */ SyntaxRuleType[SyntaxRuleType["NativeShorthand"] = -3] = "NativeShorthand";
+    /**
+     * shorthand
+     * @example px, py, mx, my
+     */ SyntaxRuleType[SyntaxRuleType["Shorthand"] = -2] = "Shorthand";
+    /**
+     * native properties
+     * @example color, background-color, font-size
+     */ SyntaxRuleType[SyntaxRuleType["Native"] = -1] = "Native";
+    /**
+     * normal
+     * @example grid-cols
+     */ SyntaxRuleType[SyntaxRuleType["Normal"] = 0] = "Normal";
+    return SyntaxRuleType;
+}(SyntaxRuleType || {});
+
+export { SyntaxRuleType as default };