@master/css 2.0.0-rc.4 → 2.0.0-rc.40

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/types/global.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types/global.d.ts

@@ -1,5 +1,5 @@
-import type { MasterCSS as _MasterCSS } from '../core';
+import type Core from '../core';
 declare global {
-    var MasterCSS: typeof _MasterCSS;
-    var masterCSSs: _MasterCSS[];
+    var masterCSSs: Core[];
+    var MasterCSS: typeof Core;
 }

package/dist/types/global.mjs

@@ -0,0 +1 @@
+

package/dist/utils/are-rule-at-equal.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+function areRuleAtEqual(aRule, bRule) {
+    const aQueryTypes = Object.keys(aRule.at);
+    const bQueryTypes = Object.keys(bRule.at);
+    if (aQueryTypes.length !== bQueryTypes.length) {
+        return false;
+    }
+    for (const aQueryType of aQueryTypes){
+        const aAtComponents = aRule.at[aQueryType];
+        const bAtComponents = bRule.at[aQueryType];
+        for (const aAtComponent of aAtComponents){
+            const aAtComponentToken = aRule.resolveAtComponent(aAtComponent);
+            if (!bAtComponents.find((bAtComponent)=>bRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+module.exports = areRuleAtEqual;

package/dist/utils/are-rule-at-equal.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from '../rule';
+export default function areRuleAtEqual(aRule: Rule, bRule: Rule): boolean;

package/dist/utils/are-rule-at-equal.mjs

@@ -0,0 +1,20 @@
+function areRuleAtEqual(aRule, bRule) {
+    const aQueryTypes = Object.keys(aRule.at);
+    const bQueryTypes = Object.keys(bRule.at);
+    if (aQueryTypes.length !== bQueryTypes.length) {
+        return false;
+    }
+    for (const aQueryType of aQueryTypes){
+        const aAtComponents = aRule.at[aQueryType];
+        const bAtComponents = bRule.at[aQueryType];
+        for (const aAtComponent of aAtComponents){
+            const aAtComponentToken = aRule.resolveAtComponent(aAtComponent);
+            if (!bAtComponents.find((bAtComponent)=>bRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+export { areRuleAtEqual as default };

package/dist/utils/are-rule-modes-equal.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function areRuleModesEqual(aRule, bRule) {
+    return aRule.mode === bRule.mode;
+}
+
+module.exports = areRuleModesEqual;

package/dist/utils/are-rule-modes-equal.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from '../rule';
+export default function areRuleModesEqual(aRule: Rule, bRule: Rule): boolean;

package/dist/utils/are-rule-modes-equal.mjs

@@ -0,0 +1,5 @@
+function areRuleModesEqual(aRule, bRule) {
+    return aRule.mode === bRule.mode;
+}
+
+export { areRuleModesEqual as default };

package/dist/utils/are-rule-selectors-equal.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+function areRuleSelectorsEqual(aRule, bRule) {
+    // suffix
+    const aVendorSuffixSelectorKeys = Object.keys(aRule.vendorSuffixSelectors);
+    const bVendorSuffixSelectorKeys = Object.keys(bRule.vendorSuffixSelectors);
+    if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
+    const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bRule.vendorSuffixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorSuffixSelectors) return false;
+    // prefix
+    const aVendorPrefixSelectorKeys = Object.keys(aRule.vendorPrefixSelectors);
+    const bVendorPrefixSelectorKeys = Object.keys(bRule.vendorPrefixSelectors);
+    if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
+    const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aRule.vendorPrefixSelectors[eachAKey];
+        const bValues = bRule.vendorPrefixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorPrefixSelectors) return false;
+    return true;
+}
+
+module.exports = areRuleSelectorsEqual;

package/dist/utils/are-rule-selectors-equal.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from '../rule';
+export default function areRuleSelectorsEqual(aRule: Rule, bRule: Rule): boolean;

package/dist/utils/are-rule-selectors-equal.mjs

@@ -0,0 +1,27 @@
+function areRuleSelectorsEqual(aRule, bRule) {
+    // suffix
+    const aVendorSuffixSelectorKeys = Object.keys(aRule.vendorSuffixSelectors);
+    const bVendorSuffixSelectorKeys = Object.keys(bRule.vendorSuffixSelectors);
+    if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
+    const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bRule.vendorSuffixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorSuffixSelectors) return false;
+    // prefix
+    const aVendorPrefixSelectorKeys = Object.keys(aRule.vendorPrefixSelectors);
+    const bVendorPrefixSelectorKeys = Object.keys(bRule.vendorPrefixSelectors);
+    if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
+    const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aRule.vendorPrefixSelectors[eachAKey];
+        const bValues = bRule.vendorPrefixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorPrefixSelectors) return false;
+    return true;
+}
+
+export { areRuleSelectorsEqual as default };

package/dist/utils/are-rule-states-equal.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var areRuleSelectorsEqual = require('./are-rule-selectors-equal.cjs');
+var areRuleModesEqual = require('./are-rule-modes-equal.cjs');
+var areRuleAtEqual = require('./are-rule-at-equal.cjs');
+
+function areRuleStatesEqual(aRule, bRule) {
+    return areRuleSelectorsEqual(aRule, bRule) && areRuleModesEqual(aRule, bRule) && areRuleAtEqual(aRule, bRule);
+}
+
+module.exports = areRuleStatesEqual;

package/dist/utils/are-rule-states-equal.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from '../rule';
+export default function areRuleStatesEqual(aRule: Rule, bRule: Rule): boolean;

package/dist/utils/are-rule-states-equal.mjs

@@ -0,0 +1,9 @@
+import areRuleSelectorsEqual from './are-rule-selectors-equal.mjs';
+import areRuleModesEqual from './are-rule-modes-equal.mjs';
+import areRuleAtEqual from './are-rule-at-equal.mjs';
+
+function areRuleStatesEqual(aRule, bRule) {
+    return areRuleSelectorsEqual(aRule, bRule) && areRuleModesEqual(aRule, bRule) && areRuleAtEqual(aRule, bRule);
+}
+
+export { areRuleStatesEqual as default };

package/dist/utils/are-rules-duplicated.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function areRulesDuplicated(aRule, bRule) {
+    const aKeys = Object.keys(aRule.declarations || {});
+    const bKeys = Object.keys(bRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bRule.declarations, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+module.exports = areRulesDuplicated;

package/dist/utils/are-rules-duplicated.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from '../rule';
+export default function areRulesDuplicated(aRule: Rule, bRule: Rule): boolean;

package/dist/utils/are-rules-duplicated.mjs

@@ -0,0 +1,15 @@
+function areRulesDuplicated(aRule, bRule) {
+    const aKeys = Object.keys(aRule.declarations || {});
+    const bKeys = Object.keys(bRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bRule.declarations, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { areRulesDuplicated as default };

package/dist/utils/autofill-solid-style.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var common = require('../common.cjs');
+
+const autofillSolidStyle = function(valueComponents) {
+    if (valueComponents.length < 2) return valueComponents;
+    let styleIncluded = false;
+    let varIncluded = false;
+    for (const valueComponent of valueComponents){
+        if (valueComponent.type === 'string' && common.BORDER_STYLE_VALUES.includes(valueComponent.value) || valueComponent.type === 'variable' && common.BORDER_STYLE_VALUES.includes(String(valueComponent.variable?.value))) {
+            styleIncluded = true;
+        }
+        if (valueComponent.type === 'function' && valueComponent.name === 'var') {
+            varIncluded = true;
+        }
+    }
+    if (!styleIncluded && !varIncluded) {
+        valueComponents.push({
+            type: 'separator',
+            value: ' ',
+            token: '|'
+        }, {
+            type: 'string',
+            value: 'solid',
+            token: 'solid'
+        });
+    }
+    return valueComponents;
+};
+
+module.exports = autofillSolidStyle;

package/dist/utils/autofill-solid-style.d.ts

@@ -0,0 +1,3 @@
+import { RuleDefinition } from '../rule';
+declare const autofillSolidStyle: RuleDefinition['transformValueComponents'];
+export default autofillSolidStyle;

package/dist/utils/autofill-solid-style.mjs

@@ -0,0 +1,29 @@
+import { BORDER_STYLE_VALUES } from '../common.mjs';
+
+const autofillSolidStyle = function(valueComponents) {
+    if (valueComponents.length < 2) return valueComponents;
+    let styleIncluded = false;
+    let varIncluded = false;
+    for (const valueComponent of valueComponents){
+        if (valueComponent.type === 'string' && BORDER_STYLE_VALUES.includes(valueComponent.value) || valueComponent.type === 'variable' && BORDER_STYLE_VALUES.includes(String(valueComponent.variable?.value))) {
+            styleIncluded = true;
+        }
+        if (valueComponent.type === 'function' && valueComponent.name === 'var') {
+            varIncluded = true;
+        }
+    }
+    if (!styleIncluded && !varIncluded) {
+        valueComponents.push({
+            type: 'separator',
+            value: ' ',
+            token: '|'
+        }, {
+            type: 'string',
+            value: 'solid',
+            token: 'solid'
+        });
+    }
+    return valueComponents;
+};
+
+export { autofillSolidStyle as default };

package/dist/utils/extend-config.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var extend = require('@techor/extend');
+
+function extendConfig(...configs) {
+    const formatConfig = (config)=>{
+        const clonedConfig = extend({}, config);
+        const formatDeeply = (obj)=>{
+            for(const key in obj){
+                const value = obj[key];
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    formatDeeply(value);
+                } else if (key && !key.startsWith('@')) {
+                    obj[key] = {
+                        '': value
+                    };
+                }
+            }
+        };
+        if (clonedConfig.styles) {
+            formatDeeply(clonedConfig.styles);
+        }
+        if (clonedConfig.at) {
+            formatDeeply(clonedConfig.at);
+        }
+        if (clonedConfig.variables) {
+            formatDeeply(clonedConfig.variables);
+        }
+        return clonedConfig;
+    };
+    const formattedConfigs = [];
+    for (const eachConfig of configs){
+        if (!eachConfig) continue;
+        (function getConfigsDeeply(config) {
+            if (config.extends?.length) {
+                for (const eachExtend of config.extends){
+                    getConfigsDeeply('config' in eachExtend ? eachExtend.config : eachExtend);
+                }
+            }
+            formattedConfigs.push(formatConfig(config));
+        })(eachConfig);
+    }
+    let extendedConfig = {
+        animations: {},
+        styles: {},
+        at: {},
+        variables: {}
+    };
+    for(let i = 0; i < formattedConfigs.length; i++){
+        const currentFormattedConfig = formattedConfigs[i];
+        for(const key in currentFormattedConfig){
+            switch(key){
+                case 'animations':
+                    if (currentFormattedConfig.animations) {
+                        Object.assign(extendedConfig.animations, currentFormattedConfig.animations);
+                    }
+                    break;
+                default:
+                    if (currentFormattedConfig[key]) {
+                        extendedConfig = extend(extendedConfig, {
+                            [key]: currentFormattedConfig[key]
+                        });
+                    }
+            }
+        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.styles, key)) {
+        //     Object.assign(extendedConfig.styles[key], currentFormattedConfig.styles[key])
+        // }
+        }
+    }
+    return extendedConfig;
+}
+
+module.exports = extendConfig;

package/dist/utils/extend-config.d.ts

@@ -1,2 +1,2 @@
 import type { Config } from '../config';
-export declare function extendConfig(...configs: Config[]): Config;
+export default function extendConfig(...configs: (Config | undefined)[]): Config;

package/dist/utils/extend-config.mjs

@@ -0,0 +1,71 @@
+import extend from '@techor/extend';
+
+function extendConfig(...configs) {
+    const formatConfig = (config)=>{
+        const clonedConfig = extend({}, config);
+        const formatDeeply = (obj)=>{
+            for(const key in obj){
+                const value = obj[key];
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    formatDeeply(value);
+                } else if (key && !key.startsWith('@')) {
+                    obj[key] = {
+                        '': value
+                    };
+                }
+            }
+        };
+        if (clonedConfig.styles) {
+            formatDeeply(clonedConfig.styles);
+        }
+        if (clonedConfig.at) {
+            formatDeeply(clonedConfig.at);
+        }
+        if (clonedConfig.variables) {
+            formatDeeply(clonedConfig.variables);
+        }
+        return clonedConfig;
+    };
+    const formattedConfigs = [];
+    for (const eachConfig of configs){
+        if (!eachConfig) continue;
+        (function getConfigsDeeply(config) {
+            if (config.extends?.length) {
+                for (const eachExtend of config.extends){
+                    getConfigsDeeply('config' in eachExtend ? eachExtend.config : eachExtend);
+                }
+            }
+            formattedConfigs.push(formatConfig(config));
+        })(eachConfig);
+    }
+    let extendedConfig = {
+        animations: {},
+        styles: {},
+        at: {},
+        variables: {}
+    };
+    for(let i = 0; i < formattedConfigs.length; i++){
+        const currentFormattedConfig = formattedConfigs[i];
+        for(const key in currentFormattedConfig){
+            switch(key){
+                case 'animations':
+                    if (currentFormattedConfig.animations) {
+                        Object.assign(extendedConfig.animations, currentFormattedConfig.animations);
+                    }
+                    break;
+                default:
+                    if (currentFormattedConfig[key]) {
+                        extendedConfig = extend(extendedConfig, {
+                            [key]: currentFormattedConfig[key]
+                        });
+                    }
+            }
+        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.styles, key)) {
+        //     Object.assign(extendedConfig.styles[key], currentFormattedConfig.styles[key])
+        // }
+        }
+    }
+    return extendedConfig;
+}
+
+export { extendConfig as default };

package/dist/utils/flatten-object.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function flattenObject(obj, parentKey = '') {
+    return Object.entries(obj).reduce((acc, [key, value])=>{
+        const currentKey = parentKey ? `${parentKey}${key ? '-' + key : ''}` : key;
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(acc, flattenObject(value, currentKey));
+        } else {
+            acc[currentKey] = value;
+        }
+        return acc;
+    }, {});
+}
+
+exports.flattenObject = flattenObject;

package/dist/utils/flatten-object.mjs

@@ -0,0 +1,13 @@
+function flattenObject(obj, parentKey = '') {
+    return Object.entries(obj).reduce((acc, [key, value])=>{
+        const currentKey = parentKey ? `${parentKey}${key ? '-' + key : ''}` : key;
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(acc, flattenObject(value, currentKey));
+        } else {
+            acc[currentKey] = value;
+        }
+        return acc;
+    }, {});
+}
+
+export { flattenObject };

package/dist/utils/generate-css.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var core = require('../core.cjs');
+
+function generateCSS(classes, css = new core.default()) {
+    let text = '';
+    css.add(...classes);
+    text = css.text;
+    css.delete(...classes);
+    return text;
+}
+
+module.exports = generateCSS;

package/dist/utils/generate-css.d.ts

@@ -0,0 +1,2 @@
+import MasterCSS from '../core';
+export default function generateCSS(classes: string[], css?: MasterCSS): string;

package/dist/utils/generate-css.mjs

@@ -0,0 +1,11 @@
+import MasterCSS from '../core.mjs';
+
+function generateCSS(classes, css = new MasterCSS()) {
+    let text = '';
+    css.add(...classes);
+    text = css.text;
+    css.delete(...classes);
+    return text;
+}
+
+export { generateCSS as default };

package/dist/utils/hex-to-rgb.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+function hexToRgb(hex) {
+    if (hex.startsWith('#')) {
+        hex = hex.slice(1);
+    }
+    let r;
+    let g;
+    let b;
+    let a;
+    if (hex.length === 3 || hex.length === 4) {
+        r = parseInt(hex[0] + hex[0], 16);
+        g = parseInt(hex[1] + hex[1], 16);
+        b = parseInt(hex[2] + hex[2], 16);
+        a = hex.length === 4 ? Math.round(parseInt(hex[3] + hex[3], 16) / 255 * 100) / 100 : 1;
+    } else if (hex.length === 6 || hex.length === 8) {
+        r = parseInt(hex.slice(0, 2), 16);
+        g = parseInt(hex.slice(2, 4), 16);
+        b = parseInt(hex.slice(4, 6), 16);
+        a = hex.length === 8 ? Math.round(parseInt(hex.slice(6, 8), 16) / 255 * 100) / 100 : 1;
+    }
+    return [
+        r,
+        g,
+        b,
+        a
+    ];
+}
+
+module.exports = hexToRgb;

package/dist/utils/hex-to-rgb.d.ts

@@ -1 +1 @@
-export declare function hexToRgb(hex: string): (number | undefined)[];
+export default function hexToRgb(hex: string): (number | undefined)[];