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

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

@@ -0,0 +1,223 @@
+import functions from '../config/functions.mjs';
+import { BASE_UNIT_REGEX } from '../common.mjs';
+
+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 = 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) + ')';
+}
+
+export { coreCalc as default };

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

@@ -0,0 +1,23 @@
+'use strict';
+
+function coreVariable(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
+        }
+    ];
+}
+
+module.exports = coreVariable;

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

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

package/dist/function-transformers/core.variable.mjs

@@ -0,0 +1,21 @@
+function coreVariable(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
+        }
+    ];
+}
+
+export { coreVariable as default };

package/dist/function-transformers/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var core_calc = require('./core.calc.cjs');
+var core_variable = require('./core.variable.cjs');
+
+const functionTransformers = {
+    'core.calc': core_calc,
+    'core.variable': core_variable
+};
+
+module.exports = functionTransformers;

package/dist/function-transformers/index.d.ts

@@ -0,0 +1,8 @@
+import coreCalc from './core.calc';
+import coreVariable from './core.variable';
+declare const functionTransformers: {
+    'core.calc': typeof coreCalc;
+    'core.variable': typeof coreVariable;
+};
+export default functionTransformers;
+export type FunctionTransformerNames = keyof typeof functionTransformers;

package/dist/function-transformers/index.mjs

@@ -0,0 +1,9 @@
+import coreCalc from './core.calc.mjs';
+import coreVariable from './core.variable.mjs';
+
+const functionTransformers = {
+    'core.calc': coreCalc,
+    'core.variable': coreVariable
+};
+
+export { functionTransformers as default };

package/dist/index.cjs

@@ -13,6 +13,7 @@ var nonLayer = require('./non-layer.cjs');
 var syntaxRuleType = require('./syntax-rule-type.cjs');
 var variableRule = require('./variable-rule.cjs');
 var animationRule = require('./animation-rule.cjs');
+var create = require('./create.cjs');
 var withSyntaxLayer = require('./factories/with-syntax-layer.cjs');
 var extendConfig = require('./utils/extend-config.cjs');
 var sortReadableClasses = require('./utils/sort-readable-classes.cjs');
@@ -30,6 +31,10 @@ var parseSelector = require('./utils/parse-selector.cjs');
 var generateSelector = require('./utils/generate-selector.cjs');
 var getSingleAtNumberRuleNode = require('./utils/get-single-at-number-rule-node.cjs');
 var compareRulePriority = require('./utils/compare-rule-priority.cjs');
+var flattenObject = require('./utils/flatten-object.cjs');
+var flattenMetaObject = require('./utils/flatten-meta-object.cjs');
+var nestMetaObject = require('./utils/nest-meta-object.cjs');
+var minifyExtendedConfig = require('./utils/minify-extended-config.cjs');
 var at = require('./config/at.cjs');
 var selectors = require('./config/selectors.cjs');
 var utilities = require('./config/utilities.cjs');
@@ -59,7 +64,6 @@ exports.COMPARISION_OPERATORS = common.COMPARISION_OPERATORS;
 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_COMBINATORS = common.SELECTOR_COMBINATORS;
@@ -81,6 +85,7 @@ exports.NonLayer = nonLayer;
 exports.SyntaxRuleType = syntaxRuleType;
 exports.VariableRule = variableRule.default;
 exports.AnimationRule = animationRule;
+exports.createCSS = create;
 exports.withSyntaxLayer = withSyntaxLayer;
 exports.extendConfig = extendConfig;
 exports.sortReadableClasses = sortReadableClasses;
@@ -98,6 +103,10 @@ exports.parseSelector = parseSelector;
 exports.generateSelector = generateSelector;
 exports.getSingleAtNumberRuleNode = getSingleAtNumberRuleNode;
 exports.compareRulePriority = compareRulePriority.default;
+exports.flattenObject = flattenObject;
+exports.flattenMetaObject = flattenMetaObject;
+exports.nestMetaObject = nestMetaObject;
+exports.minifyExtendedConfig = minifyExtendedConfig;
 exports.at = at;
 exports.selectors = selectors;
 exports.utilities = utilities;

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { default as NonLayer } from './non-layer';
 export { default as SyntaxRuleType } from './syntax-rule-type';
 export { default as VariableRule } from './variable-rule';
 export { default as AnimationRule } from './animation-rule';
+export { default as createCSS } from './create';
 export * from './types/config';
 export * from './types/syntax';
 export * from './types/common';
@@ -24,11 +25,16 @@ export { default as isCoreRule } from './utils/is-core-rule';
 export { default as parsePair } from './utils/parse-pair';
 export { default as parseValue } from './utils/parse-value';
 export { default as parseAt } from './utils/parse-at';
-export type * from './utils/parse-at';
 export { default as generateAt } from './utils/generate-at';
 export { default as parseSelector } from './utils/parse-selector';
-export type * from './utils/parse-selector';
 export { default as generateSelector } from './utils/generate-selector';
 export { default as getSingleAtNumberRuleNode } from './utils/get-single-at-number-rule-node';
 export { default as compareRulePriority } from './utils/compare-rule-priority';
+export { default as flattenObject } from './utils/flatten-object';
+export { default as flattenMetaObject } from './utils/flatten-meta-object';
+export { default as nestMetaObject } from './utils/nest-meta-object';
+export { default as minifyExtendedConfig } from './utils/minify-extended-config';
+export type * from './utils/parse-at';
+export type * from './utils/parse-selector';
+export type * from './utils/extend-config';
 export { default as MasterCSS, default } from './core';

package/dist/index.mjs

@@ -1,5 +1,5 @@
 export { config } from './config/index.mjs';
-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__ } from './common.mjs';
+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__ } from './common.mjs';
 export { default as MasterCSS, default } from './core.mjs';
 export { SyntaxRule } from './syntax-rule.mjs';
 export { Rule } from './rule.mjs';
@@ -9,6 +9,7 @@ export { default as NonLayer } from './non-layer.mjs';
 export { default as SyntaxRuleType } from './syntax-rule-type.mjs';
 export { default as VariableRule } from './variable-rule.mjs';
 export { default as AnimationRule } from './animation-rule.mjs';
+export { default as createCSS } from './create.mjs';
 export { default as withSyntaxLayer } from './factories/with-syntax-layer.mjs';
 export { default as extendConfig } from './utils/extend-config.mjs';
 export { default as sortReadableClasses } from './utils/sort-readable-classes.mjs';
@@ -26,6 +27,10 @@ export { default as parseSelector } from './utils/parse-selector.mjs';
 export { default as generateSelector } from './utils/generate-selector.mjs';
 export { default as getSingleAtNumberRuleNode } from './utils/get-single-at-number-rule-node.mjs';
 export { default as compareRulePriority } from './utils/compare-rule-priority.mjs';
+export { default as flattenObject } from './utils/flatten-object.mjs';
+export { default as flattenMetaObject } from './utils/flatten-meta-object.mjs';
+export { default as nestMetaObject } from './utils/nest-meta-object.mjs';
+export { default as minifyExtendedConfig } from './utils/minify-extended-config.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';

package/dist/layer.cjs

@@ -3,13 +3,11 @@
 class Layer {
     name;
     css;
-    rules;
-    tokenCounts;
+    rules = [];
+    tokenCounts = new Map();
     constructor(name, css){
         this.name = name;
         this.css = css;
-        this.rules = [];
-        this.tokenCounts = new Map();
     }
     attach() {
         this.css.rules.push(this);

package/dist/layer.mjs

@@ -1,13 +1,11 @@
 class Layer {
     name;
     css;
-    rules;
-    tokenCounts;
+    rules = [];
+    tokenCounts = new Map();
     constructor(name, css){
         this.name = name;
         this.css = css;
-        this.rules = [];
-        this.tokenCounts = new Map();
     }
     attach() {
         this.css.rules.push(this);

package/dist/non-layer.cjs

@@ -4,12 +4,10 @@ var findNativeCssRuleIndex = require('./shared/utils/find-native-css-rule-index.
 
 class NonLayer {
     css;
-    rules;
-    tokenCounts;
+    rules = [];
+    tokenCounts = new Map();
     constructor(css){
         this.css = css;
-        this.rules = [];
-        this.tokenCounts = new Map();
     }
     insert(rule) {
         if (this.rules.includes(rule)) return;

package/dist/non-layer.mjs

@@ -2,12 +2,10 @@ import findNativeCSSRuleIndex from './shared/utils/find-native-css-rule-index.mj
 
 class NonLayer {
     css;
-    rules;
-    tokenCounts;
+    rules = [];
+    tokenCounts = new Map();
     constructor(css){
         this.css = css;
-        this.rules = [];
-        this.tokenCounts = new Map();
     }
     insert(rule) {
         if (this.rules.includes(rule)) return;

package/dist/syntax-rule-type.cjs

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

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

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

package/dist/syntax-rule-type.mjs

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