@master/css 2.0.0-rc.15 → 2.0.0-rc.17

package/dist/_virtual/_commonjsHelpers.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+exports.commonjsGlobal = commonjsGlobal;

package/dist/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,3 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export { commonjsGlobal };

package/dist/_virtual/css-escape.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+var cssEscape = {};
+
+exports.__exports = cssEscape;

package/dist/_virtual/css-escape.mjs

@@ -0,0 +1,3 @@
+var cssEscape = {};
+
+export { cssEscape as __exports };

package/dist/bin/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var child_process = require('child_process');
+
+try {
+    child_process.execSync('mastercss', {
+        stdio: 'inherit'
+    });
+} catch (error) {
+    console.error('Command not found. Try installing "@master/css-cli" first.');
+}

package/dist/bin/index.mjs

@@ -0,0 +1,9 @@
+import { execSync } from 'child_process';
+
+try {
+    execSync('mastercss', {
+        stdio: 'inherit'
+    });
+} catch (error) {
+    console.error('Command not found. Try installing "@master/css-cli" first.');
+}

package/dist/config/animations.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+const animations = {
+    fade: {
+        '0%': {
+            opacity: 0
+        },
+        to: {
+            opacity: 1
+        }
+    },
+    flash: {
+        '0%,50%,to': {
+            opacity: 1
+        },
+        '25%,75%': {
+            opacity: 0
+        }
+    },
+    float: {
+        '0%': {
+            transform: 'none'
+        },
+        '50%': {
+            transform: 'translateY(-1.25rem)'
+        },
+        to: {
+            transform: 'none'
+        }
+    },
+    heart: {
+        '0%': {
+            transform: 'scale(1)'
+        },
+        '14%': {
+            transform: 'scale(1.3)'
+        },
+        '28%': {
+            transform: 'scale(1)'
+        },
+        '42%': {
+            transform: 'scale(1.3)'
+        },
+        '70%': {
+            transform: 'scale(1)'
+        }
+    },
+    jump: {
+        '0%,to': {
+            transform: 'translateY(-25%)',
+            'animation-timing-function': 'cubic-bezier(.8,0,1,1)'
+        },
+        '50%': {
+            transform: 'translateY(0)',
+            'animation-timing-function': 'cubic-bezier(0,0,.2,1)'
+        }
+    },
+    ping: {
+        '75%,to': {
+            transform: 'scale(2)',
+            opacity: 0
+        }
+    },
+    pulse: {
+        '0%': {
+            transform: 'none'
+        },
+        '50%': {
+            transform: 'scale(1.05)'
+        },
+        to: {
+            transform: 'none'
+        }
+    },
+    rotate: {
+        '0%': {
+            transform: 'rotate(-360deg)'
+        },
+        to: {
+            transform: 'none'
+        }
+    },
+    shake: {
+        '0%': {
+            transform: 'none'
+        },
+        '6.5%': {
+            transform: 'translateX(-6px) rotateY(-9deg)'
+        },
+        '18.5%': {
+            transform: 'translateX(5px) rotateY(7deg)'
+        },
+        '31.5%': {
+            transform: 'translateX(-3px) rotateY(-5deg)'
+        },
+        '43.5%': {
+            transform: 'translateX(2px) rotateY(3deg)'
+        },
+        '50%': {
+            transform: 'none'
+        }
+    },
+    zoom: {
+        '0%': {
+            transform: 'scale(0)'
+        },
+        to: {
+            transform: 'none'
+        }
+    }
+};
+
+module.exports = animations;

package/dist/config/animations.mjs

@@ -0,0 +1,111 @@
+const animations = {
+    fade: {
+        '0%': {
+            opacity: 0
+        },
+        to: {
+            opacity: 1
+        }
+    },
+    flash: {
+        '0%,50%,to': {
+            opacity: 1
+        },
+        '25%,75%': {
+            opacity: 0
+        }
+    },
+    float: {
+        '0%': {
+            transform: 'none'
+        },
+        '50%': {
+            transform: 'translateY(-1.25rem)'
+        },
+        to: {
+            transform: 'none'
+        }
+    },
+    heart: {
+        '0%': {
+            transform: 'scale(1)'
+        },
+        '14%': {
+            transform: 'scale(1.3)'
+        },
+        '28%': {
+            transform: 'scale(1)'
+        },
+        '42%': {
+            transform: 'scale(1.3)'
+        },
+        '70%': {
+            transform: 'scale(1)'
+        }
+    },
+    jump: {
+        '0%,to': {
+            transform: 'translateY(-25%)',
+            'animation-timing-function': 'cubic-bezier(.8,0,1,1)'
+        },
+        '50%': {
+            transform: 'translateY(0)',
+            'animation-timing-function': 'cubic-bezier(0,0,.2,1)'
+        }
+    },
+    ping: {
+        '75%,to': {
+            transform: 'scale(2)',
+            opacity: 0
+        }
+    },
+    pulse: {
+        '0%': {
+            transform: 'none'
+        },
+        '50%': {
+            transform: 'scale(1.05)'
+        },
+        to: {
+            transform: 'none'
+        }
+    },
+    rotate: {
+        '0%': {
+            transform: 'rotate(-360deg)'
+        },
+        to: {
+            transform: 'none'
+        }
+    },
+    shake: {
+        '0%': {
+            transform: 'none'
+        },
+        '6.5%': {
+            transform: 'translateX(-6px) rotateY(-9deg)'
+        },
+        '18.5%': {
+            transform: 'translateX(5px) rotateY(7deg)'
+        },
+        '31.5%': {
+            transform: 'translateX(-3px) rotateY(-5deg)'
+        },
+        '43.5%': {
+            transform: 'translateX(2px) rotateY(3deg)'
+        },
+        '50%': {
+            transform: 'none'
+        }
+    },
+    zoom: {
+        '0%': {
+            transform: 'scale(0)'
+        },
+        to: {
+            transform: 'none'
+        }
+    }
+};
+
+export { animations as default };

package/dist/config/functions.cjs

@@ -0,0 +1,352 @@
+'use strict';
+
+var baseUnitRegex = require('../constants/base-unit-regex.cjs');
+
+const functions = {
+    $: {
+        colored: true,
+        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
+                }
+            ];
+        }
+    },
+    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 = baseUnitRegex.BASE_UNIT_REGEX.exec(current);
+                            if (result) {
+                                current = (+result[1] * (this.css.config.baseUnit ?? 1)).toString();
+                            }
+                        }
+                        if (!bypassParsing && !parentBypassParsing) {
+                            const valueComponent = this.parseValueComponent(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
+                                    });
+                                }
+                            } else {
+                                if (isChildHandler) {
+                                    const newValueComponent = {
+                                        type: 'string',
+                                        value: current
+                                    };
+                                    unparsedValueComponents.push(newValueComponent);
+                                    currentValueComponents.push(newValueComponent);
+                                } else {
+                                    currentValueComponents.push(valueComponent);
+                                }
+                            }
+                        } else {
+                            currentValueComponents.push({
+                                type: 'string',
+                                value: 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
+                            });
+                        } else {
+                            currentValueComponents.push({
+                                type: 'separator',
+                                value: separator,
+                                text: prefix + separator + suffix
+                            });
+                        }
+                    }
+                    bypassParsing = false;
+                };
+                const pushUnitValueComponents = ()=>{
+                    if (this.definition.unit === 'rem' || this.definition.unit === 'em') {
+                        currentValueComponents.push({
+                            type: 'separator',
+                            value: '/',
+                            text: ' / '
+                        }, {
+                            type: 'number',
+                            value: this.css.config.rootSize
+                        });
+                    }
+                    currentValueComponents.push({
+                        type: 'separator',
+                        value: '*',
+                        text: ' * '
+                    }, {
+                        type: 'number',
+                        value: 1,
+                        unit: 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]
+                            });
+                        }
+                        const functionName = symbolResult ? current.slice(1) : current;
+                        const newValueComponent = {
+                            type: 'function',
+                            name: functionName,
+                            symbol: char,
+                            children: [],
+                            bypassTransform: functionName === 'calc'
+                        };
+                        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[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.parseValueComponent(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'
+    },
+    translateX: {
+        unit: 'rem'
+    },
+    translateY: {
+        unit: 'rem'
+    },
+    translateZ: {
+        unit: 'rem'
+    },
+    translate3d: {
+        unit: 'rem'
+    },
+    skew: {
+        unit: 'deg'
+    },
+    skewX: {
+        unit: 'deg'
+    },
+    skewY: {
+        unit: 'deg'
+    },
+    skewZ: {
+        unit: 'deg'
+    },
+    skew3d: {
+        unit: 'deg'
+    },
+    rotate: {
+        unit: 'deg'
+    },
+    rotateX: {
+        unit: 'deg'
+    },
+    rotateY: {
+        unit: 'deg'
+    },
+    rotateZ: {
+        unit: 'deg'
+    },
+    rotate3d: {
+        unit: 'deg'
+    },
+    blur: {
+        unit: 'rem'
+    },
+    'drop-shadow': {
+        unit: 'rem'
+    },
+    'hue-rotate': {
+        unit: 'deg'
+    },
+    rgb: {
+        unit: ''
+    },
+    rgba: {
+        unit: ''
+    },
+    hsl: {
+        unit: ''
+    },
+    hsla: {
+        unit: ''
+    },
+    color: {
+        unit: '',
+        colored: true
+    },
+    'color-contrast': {
+        unit: '',
+        colored: true
+    },
+    'color-mix': {
+        unit: '',
+        colored: true
+    },
+    hwb: {
+        unit: ''
+    },
+    lab: {
+        unit: ''
+    },
+    lch: {
+        unit: ''
+    },
+    oklab: {
+        unit: ''
+    },
+    oklch: {
+        unit: ''
+    },
+    clamp: {
+        unit: ''
+    },
+    repeat: {
+        unit: ''
+    },
+    'linear-gradient': {
+        colored: true
+    },
+    'radial-gradient': {
+        colored: true
+    },
+    'conic-gradient': {
+        colored: true
+    },
+    'repeating-linear-gradient': {
+        colored: true
+    },
+    'repeating-radial-gradient': {
+        colored: true
+    },
+    'repeating-conic-gradient': {
+        colored: true
+    }
+};
+
+module.exports = functions;