@master/css 2.0.0-rc.6 → 2.0.0-rc.61

package/dist/types/config.d.ts

@@ -0,0 +1,70 @@
+import type { PropertiesHyphen } from 'csstype';
+import type SyntaxRuleType from '../syntax-rule-type';
+import type { SyntaxRule } from '../syntax-rule';
+import type { ValueComponent } from './syntax';
+import type { rules, utilities } from '../config';
+export interface SyntaxRuleDefinition {
+    type?: SyntaxRuleType;
+    matcher?: RegExp;
+    sign?: string;
+    key?: string;
+    subkey?: string;
+    ambiguousKeys?: string[];
+    ambiguousValues?: (RegExp | string)[];
+    variables?: string[];
+    separators?: string[];
+    unit?: any;
+    declarations?: PropertiesHyphen;
+    includeAnimations?: boolean;
+    analyze?: (this: SyntaxRule, className: string) => [valueToken: string, prefixToken?: string];
+    transformValue?(this: SyntaxRule, value: string): string;
+    transformValueComponents?(this: SyntaxRule, valueComponents: ValueComponent[]): ValueComponent[];
+    declare?(this: SyntaxRule, value: string, valueComponents: ValueComponent[]): PropertiesHyphen;
+    delete?(this: SyntaxRule, className: string): void;
+    create?(this: SyntaxRule, className: string): void;
+    insert?(this: SyntaxRule): void;
+}
+export type VariableValue = number | string | false | (number | string)[];
+export type VariableDefinition = {
+    [key in '' | `@${string}` | string]?: VariableValue | VariableDefinition;
+} | VariableValue;
+export type CSSKeyframes = Record<'from' | 'to' | string, PropertiesHyphen>;
+export type AnimationDefinitions = Record<string, CSSKeyframes>;
+export type SelectorDefinitions = Record<string, string | string[]>;
+export interface AtDefinitions {
+    [key: string]: number | string | AtDefinitions;
+}
+export interface StyleDefinitions {
+    [key: string]: string | StyleDefinitions;
+}
+export type SyntaxRuleDefinitions = Partial<Record<keyof typeof rules | string, SyntaxRuleDefinition>>;
+export type VariableDefinitions = {
+    [key in keyof typeof rules]?: VariableDefinition;
+} & Record<string, VariableDefinition>;
+export type UtilityDefinitions = {
+    [key in keyof typeof utilities]?: PropertiesHyphen;
+} & Record<string, PropertiesHyphen>;
+export type ModeDefinitions = Record<string, 'class' | 'media' | 'host' | false>;
+export interface FunctionDefinition {
+    unit?: string;
+    transform?(this: SyntaxRule, value: string, bypassVariableNames: string[]): string | ValueComponent[];
+}
+export type FunctionDefinitions = Record<string, FunctionDefinition>;
+export interface Config {
+    extends?: (Config | any)[];
+    components?: StyleDefinitions;
+    at?: AtDefinitions;
+    selectors?: SelectorDefinitions;
+    utilities?: UtilityDefinitions;
+    variables?: VariableDefinitions;
+    rules?: SyntaxRuleDefinitions;
+    rootSize?: number;
+    baseUnit?: number;
+    defaultMode?: 'light' | 'dark' | string | false;
+    scope?: string;
+    important?: boolean;
+    override?: boolean;
+    functions?: FunctionDefinitions;
+    animations?: AnimationDefinitions;
+    modes?: ModeDefinitions;
+}

package/dist/types/config.mjs

@@ -0,0 +1 @@
+

package/dist/types/syntax.cjs

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

package/dist/types/syntax.d.ts

@@ -0,0 +1,106 @@
+import { SyntaxRuleDefinition } from './config';
+export interface AtArbitraryComponent {
+    type: 'arbitrary';
+    token?: string;
+    value: string;
+}
+export interface AtFeatureComponent {
+    type: 'feature';
+    token?: string;
+    name: string;
+    valueType: 'number' | 'string';
+    value: string | number;
+    unit?: string;
+}
+export interface AtOperatorComponent {
+    type: 'operator';
+    token: '&';
+    value: 'and';
+}
+export type AtComponent = AtArbitraryComponent | AtFeatureComponent | AtOperatorComponent;
+export type ValueComponent = StringValueComponent | NumericValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
+export interface StringValueComponent {
+    text?: string;
+    token: string;
+    type: 'string';
+    value: string;
+}
+export interface NumericValueComponent {
+    text?: string;
+    token: string;
+    type: 'number';
+    value: number;
+    unit?: string;
+}
+export interface FunctionValueComponent {
+    text?: string;
+    token: string;
+    type: 'function';
+    name: string;
+    symbol: string;
+    children: ValueComponent[];
+    bypassTransform?: boolean;
+}
+export interface VariableValueComponent {
+    text?: string;
+    token: string;
+    type: 'variable';
+    name: string;
+    alpha?: string;
+    fallback?: string;
+    variable?: Variable;
+}
+export interface SeparatorValueComponent {
+    text?: string;
+    token: string;
+    type: 'separator';
+    value: string;
+}
+export interface DefinedRule {
+    id: string;
+    key?: string;
+    keys: string[];
+    matchers: {
+        key?: RegExp;
+        variable?: RegExp;
+        value?: RegExp;
+        arbitrary?: RegExp;
+    };
+    variables: Record<string, Variable>;
+    order: number;
+    definition: SyntaxRuleDefinition;
+}
+export type MediaFeatureComponent = {
+    type: string;
+    tokenType?: string;
+    operator?: string;
+    value: number;
+    unit: string;
+};
+export interface MediaQuery {
+    token: string;
+    features: Record<string, MediaFeatureComponent>;
+    type?: string;
+}
+type VariableCommon = {
+    group?: string;
+    name: string;
+    key: string;
+    modes?: Record<string, TypeVariable>;
+};
+export interface StringVariable {
+    type: 'string';
+    value: string;
+}
+export interface NumberVariable {
+    type: 'number';
+    value: number;
+}
+export interface ColorVariable {
+    type: 'color';
+    value: string;
+    space: 'rgb' | 'hsl';
+}
+export type TypeVariable = StringVariable | NumberVariable | ColorVariable;
+export type Variable = TypeVariable & VariableCommon;
+export {};

package/dist/types/syntax.mjs

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,12 @@
+'use strict';
+
+function areRuleAtEqual(a, b) {
+    const compare = (aList, bList)=>{
+        const aResolved = (aList ?? []).map(a.resolveAtComponent);
+        const bResolved = (bList ?? []).map(b.resolveAtComponent);
+        return aResolved.length === bResolved.length && aResolved.every((val)=>bResolved.includes(val)) && bResolved.every((val)=>aResolved.includes(val));
+    };
+    return compare(a.mediaAtComponents, b.mediaAtComponents) && compare(a.supportsAtComponents, b.supportsAtComponents) && compare(a.containerAtComponents, b.containerAtComponents) && compare(a.layerAtComponents, b.layerAtComponents);
+}
+
+module.exports = areRuleAtEqual;

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

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleAtEqual(a: SyntaxRule, b: SyntaxRule): boolean;

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

@@ -0,0 +1,10 @@
+function areRuleAtEqual(a, b) {
+    const compare = (aList, bList)=>{
+        const aResolved = (aList ?? []).map(a.resolveAtComponent);
+        const bResolved = (bList ?? []).map(b.resolveAtComponent);
+        return aResolved.length === bResolved.length && aResolved.every((val)=>bResolved.includes(val)) && bResolved.every((val)=>aResolved.includes(val));
+    };
+    return compare(a.mediaAtComponents, b.mediaAtComponents) && compare(a.supportsAtComponents, b.supportsAtComponents) && compare(a.containerAtComponents, b.containerAtComponents) && compare(a.layerAtComponents, b.layerAtComponents);
+}
+
+export { areRuleAtEqual as default };

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

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

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

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleModesEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

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

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

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

@@ -0,0 +1,29 @@
+'use strict';
+
+function areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) {
+    // suffix
+    const aVendorSuffixSelectorKeys = aSyntaxRule.vendorSuffixSelectors ? Object.keys(aSyntaxRule.vendorSuffixSelectors) : [];
+    const bVendorSuffixSelectorKeys = bSyntaxRule.vendorSuffixSelectors ? Object.keys(bSyntaxRule.vendorSuffixSelectors) : [];
+    if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
+    const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorSuffixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorSuffixSelectors) return false;
+    // prefix
+    const aVendorPrefixSelectorKeys = aSyntaxRule.vendorPrefixSelectors ? Object.keys(aSyntaxRule.vendorPrefixSelectors) : [];
+    const bVendorPrefixSelectorKeys = bSyntaxRule.vendorPrefixSelectors ? Object.keys(bSyntaxRule.vendorPrefixSelectors) : [];
+    if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
+    const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorPrefixSelectors?.[eachAKey] || [];
+        const bValues = bSyntaxRule.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 { SyntaxRule } from '../syntax-rule';
+export default function areRuleSelectorsEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

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

@@ -0,0 +1,27 @@
+function areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) {
+    // suffix
+    const aVendorSuffixSelectorKeys = aSyntaxRule.vendorSuffixSelectors ? Object.keys(aSyntaxRule.vendorSuffixSelectors) : [];
+    const bVendorSuffixSelectorKeys = bSyntaxRule.vendorSuffixSelectors ? Object.keys(bSyntaxRule.vendorSuffixSelectors) : [];
+    if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
+    const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorSuffixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorSuffixSelectors) return false;
+    // prefix
+    const aVendorPrefixSelectorKeys = aSyntaxRule.vendorPrefixSelectors ? Object.keys(aSyntaxRule.vendorPrefixSelectors) : [];
+    const bVendorPrefixSelectorKeys = bSyntaxRule.vendorPrefixSelectors ? Object.keys(bSyntaxRule.vendorPrefixSelectors) : [];
+    if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
+    const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorPrefixSelectors?.[eachAKey] || [];
+        const bValues = bSyntaxRule.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(aSyntaxRule, bSyntaxRule) {
+    return areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) && areRuleModesEqual(aSyntaxRule, bSyntaxRule) && areRuleAtEqual(aSyntaxRule, bSyntaxRule);
+}
+
+module.exports = areRuleStatesEqual;

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

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleStatesEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): 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(aSyntaxRule, bSyntaxRule) {
+    return areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) && areRuleModesEqual(aSyntaxRule, bSyntaxRule) && areRuleAtEqual(aSyntaxRule, bSyntaxRule);
+}
+
+export { areRuleStatesEqual as default };

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

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

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

@@ -0,0 +1,2 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function areRulesDuplicated(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

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

@@ -0,0 +1,15 @@
+function areRulesDuplicated(aSyntaxRule, bSyntaxRule) {
+    const aKeys = Object.keys(aSyntaxRule.declarations || {});
+    const bKeys = Object.keys(bSyntaxRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.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 { SyntaxRuleDefinition } from '../types/config';
+declare const autofillSolidStyle: SyntaxRuleDefinition['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,59 @@
+'use strict';
+
+var extend = require('@techor/extend');
+
+// todo: split resolveConfig into a function
+function extendConfig(...configs) {
+    const formatConfig = (config)=>{
+        const clonedConfig = extend({}, config);
+        const formatDeeply = (obj)=>{
+            Object.entries(obj).forEach(([key, value])=>{
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    formatDeeply(value);
+                } else if (key && !key.startsWith('@')) {
+                    obj[key] = {
+                        '': value
+                    };
+                }
+            });
+        };
+        [
+            'components',
+            'at',
+            'variables'
+        ].forEach((key)=>{
+            if (clonedConfig[key]) {
+                formatDeeply(clonedConfig[key]);
+            }
+        });
+        return clonedConfig;
+    };
+    const collectConfigs = (config, result = [])=>{
+        if (!config) return result;
+        if (config.extends?.length) {
+            config.extends.forEach((ext)=>collectConfigs('config' in ext ? ext.config : ext, result));
+        }
+        result.push(formatConfig(config));
+        return result;
+    };
+    const formattedConfigs = configs.reduce((acc, config)=>collectConfigs(config, acc), []);
+    return formattedConfigs.reduce((extendedConfig, currentConfig)=>{
+        Object.entries(currentConfig).forEach(([key, value])=>{
+            if (key === 'animations' && value) {
+                Object.assign(extendedConfig.animations, value);
+            } else if (value) {
+                extendedConfig = extend(extendedConfig, {
+                    [key]: value
+                });
+            }
+        });
+        return extendedConfig;
+    }, {
+        animations: {},
+        components: {},
+        at: {},
+        variables: {}
+    });
+}
+
+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;
+import type { Config } from '../types/config';
+export default function extendConfig(...configs: (Config | undefined)[]): Config;

package/dist/utils/extend-config.mjs

@@ -0,0 +1,57 @@
+import extend from '@techor/extend';
+
+// todo: split resolveConfig into a function
+function extendConfig(...configs) {
+    const formatConfig = (config)=>{
+        const clonedConfig = extend({}, config);
+        const formatDeeply = (obj)=>{
+            Object.entries(obj).forEach(([key, value])=>{
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    formatDeeply(value);
+                } else if (key && !key.startsWith('@')) {
+                    obj[key] = {
+                        '': value
+                    };
+                }
+            });
+        };
+        [
+            'components',
+            'at',
+            'variables'
+        ].forEach((key)=>{
+            if (clonedConfig[key]) {
+                formatDeeply(clonedConfig[key]);
+            }
+        });
+        return clonedConfig;
+    };
+    const collectConfigs = (config, result = [])=>{
+        if (!config) return result;
+        if (config.extends?.length) {
+            config.extends.forEach((ext)=>collectConfigs('config' in ext ? ext.config : ext, result));
+        }
+        result.push(formatConfig(config));
+        return result;
+    };
+    const formattedConfigs = configs.reduce((acc, config)=>collectConfigs(config, acc), []);
+    return formattedConfigs.reduce((extendedConfig, currentConfig)=>{
+        Object.entries(currentConfig).forEach(([key, value])=>{
+            if (key === 'animations' && value) {
+                Object.assign(extendedConfig.animations, value);
+            } else if (value) {
+                extendedConfig = extend(extendedConfig, {
+                    [key]: value
+                });
+            }
+        });
+        return extendedConfig;
+    }, {
+        animations: {},
+        components: {},
+        at: {},
+        variables: {}
+    });
+}
+
+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.d.ts

@@ -1 +1 @@
-export declare function flattenObject(obj: Record<string, any>, parentKey?: string): Record<string, any>;
+export declare function flattenObject(obj: Map<string, any> | Record<string, any>, parentKey?: string): Record<string, any>;

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()) {
+    let text = '';
+    css.add(...classes);
+    text = css.text;
+    css.remove(...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.remove(...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)[];