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

package/dist/common.cjs

@@ -109,7 +109,6 @@ const UNIT_REGEX = /^([+-.]?\d+(?:\.?\d+)?)(%|cm|mm|q|in|pt|pc|px|em|rem|ex|rex|
 const IMAGE_VALUE_REGEX = /(?:url|linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient|conic-gradient)\(.*\)/;
 const COLOR_VALUE_REGEX = /(?:#|(?:color|color-contrast|color-mix|hwb|lab|lch|oklab|oklch|rgb|rgba|hsl|hsla|light-dark)\(.*\)|(?:\$colors)(?![a-zA-Z0-9-]))/;
 const NUMBER_VALUE_REGEX = /(?:[\d.]|(?:max|min|calc|clamp)\([^|]*\))/;
-const OFFICIAL_URL = new URL('https://rc.css.master.co');
 const CLASS_ATTRIBUTES = [
     'class',
     'className'
@@ -196,7 +195,6 @@ exports.COMPARISION_OPERATORS = COMPARISION_OPERATORS;
 exports.DELIMITER_SIGN = DELIMITER_SIGN;
 exports.IMAGE_VALUE_REGEX = IMAGE_VALUE_REGEX;
 exports.NUMBER_VALUE_REGEX = NUMBER_VALUE_REGEX;
-exports.OFFICIAL_URL = OFFICIAL_URL;
 exports.QUERY_COMPARISON_OPERATORS = QUERY_COMPARISON_OPERATORS;
 exports.QUERY_LOGICAL_OPERATORS = QUERY_LOGICAL_OPERATORS;
 exports.SELECTOR_COMBINATORS = SELECTOR_COMBINATORS;

package/dist/common.d.ts

@@ -20,7 +20,6 @@ export declare const UNIT_REGEX: RegExp;
 export declare const IMAGE_VALUE_REGEX: RegExp;
 export declare const COLOR_VALUE_REGEX: RegExp;
 export declare const NUMBER_VALUE_REGEX: RegExp;
-export declare const OFFICIAL_URL: URL;
 export declare const CLASS_ATTRIBUTES: string[];
 export declare const CLASS_DECLARATIONS: string[];
 export declare const CLASS_FUNCTIONS: string[];

package/dist/common.mjs

@@ -107,7 +107,6 @@ const UNIT_REGEX = /^([+-.]?\d+(?:\.?\d+)?)(%|cm|mm|q|in|pt|pc|px|em|rem|ex|rex|
 const IMAGE_VALUE_REGEX = /(?:url|linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient|conic-gradient)\(.*\)/;
 const COLOR_VALUE_REGEX = /(?:#|(?:color|color-contrast|color-mix|hwb|lab|lch|oklab|oklch|rgb|rgba|hsl|hsla|light-dark)\(.*\)|(?:\$colors)(?![a-zA-Z0-9-]))/;
 const NUMBER_VALUE_REGEX = /(?:[\d.]|(?:max|min|calc|clamp)\([^|]*\))/;
-const OFFICIAL_URL = new URL('https://rc.css.master.co');
 const CLASS_ATTRIBUTES = [
     'class',
     'className'
@@ -178,4 +177,4 @@ const AT_COMPARABLE_FEATURES = [
 ];
 const __UNSORTED__ = '__UNSORTED__';
 
-export { ANIMATION_SIGN, AT_COMPARABLE_FEATURES, AT_COMPARISON_OPERATORS, AT_IDENTIFIERS, AT_LOGICAL_OPERATORS, AT_SIGN, BASE_UNIT_REGEX, BORDER_STYLE_VALUES, CLASS_ATTRIBUTES, CLASS_DECLARATIONS, CLASS_FUNCTIONS, COLOR_VALUE_REGEX, COMPARISION_OPERATORS, DELIMITER_SIGN, IMAGE_VALUE_REGEX, NUMBER_VALUE_REGEX, OFFICIAL_URL, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, SELECTOR_COMBINATORS, SELECTOR_SIGNS, SEPARATOR_SIGN, SEPARATOR_SIGNS, TRANSITION_SIGN, UNIT_REGEX, VALUE_DELIMITERS, VALUE_UNITS, __UNSORTED__ };
+export { ANIMATION_SIGN, AT_COMPARABLE_FEATURES, AT_COMPARISON_OPERATORS, AT_IDENTIFIERS, AT_LOGICAL_OPERATORS, AT_SIGN, BASE_UNIT_REGEX, BORDER_STYLE_VALUES, CLASS_ATTRIBUTES, CLASS_DECLARATIONS, CLASS_FUNCTIONS, COLOR_VALUE_REGEX, COMPARISION_OPERATORS, DELIMITER_SIGN, IMAGE_VALUE_REGEX, NUMBER_VALUE_REGEX, QUERY_COMPARISON_OPERATORS, QUERY_LOGICAL_OPERATORS, SELECTOR_COMBINATORS, SELECTOR_SIGNS, SEPARATOR_SIGN, SEPARATOR_SIGNS, TRANSITION_SIGN, UNIT_REGEX, VALUE_DELIMITERS, VALUE_UNITS, __UNSORTED__ };

package/dist/config/functions.cjs

@@ -1,249 +1,6 @@
 'use strict';
 
-var common = require('../common.cjs');
-
 const functions = {
-    $: {
-        transform (value) {
-            let name;
-            let fallback;
-            const firstCommaIndex = value.indexOf(',');
-            if (firstCommaIndex !== -1) {
-                name = value.slice(0, firstCommaIndex);
-                fallback = value.slice(firstCommaIndex + 1);
-            } else {
-                name = value;
-            }
-            return [
-                {
-                    type: 'variable',
-                    name,
-                    fallback,
-                    token: value
-                }
-            ];
-        }
-    },
-    calc: {
-        transform (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, functions.calc.unit ?? this.definition.unit, bypassVariableNames, true) + ')';
-        }
-    },
     translate: {
         unit: 'rem'
     },
@@ -259,6 +16,9 @@ const functions = {
     translate3d: {
         unit: 'rem'
     },
+    perspective: {
+        unit: 'rem'
+    },
     skew: {
         unit: 'deg'
     },
@@ -369,6 +129,12 @@ const functions = {
     },
     'scaleZ': {
         unit: ''
+    },
+    $: {
+        transformer: 'core.variable'
+    },
+    calc: {
+        transformer: 'core.calc'
     }
 };
 

package/dist/config/functions.d.ts

@@ -1,3 +1,138 @@
-import { FunctionDefinitions } from '../types/config';
-declare const functions: FunctionDefinitions;
+declare const functions: {
+    translate: {
+        unit: string;
+    };
+    translateX: {
+        unit: string;
+    };
+    translateY: {
+        unit: string;
+    };
+    translateZ: {
+        unit: string;
+    };
+    translate3d: {
+        unit: string;
+    };
+    perspective: {
+        unit: string;
+    };
+    skew: {
+        unit: string;
+    };
+    skewX: {
+        unit: string;
+    };
+    skewY: {
+        unit: string;
+    };
+    skewZ: {
+        unit: string;
+    };
+    skew3d: {
+        unit: string;
+    };
+    rotate: {
+        unit: string;
+    };
+    rotateX: {
+        unit: string;
+    };
+    rotateY: {
+        unit: string;
+    };
+    rotateZ: {
+        unit: string;
+    };
+    rotate3d: {
+        unit: string;
+    };
+    blur: {
+        unit: string;
+    };
+    'drop-shadow': {
+        unit: string;
+    };
+    'hue-rotate': {
+        unit: string;
+    };
+    rgb: {
+        unit: string;
+    };
+    rgba: {
+        unit: string;
+    };
+    hsl: {
+        unit: string;
+    };
+    hsla: {
+        unit: string;
+    };
+    color: {
+        unit: string;
+    };
+    'color-contrast': {
+        unit: string;
+    };
+    'color-mix': {
+        unit: string;
+    };
+    hwb: {
+        unit: string;
+    };
+    lab: {
+        unit: string;
+    };
+    lch: {
+        unit: string;
+    };
+    oklab: {
+        unit: string;
+    };
+    oklch: {
+        unit: string;
+    };
+    'light-dark': {
+        unit: string;
+    };
+    clamp: {
+        unit: string;
+    };
+    repeat: {
+        unit: string;
+    };
+    'linear-gradient': {};
+    'radial-gradient': {};
+    'conic-gradient': {};
+    'repeating-linear-gradient': {};
+    'repeating-radial-gradient': {};
+    'repeating-conic-gradient': {};
+    matrix: {
+        unit: string;
+    };
+    matrix3d: {
+        unit: string;
+    };
+    scale: {
+        unit: string;
+    };
+    scale3d: {
+        unit: string;
+    };
+    scaleX: {
+        unit: string;
+    };
+    scaleY: {
+        unit: string;
+    };
+    scaleZ: {
+        unit: string;
+    };
+    $: {
+        transformer: "core.variable";
+    };
+    calc: {
+        transformer: "core.calc";
+    };
+};
 export default functions;