@master/css 2.0.0-rc.68 → 2.0.0-rc.69

package/dist/declarers/core.group.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+var cssEscape = require('../shared/utils/css-escape.cjs');
+var common = require('../common.cjs');
+
+function coreGroup(value) {
+    const declarations = {};
+    const addProp = (propertyName)=>{
+        const indexOfColon = propertyName.indexOf(':');
+        if (indexOfColon !== -1) {
+            const propName = propertyName.slice(0, indexOfColon);
+            declarations[propName] = propertyName.slice(indexOfColon + 1);
+        }
+    };
+    const handleRule = (rule)=>{
+        const addProps = (cssText)=>{
+            const cssProperties = cssText.slice(cssEscape(rule.name).length).match(/\{(.*)\}/)?.[1].split(';');
+            if (cssProperties) for (const eachCssProperty of cssProperties){
+                addProp(eachCssProperty);
+            }
+        };
+        addProps(rule.text);
+        // animation
+        if (rule.animationNames) {
+            if (!this.animationNames) {
+                this.animationNames = new Set();
+            }
+            for (const eachKeyframeName of rule.animationNames){
+                this.animationNames.add(eachKeyframeName);
+            }
+        }
+        // variable
+        if (rule.variableNames) {
+            if (this.variableNames) {
+                for (const eachVariableName of rule.variableNames){
+                    this.variableNames.add(eachVariableName);
+                }
+            } else {
+                this.variableNames = new Set(rule.variableNames);
+            }
+        }
+    };
+    const names = [];
+    let currentName = '';
+    const addName = ()=>{
+        if (currentName) {
+            names.push(currentName.replace(/ /g, '|'));
+            currentName = '';
+        }
+    };
+    let i = 1;
+    (function analyze(end) {
+        for(; i < value.length; i++){
+            const char = value[i];
+            if (!end) {
+                if (char === ';') {
+                    addName();
+                    continue;
+                }
+                if (char === '}') {
+                    break;
+                }
+            }
+            currentName += char;
+            if (end === char) {
+                if (end === '\'' || end === '"') {
+                    let count = 0;
+                    for(let j = currentName.length - 2;; j--){
+                        if (currentName[j] !== '\\') {
+                            break;
+                        }
+                        count++;
+                    }
+                    if (count % 2) {
+                        continue;
+                    }
+                }
+                break;
+            } else if (char in common.VALUE_DELIMITERS && end !== '\'' && end !== '"') {
+                i++;
+                analyze(common.VALUE_DELIMITERS[char]);
+            }
+        }
+    })('');
+    addName();
+    for (const eachName of names){
+        const rules = this.css.generate(eachName, this.mode);
+        if (rules.length) {
+            for (const eachRule of rules){
+                handleRule(eachRule);
+            }
+        } else {
+            addProp(eachName);
+        }
+    }
+    return declarations;
+}
+
+module.exports = coreGroup;

package/dist/declarers/core.group.d.ts

@@ -0,0 +1,2 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function coreGroup(this: SyntaxRule, value: string): any;

package/dist/declarers/core.group.mjs

@@ -0,0 +1,97 @@
+import cssEscape from '../shared/utils/css-escape.mjs';
+import { VALUE_DELIMITERS } from '../common.mjs';
+
+function coreGroup(value) {
+    const declarations = {};
+    const addProp = (propertyName)=>{
+        const indexOfColon = propertyName.indexOf(':');
+        if (indexOfColon !== -1) {
+            const propName = propertyName.slice(0, indexOfColon);
+            declarations[propName] = propertyName.slice(indexOfColon + 1);
+        }
+    };
+    const handleRule = (rule)=>{
+        const addProps = (cssText)=>{
+            const cssProperties = cssText.slice(cssEscape(rule.name).length).match(/\{(.*)\}/)?.[1].split(';');
+            if (cssProperties) for (const eachCssProperty of cssProperties){
+                addProp(eachCssProperty);
+            }
+        };
+        addProps(rule.text);
+        // animation
+        if (rule.animationNames) {
+            if (!this.animationNames) {
+                this.animationNames = new Set();
+            }
+            for (const eachKeyframeName of rule.animationNames){
+                this.animationNames.add(eachKeyframeName);
+            }
+        }
+        // variable
+        if (rule.variableNames) {
+            if (this.variableNames) {
+                for (const eachVariableName of rule.variableNames){
+                    this.variableNames.add(eachVariableName);
+                }
+            } else {
+                this.variableNames = new Set(rule.variableNames);
+            }
+        }
+    };
+    const names = [];
+    let currentName = '';
+    const addName = ()=>{
+        if (currentName) {
+            names.push(currentName.replace(/ /g, '|'));
+            currentName = '';
+        }
+    };
+    let i = 1;
+    (function analyze(end) {
+        for(; i < value.length; i++){
+            const char = value[i];
+            if (!end) {
+                if (char === ';') {
+                    addName();
+                    continue;
+                }
+                if (char === '}') {
+                    break;
+                }
+            }
+            currentName += char;
+            if (end === char) {
+                if (end === '\'' || end === '"') {
+                    let count = 0;
+                    for(let j = currentName.length - 2;; j--){
+                        if (currentName[j] !== '\\') {
+                            break;
+                        }
+                        count++;
+                    }
+                    if (count % 2) {
+                        continue;
+                    }
+                }
+                break;
+            } else if (char in VALUE_DELIMITERS && end !== '\'' && end !== '"') {
+                i++;
+                analyze(VALUE_DELIMITERS[char]);
+            }
+        }
+    })('');
+    addName();
+    for (const eachName of names){
+        const rules = this.css.generate(eachName, this.mode);
+        if (rules.length) {
+            for (const eachRule of rules){
+                handleRule(eachRule);
+            }
+        } else {
+            addProp(eachName);
+        }
+    }
+    return declarations;
+}
+
+export { coreGroup as default };

package/dist/declarers/core.variable.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function coreVariable(value) {
+    return {
+        ['--' + this.keyToken.slice(1, -1)]: value
+    };
+}
+
+module.exports = coreVariable;

package/dist/declarers/core.variable.d.ts

@@ -0,0 +1,4 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function coreVariable(this: SyntaxRule, value: string): {
+    [x: string]: string;
+};

package/dist/declarers/core.variable.mjs

@@ -0,0 +1,7 @@
+function coreVariable(value) {
+    return {
+        ['--' + this.keyToken.slice(1, -1)]: value
+    };
+}
+
+export { coreVariable as default };

package/dist/declarers/index.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var core_group = require('./core.group.cjs');
+var core_variable = require('./core.variable.cjs');
+var pair = require('./pair.cjs');
+
+const declarers = {
+    pair,
+    'core.group': core_group,
+    'core.variable': core_variable
+};
+
+module.exports = declarers;

package/dist/declarers/index.d.ts

@@ -0,0 +1,10 @@
+import coreGroup from './core.group';
+import coreVariable from './core.variable';
+import pair from './pair';
+declare const declarers: {
+    pair: typeof pair;
+    'core.group': typeof coreGroup;
+    'core.variable': typeof coreVariable;
+};
+export default declarers;
+export type DeclarerNames = keyof typeof declarers;

package/dist/declarers/index.mjs

@@ -0,0 +1,11 @@
+import coreGroup from './core.group.mjs';
+import coreVariable from './core.variable.mjs';
+import pair from './pair.mjs';
+
+const declarers = {
+    pair,
+    'core.group': coreGroup,
+    'core.variable': coreVariable
+};
+
+export { declarers as default };

package/dist/declarers/pair.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function pair(_, valueComponents, data) {
+    const [x, y] = data;
+    const length = valueComponents.length;
+    return {
+        [x]: length === 1 ? valueComponents[0].text : valueComponents[0].text,
+        [y]: length === 1 ? valueComponents[0].text : valueComponents[2].text
+    };
+}
+
+module.exports = pair;

package/dist/declarers/pair.d.ts

@@ -0,0 +1,4 @@
+import { ValueComponent } from '../types/syntax';
+export default function pair(_: string, valueComponents: ValueComponent[], data: [string, string]): {
+    [x: string]: string | undefined;
+};

package/dist/declarers/pair.mjs

@@ -0,0 +1,10 @@
+function pair(_, valueComponents, data) {
+    const [x, y] = data;
+    const length = valueComponents.length;
+    return {
+        [x]: length === 1 ? valueComponents[0].text : valueComponents[0].text,
+        [y]: length === 1 ? valueComponents[0].text : valueComponents[2].text
+    };
+}
+
+export { pair as default };

package/dist/factories/with-syntax-layer.cjs

@@ -27,7 +27,6 @@ function withSyntaxLayer(Base) {
             super.insert(syntaxRule, index);
             this.insertVariables(syntaxRule);
             this.insertAnimations(syntaxRule);
-            syntaxRule.definition.insert?.call(syntaxRule);
             return index;
         }
         delete(key) {
@@ -48,7 +47,6 @@ function withSyntaxLayer(Base) {
             syntaxRule.animationNames?.forEach((eachAnimationName)=>{
                 deleteLayerToken(eachAnimationName, this.css.animationsNonLayer);
             });
-            syntaxRule.definition.delete?.call(syntaxRule, syntaxRule.name);
             return syntaxRule;
         }
         insertVariables(syntaxRule) {

package/dist/factories/with-syntax-layer.mjs

@@ -25,7 +25,6 @@ function withSyntaxLayer(Base) {
             super.insert(syntaxRule, index);
             this.insertVariables(syntaxRule);
             this.insertAnimations(syntaxRule);
-            syntaxRule.definition.insert?.call(syntaxRule);
             return index;
         }
         delete(key) {
@@ -46,7 +45,6 @@ function withSyntaxLayer(Base) {
             syntaxRule.animationNames?.forEach((eachAnimationName)=>{
                 deleteLayerToken(eachAnimationName, this.css.animationsNonLayer);
             });
-            syntaxRule.definition.delete?.call(syntaxRule, syntaxRule.name);
             return syntaxRule;
         }
         insertVariables(syntaxRule) {

package/dist/function-transformers/core.calc.cjs

@@ -0,0 +1,225 @@
+'use strict';
+
+var functions = require('../config/functions.cjs');
+var common = require('../common.cjs');
+
+function coreCalc(value, bypassVariableNames) {
+    const valueComponents = [];
+    let i = 0;
+    const anaylzeDeeply = (currentValueComponents, bypassHandlingSeparator, parentBypassParsing, parentUnitChecking, isVarFunction)=>{
+        const isChildHandler = valueComponents !== currentValueComponents;
+        const unparsedValueComponents = [];
+        let bypassParsing = false;
+        let hasUnit = false;
+        let currentHasUnit = false;
+        let unitChecking = false;
+        let childHasUnit = undefined;
+        let current = '';
+        const clear = (separator, prefix = '', suffix = '')=>{
+            if (childHasUnit === false && separator !== ' ' && this.definition.unit) {
+                childHasUnit = undefined;
+                if (!unitChecking) {
+                    pushUnitValueComponents();
+                }
+            }
+            if (current) {
+                if (!isVarFunction) {
+                    const result = common.BASE_UNIT_REGEX.exec(current);
+                    if (result) {
+                        current = (+result[1] * (this.css.config.baseUnit ?? 1)).toString();
+                    }
+                }
+                if (!bypassParsing && !parentBypassParsing) {
+                    const valueComponent = {
+                        ...this.parseValue(current),
+                        token: current
+                    };
+                    if (!hasUnit && isNaN(+current) && valueComponent.type === 'number') {
+                        hasUnit = true;
+                    }
+                    if (unitChecking) {
+                        if (isNaN(+current)) {
+                            if (valueComponent.type === 'number') {
+                                currentValueComponents.push(valueComponent);
+                                currentHasUnit = true;
+                            } else {
+                                currentValueComponents.push(valueComponent);
+                            }
+                        } else {
+                            currentValueComponents.push({
+                                type: 'number',
+                                value: +current,
+                                token: current
+                            });
+                        }
+                    } else {
+                        if (isChildHandler) {
+                            const newValueComponent = {
+                                type: 'string',
+                                value: current,
+                                token: current
+                            };
+                            unparsedValueComponents.push(newValueComponent);
+                            currentValueComponents.push(newValueComponent);
+                        } else {
+                            currentValueComponents.push(valueComponent);
+                        }
+                    }
+                } else {
+                    currentValueComponents.push({
+                        type: 'string',
+                        value: current,
+                        token: current
+                    });
+                }
+                current = '';
+            }
+            if (separator) {
+                if (separator === '+' || separator === '-') {
+                    handleUnitChecking();
+                }
+                if (prefix && value[i - 1] === ' ') {
+                    prefix = '';
+                }
+                if (suffix && value[i + 1] === ' ') {
+                    suffix = '';
+                }
+                if (bypassHandlingSeparator) {
+                    currentValueComponents.push({
+                        type: 'separator',
+                        value: separator,
+                        text: separator,
+                        token: separator
+                    });
+                } else {
+                    currentValueComponents.push({
+                        type: 'separator',
+                        value: separator,
+                        text: prefix + separator + suffix,
+                        token: separator
+                    });
+                }
+            }
+            bypassParsing = false;
+        };
+        const pushUnitValueComponents = ()=>{
+            if (this.definition.unit === 'rem' || this.definition.unit === 'em') {
+                currentValueComponents.push({
+                    type: 'separator',
+                    value: '/',
+                    text: ' / ',
+                    token: '/'
+                }, {
+                    type: 'number',
+                    value: this.css.config.rootSize,
+                    token: String(this.css.config.rootSize)
+                });
+            }
+            currentValueComponents.push({
+                type: 'separator',
+                value: '*',
+                text: ' * ',
+                token: '*'
+            }, {
+                type: 'number',
+                value: 1,
+                unit: this.definition.unit,
+                token: this.definition.unit
+            });
+        };
+        const handleUnitChecking = ()=>{
+            if (unitChecking && !currentHasUnit && !parentUnitChecking && (!isChildHandler || hasUnit)) {
+                pushUnitValueComponents();
+            }
+            unitChecking = false;
+            currentHasUnit = false;
+        };
+        for(; i < value.length; i++){
+            const char = value[i];
+            if (char === '(') {
+                const symbolResult = /^([+-])/.exec(current);
+                if (symbolResult) {
+                    currentValueComponents.push({
+                        type: 'string',
+                        value: symbolResult[1],
+                        token: symbolResult[1]
+                    });
+                }
+                const functionName = symbolResult ? current.slice(1) : current;
+                const newValueComponent = {
+                    type: 'function',
+                    name: functionName,
+                    symbol: char,
+                    children: [],
+                    bypassTransform: functionName === 'calc',
+                    token: current
+                };
+                currentValueComponents.push(newValueComponent);
+                current = '';
+                i++;
+                const isVarFunction = functionName === '$' || functionName === 'var';
+                childHasUnit = anaylzeDeeply(newValueComponent.children, functionName !== '' && functionName !== 'calc' && (isVarFunction || Object.prototype.hasOwnProperty.call(functions, functionName)), bypassParsing || isVarFunction || unitChecking && currentHasUnit, unitChecking, isVarFunction) || functionName === 'var';
+                if (!childHasUnit && functionName === '$') {
+                    const variableType = this.css.variables.get(newValueComponent.children[0].value)?.type;
+                    childHasUnit = !variableType || variableType === 'string';
+                }
+                if (childHasUnit) {
+                    hasUnit = true;
+                    currentHasUnit = true;
+                }
+            } else if (char === ')') {
+                clear('');
+                if (hasUnit) {
+                    for (const eachUnparsedValueComponent of unparsedValueComponents){
+                        Object.assign(eachUnparsedValueComponent, this.parseValue(eachUnparsedValueComponent.value));
+                    }
+                }
+                return hasUnit;
+            } else if (char === ',') {
+                clear(char, '', ' ');
+            } else if (char === ' ') {
+                clear(char);
+            } else {
+                const previousChar = value[i - 1];
+                switch(char){
+                    case '+':
+                        if (!current && previousChar !== ')') {
+                            current += char;
+                        } else {
+                            clear(char, ' ', ' ');
+                        }
+                        break;
+                    case '-':
+                        if (!current && previousChar !== ')') {
+                            current += char;
+                        } else {
+                            clear(char, ' ', ' ');
+                        }
+                        break;
+                    case '*':
+                        if (this.definition.unit) {
+                            unitChecking = true;
+                        }
+                        clear(char, ' ', ' ');
+                        break;
+                    case '/':
+                        if (this.definition.unit) {
+                            unitChecking = true;
+                        }
+                        clear(char, ' ', ' ');
+                        bypassParsing = true;
+                        break;
+                    default:
+                        current += char;
+                        break;
+                }
+            }
+        }
+        clear('');
+        handleUnitChecking();
+    };
+    anaylzeDeeply(valueComponents, false, false, false, false);
+    return 'calc(' + this.resolveValue(valueComponents, this.definition.unit, bypassVariableNames, true) + ')';
+}
+
+module.exports = coreCalc;

package/dist/function-transformers/core.calc.d.ts

@@ -0,0 +1,2 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function coreCalc(this: SyntaxRule, value: string, bypassVariableNames: string[]): string;