@master/css-compiler 2.0.0-rc.73 → 2.0.0-rc.74

package/dist/master-css-manifest.mjs

@@ -1,760 +0,0 @@
-import UtilityType from '@master/css-schema/utility-type';
-import { groupMasterCSSManifestVariables, flattenMasterCSSManifestVariables } from '@master/css-schema/manifest';
-import { createCompilerCSS, parseSelector, parseAt } from '@master/css-engine/compiler';
-import { builtinNamespaces } from '@master/css-engine';
-import { isNativeCSSShorthandProperty } from '@master/css-schema/native-css-shorthand';
-
-const NUMERIC_THEME_NAMESPACES = new Set([
-    'font-size',
-    'radius',
-    'spacing',
-    'breakpoint',
-    'container'
-]);
-const UNITFUL_NUMERIC_TOKEN = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(px|rem)?$/;
-function clone(value) {
-    if (Array.isArray(value)) return value.map((item)=>clone(item));
-    if (value && typeof value === 'object') {
-        const result = {};
-        for(const key in value){
-            result[key] = clone(value[key]);
-        }
-        return result;
-    }
-    return value;
-}
-function normalizeZero(value) {
-    return Object.is(value, -0) ? 0 : value;
-}
-function addVariableNamespace(namespaces, namespace) {
-    if (typeof namespace === 'string' && namespace) namespaces.add(namespace);
-}
-function addVariableAliasRefNamespace(namespaces, ref) {
-    if (typeof ref === 'string' && (ref[0] === '=' || ref[0] === '~')) {
-        addVariableNamespace(namespaces, ref.slice(1));
-    }
-}
-function addImplicitUtilityNamespace(namespaces, value) {
-    if (typeof value !== 'string' || !value || value[0] === '.' || value.includes('()')) return;
-    addVariableNamespace(namespaces, value);
-}
-function addUtilityVariableNamespaces(namespaces, utilities) {
-    for (const utility of utilities || []){
-        for (const namespace of utility.namespaces || []){
-            addVariableNamespace(namespaces, namespace);
-        }
-        for (const ref of utility.variableAliasRefs || []){
-            addVariableAliasRefNamespace(namespaces, ref);
-        }
-        if (utility.implicitNamespace !== false && utility.emit?.type === 'property') {
-            addImplicitUtilityNamespace(namespaces, utility.id);
-            addImplicitUtilityNamespace(namespaces, utility.name);
-        }
-    }
-}
-function collectVariableNamespaces(input = {}, options = {}) {
-    const namespaces = new Set(builtinNamespaces);
-    for (const variable of flattenMasterCSSManifestVariables(options.baseManifest?.variables)){
-        addVariableNamespace(namespaces, variable.namespace);
-    }
-    for (const variable of input.variables || []){
-        addVariableNamespace(namespaces, variable.namespace);
-    }
-    addUtilityVariableNamespaces(namespaces, options.baseManifest?.utilities);
-    addUtilityVariableNamespaces(namespaces, input.utilities);
-    return [
-        ...namespaces
-    ].sort((a, b)=>b.length - a.length || a.localeCompare(b));
-}
-function resolveVariableName(variable, namespaces) {
-    const explicitName = variable.name?.replace(/^--/, '');
-    if (variable.namespace || variable.key !== undefined) {
-        const key = variable.key ?? explicitName ?? '';
-        const name = variable.namespace ? `${variable.namespace}${key ? '-' + key : ''}` : key;
-        return {
-            name,
-            key,
-            ...variable.namespace ? {
-                namespace: variable.namespace
-            } : {}
-        };
-    }
-    const name = explicitName || '';
-    const namespace = namespaces.find((eachNamespace)=>name.startsWith(eachNamespace + '-'));
-    return namespace ? {
-        name,
-        namespace,
-        key: name.slice(namespace.length + 1)
-    } : {
-        name,
-        key: name
-    };
-}
-function createVariableNameResolver(input = {}, options = {}) {
-    const namespaces = collectVariableNamespaces(input, options);
-    return (variable)=>resolveVariableName(variable, namespaces);
-}
-function getVariableType(value) {
-    return typeof value === 'number' ? 'number' : 'string';
-}
-function getVariableNumericValue(value, namespace) {
-    if (!namespace || !NUMERIC_THEME_NAMESPACES.has(namespace)) return;
-    if (typeof value === 'number') {
-        return {
-            value
-        };
-    }
-    if (typeof value !== 'string') return;
-    const match = UNITFUL_NUMERIC_TOKEN.exec(value.trim());
-    if (!match) return;
-    return {
-        value: Number(match[1]),
-        ...match[2] ? {
-            unit: match[2]
-        } : {}
-    };
-}
-function collectVariableDependencies(value, dependencies = new Set()) {
-    if (typeof value !== 'string') return dependencies;
-    for (const match of value.matchAll(/\$(-?[_a-zA-Z0-9-]+)/g)){
-        dependencies.add(match[1]);
-    }
-    for (const match of value.matchAll(/var\(\s*--(-?[_a-zA-Z0-9-]+)/g)){
-        dependencies.add(match[1]);
-    }
-    return dependencies;
-}
-function variableSlot(variable) {
-    return variable.name || `${variable.namespace || ''}\0${variable.key}`;
-}
-function pushVariable(target, variable) {
-    const slot = variableSlot(variable);
-    const existing = target.find((eachVariable)=>variableSlot(eachVariable) === slot);
-    if (existing) {
-        Object.assign(existing, variable);
-    } else {
-        target.push(variable);
-    }
-}
-function compileVariables(input, resolveVariableName) {
-    if (!input?.length) return;
-    const variables = [];
-    const byName = new Map();
-    for (const definition of input){
-        const resolved = resolveVariableName(definition);
-        if (!resolved.name) continue;
-        const value = normalizeZero(definition.value);
-        const numeric = getVariableNumericValue(value, resolved.namespace);
-        const type = numeric ? 'number' : getVariableType(value);
-        const dependencies = collectVariableDependencies(value);
-        if (definition.mode) {
-            let target = byName.get(resolved.name);
-            if (!target) {
-                target = {
-                    name: resolved.name,
-                    key: resolved.key,
-                    ...resolved.namespace ? {
-                        namespace: resolved.namespace
-                    } : {},
-                    type,
-                    modes: {},
-                    ...definition.static ? {
-                        static: true
-                    } : {}
-                };
-                byName.set(resolved.name, target);
-                pushVariable(variables, target);
-            }
-            if (definition.static) target.static = true;
-            target.modes ??= {};
-            target.modes[definition.mode] = {
-                type,
-                value: value,
-                ...numeric ? {
-                    numeric
-                } : {}
-            };
-            if (dependencies.size) {
-                const next = new Set([
-                    ...target.dependencies || [],
-                    ...dependencies
-                ]);
-                target.dependencies = [
-                    ...next
-                ];
-            }
-            continue;
-        }
-        const variable = {
-            name: resolved.name,
-            key: resolved.key,
-            ...resolved.namespace ? {
-                namespace: resolved.namespace
-            } : {},
-            type,
-            value,
-            ...numeric ? {
-                numeric
-            } : {},
-            ...dependencies.size ? {
-                dependencies: [
-                    ...dependencies
-                ]
-            } : {},
-            ...definition.inline ? {
-                inline: true
-            } : {},
-            ...definition.static ? {
-                static: true
-            } : {}
-        };
-        byName.set(resolved.name, variable);
-        pushVariable(variables, variable);
-    }
-    return variables.length ? variables : undefined;
-}
-function normalizeNumericAtRuleValue(variable, rootSize) {
-    if (variable.key.startsWith('-')) return;
-    const numeric = variable.numeric || (typeof variable.value === 'number' ? {
-        value: variable.value
-    } : undefined);
-    if (!numeric) return;
-    switch(numeric.unit){
-        case undefined:
-        case '':
-        case 'px':
-            return numeric.value / rootSize;
-        case 'rem':
-            return numeric.value;
-        default:
-            return;
-    }
-}
-function createVariableAtRule(variable, id, rootSize) {
-    const value = normalizeNumericAtRuleValue(variable, rootSize);
-    if (value === undefined) return;
-    return {
-        id,
-        nodes: [
-            {
-                type: 'number',
-                value,
-                unit: 'rem'
-            }
-        ]
-    };
-}
-function compileAtRules(variables, rootSize) {
-    const atRules = {};
-    const breakpointAtRules = {};
-    const containerAtRules = {};
-    for (const variable of variables || []){
-        if (variable.namespace === 'breakpoint') {
-            const atRule = createVariableAtRule(variable, 'media', rootSize);
-            if (atRule) {
-                atRules[variable.key] = atRule;
-                breakpointAtRules[variable.key] = atRule;
-            }
-        } else if (variable.namespace === 'container') {
-            const atRule = createVariableAtRule(variable, 'container', rootSize);
-            if (atRule) {
-                containerAtRules[variable.key] = atRule;
-            }
-        }
-    }
-    return {
-        atRules: Object.keys(atRules).length ? atRules : undefined,
-        breakpointAtRules: Object.keys(breakpointAtRules).length ? breakpointAtRules : undefined,
-        containerAtRules: Object.keys(containerAtRules).length ? containerAtRules : undefined
-    };
-}
-function cloneAtRuleNode(node) {
-    return 'children' in node ? {
-        ...node,
-        children: node.children.map(cloneAtRuleNode)
-    } : {
-        ...node
-    };
-}
-function cloneAtRule(atRule) {
-    return {
-        id: atRule.id,
-        nodes: atRule.nodes.map(cloneAtRuleNode)
-    };
-}
-function cloneSelectorNode(node) {
-    return 'children' in node && node.children?.length ? {
-        ...node,
-        children: node.children.map(cloneSelectorNode)
-    } : {
-        ...node
-    };
-}
-function compileVariantBranch(branch, css) {
-    const selector = branch.selector?.trim();
-    const bodylessSelector = selector ? selector.includes('&') ? selector.replace(/&/g, '') : selector : undefined;
-    const selectorNodes = branch.selectorNodes?.length ? branch.selectorNodes.map(cloneSelectorNode) : bodylessSelector ? parseSelector(bodylessSelector, css, false).map((node)=>cloneSelectorNode(node)) : undefined;
-    const atRuleNodes = branch.atRuleNodes?.length ? branch.atRuleNodes.map(cloneAtRule) : branch.atRules?.length ? branch.atRules.map((atRule)=>cloneAtRule(parseAt(atRule, css, false))) : undefined;
-    return {
-        ...branch,
-        ...selectorNodes?.length ? {
-            selectorNodes
-        } : {},
-        ...branch.atRules?.length ? {
-            atRules: [
-                ...branch.atRules
-            ]
-        } : {},
-        ...atRuleNodes?.length ? {
-            atRuleNodes
-        } : {}
-    };
-}
-function compileVariants(input, baseManifest) {
-    if (!input?.length) return {};
-    const css = createCompilerCSS(baseManifest);
-    const variants = [];
-    const selectors = {};
-    const atRules = {};
-    for (const variant of input){
-        const branches = variant.branches.map((branch)=>compileVariantBranch(branch, css));
-        variants.push({
-            token: variant.token,
-            branches
-        });
-        if (variant.token.startsWith(':')) {
-            const firstSelectorNodes = branches.find((branch)=>branch.selectorNodes?.length)?.selectorNodes;
-            if (firstSelectorNodes?.length) selectors[variant.token] = firstSelectorNodes.map(cloneSelectorNode);
-        }
-        if (variant.token.startsWith('@')) {
-            const firstAtRule = branches.find((branch)=>branch.atRuleNodes?.length)?.atRuleNodes?.[0];
-            if (firstAtRule) {
-                atRules[variant.token.slice(1)] = cloneAtRule(firstAtRule);
-            } else {
-                const firstLayer = branches.find((branch)=>branch.layer)?.layer;
-                if (firstLayer) {
-                    atRules[variant.token.slice(1)] = {
-                        id: 'layer',
-                        nodes: [
-                            {
-                                type: 'string',
-                                value: firstLayer
-                            }
-                        ]
-                    };
-                }
-            }
-        }
-    }
-    return {
-        variants,
-        ...Object.keys(selectors).length ? {
-            selectors
-        } : {},
-        ...Object.keys(atRules).length ? {
-            atRules
-        } : {}
-    };
-}
-function cloneDeclarations(declarations) {
-    return Array.isArray(declarations) ? [
-        ...declarations
-    ] : {
-        ...declarations
-    };
-}
-function assertNoValuePlaceholder(declarations) {
-    for(const property in declarations){
-        if (declarations[property].includes('--value')) {
-            throw new Error('--value() is only supported inside managed pattern declarations');
-        }
-    }
-}
-function compileUtilityRule(rule) {
-    assertNoValuePlaceholder(rule.declarations);
-    return {
-        declarations: cloneDeclarations(rule.declarations),
-        ...rule.atRules?.length ? {
-            atRules: [
-                ...rule.atRules
-            ]
-        } : {},
-        ...rule.selector && rule.selector !== '&' ? {
-            selector: rule.selector
-        } : {}
-    };
-}
-const VALUE_PLACEHOLDER_FUNCTION = '--value()';
-const VALUE_PLACEHOLDER_CALL = /--value\s*\(([^)]*)\)/g;
-function compilePatternDeclarationValue(value) {
-    if (!value.includes('--value')) return value;
-    const parts = [];
-    let lastIndex = 0;
-    let matched = false;
-    VALUE_PLACEHOLDER_CALL.lastIndex = 0;
-    for (const match of value.matchAll(VALUE_PLACEHOLDER_CALL)){
-        matched = true;
-        if (match[1].trim()) {
-            throw new Error('--value() does not accept arguments');
-        }
-        if (match.index > lastIndex) parts.push(value.slice(lastIndex, match.index));
-        parts.push(null);
-        lastIndex = match.index + match[0].length;
-    }
-    if (!matched || value.slice(lastIndex).includes('--value')) {
-        throw new Error('--value() must be called as --value()');
-    }
-    if (lastIndex < value.length) parts.push(value.slice(lastIndex));
-    return value === VALUE_PLACEHOLDER_FUNCTION ? null : parts;
-}
-function compilePatternDeclarations(declarations) {
-    const compiled = {};
-    for(const property in declarations){
-        compiled[property] = compilePatternDeclarationValue(declarations[property]);
-    }
-    return compiled;
-}
-function compilePatternUtilityRule(rule) {
-    return {
-        declarations: compilePatternDeclarations(rule.declarations),
-        ...rule.atRules?.length ? {
-            atRules: [
-                ...rule.atRules
-            ]
-        } : {},
-        ...rule.selector && rule.selector !== '&' ? {
-            selector: rule.selector
-        } : {}
-    };
-}
-function declarationValueUsesPlaceholder(value) {
-    return value === null || Array.isArray(value) && value.includes(null);
-}
-function countValuePlaceholderProperties(declarations) {
-    let count = 0;
-    const declarationMap = declarations;
-    for(const property in declarationMap){
-        if (declarationValueUsesPlaceholder(declarationMap[property])) count++;
-    }
-    return count;
-}
-function utilityTypeFromRules(rules) {
-    return rules.some(({ declarations })=>{
-        const properties = Object.keys(declarations);
-        return properties.some((property)=>isNativeCSSShorthandProperty(property)) || countValuePlaceholderProperties(declarations) > 1;
-    }) ? UtilityType.Shorthand : UtilityType.Normal;
-}
-function getPatternMatcher(pattern) {
-    return {
-        type: 'pattern',
-        prefix: pattern.prefix,
-        values: [
-            ...pattern.values
-        ]
-    };
-}
-function getDynamicMatchers(dynamic) {
-    const matchers = [];
-    if (dynamic.variableAliasRefs?.length) {
-        matchers.push({
-            type: 'variable',
-            keys: [
-                dynamic.key
-            ]
-        });
-    }
-    if (dynamic.kind) {
-        matchers.push({
-            type: 'value',
-            keys: [
-                dynamic.key
-            ]
-        });
-    }
-    if (dynamic.arbitrary) {
-        matchers.push({
-            type: 'key',
-            keys: [
-                dynamic.key
-            ]
-        });
-    }
-    if (dynamic.values?.length) {
-        matchers.push({
-            type: 'pattern',
-            prefix: dynamic.key + ':',
-            values: [
-                ...dynamic.values
-            ]
-        });
-    }
-    if (!matchers.length) {
-        throw new Error('Managed dynamic utility definition must include at least one value source');
-    }
-    return matchers;
-}
-function compileUtility(definition, order) {
-    if (definition.type === 'pattern') {
-        if (!definition.pattern) {
-            throw new Error('Managed enum pattern definition is missing a pattern');
-        }
-        const rules = [];
-        if (definition.declarations) {
-            rules.push({
-                declarations: compilePatternDeclarations(definition.declarations),
-                ...definition.atRules?.length ? {
-                    atRules: [
-                        ...definition.atRules
-                    ]
-                } : {}
-            });
-        }
-        if (definition.rules?.length) {
-            rules.push(...definition.rules.map(compilePatternUtilityRule));
-        }
-        return {
-            id: definition.name,
-            name: definition.name,
-            type: UtilityType.Semantic,
-            order,
-            layer: definition.layer || 'utilities',
-            emit: {
-                type: 'static',
-                rules
-            },
-            matchers: [
-                getPatternMatcher(definition.pattern)
-            ]
-        };
-    }
-    if (definition.type === 'dynamic') {
-        if (!definition.dynamic) {
-            throw new Error('Managed dynamic utility definition is missing a dynamic source');
-        }
-        const rules = [];
-        if (definition.declarations) {
-            rules.push({
-                declarations: compilePatternDeclarations(definition.declarations),
-                ...definition.atRules?.length ? {
-                    atRules: [
-                        ...definition.atRules
-                    ]
-                } : {}
-            });
-        }
-        if (definition.rules?.length) {
-            rules.push(...definition.rules.map(compilePatternUtilityRule));
-        }
-        return {
-            id: definition.name,
-            name: definition.name,
-            type: utilityTypeFromRules(rules),
-            order,
-            layer: definition.layer || 'utilities',
-            ...definition.dynamic.kind ? {
-                kind: definition.dynamic.kind
-            } : {},
-            ...definition.dynamic.variableAliasRefs?.length ? {
-                variableAliasRefs: [
-                    ...definition.dynamic.variableAliasRefs
-                ]
-            } : {},
-            emit: {
-                type: 'static',
-                rules
-            },
-            matchers: getDynamicMatchers(definition.dynamic)
-        };
-    }
-    const name = definition.name.startsWith('.') ? definition.name.slice(1) : definition.name;
-    const rules = [];
-    if (definition.declarations) {
-        assertNoValuePlaceholder(definition.declarations);
-        rules.push({
-            declarations: cloneDeclarations(definition.declarations),
-            ...definition.atRules?.length ? {
-                atRules: [
-                    ...definition.atRules
-                ]
-            } : {}
-        });
-    }
-    if (definition.rules?.length) {
-        rules.push(...definition.rules.map(compileUtilityRule));
-    }
-    return {
-        id: '.' + name,
-        name,
-        type: UtilityType.Semantic,
-        order,
-        layer: definition.layer || 'utilities',
-        emit: {
-            type: 'static',
-            rules
-        },
-        matchers: [
-            {
-                type: 'static',
-                name
-            }
-        ]
-    };
-}
-function compileUtilities(input) {
-    if (!input?.length) return;
-    return input.map((definition, index)=>compileUtility(definition, index));
-}
-function compileAnimations(input) {
-    return input ? clone(input) : undefined;
-}
-function compileAnimationOptions(input) {
-    return input ? clone(input) : undefined;
-}
-function mergeBy(base, next, getKey) {
-    const merged = [
-        ...(base || []).map((value)=>clone(value))
-    ];
-    for (const value of next || []){
-        const key = getKey(value);
-        const index = key === undefined ? -1 : merged.findIndex((existing)=>getKey(existing) === key);
-        if (index === -1) {
-            merged.push(clone(value));
-        } else {
-            merged[index] = clone(value);
-        }
-    }
-    return merged.length ? merged : undefined;
-}
-function mergeVariables(base, next) {
-    const merged = mergeBy(flattenMasterCSSManifestVariables(base), flattenMasterCSSManifestVariables(next), (variable)=>variable.name);
-    return groupMasterCSSManifestVariables(merged);
-}
-function mergeRecords(base, next) {
-    return Object.keys(base || {}).length || Object.keys(next || {}).length ? {
-        ...base ? clone(base) : {},
-        ...next ? clone(next) : {}
-    } : undefined;
-}
-function mergeAnimationOptions(base, next, animations) {
-    const merged = mergeRecords(base, next);
-    if (!merged) return;
-    for (const animationName of Object.keys(animations || {})){
-        if (!next?.[animationName]) {
-            delete merged[animationName];
-        }
-    }
-    return Object.keys(merged).length ? merged : undefined;
-}
-function mergeManifest(baseManifest, fragment) {
-    if (!baseManifest) {
-        return clone(fragment);
-    }
-    const manifest = {
-        version: 1,
-        settings: {
-            ...baseManifest.settings || {},
-            ...fragment.settings || {}
-        },
-        variables: mergeVariables(baseManifest.variables, fragment.variables),
-        animations: mergeRecords(baseManifest.animations, fragment.animations),
-        animationOptions: mergeAnimationOptions(baseManifest.animationOptions, fragment.animationOptions, fragment.animations),
-        variants: mergeBy(baseManifest.variants, fragment.variants, (variant)=>variant.token),
-        atRules: mergeRecords(baseManifest.atRules, fragment.atRules),
-        breakpointAtRules: mergeRecords(baseManifest.breakpointAtRules, fragment.breakpointAtRules),
-        containerAtRules: mergeRecords(baseManifest.containerAtRules, fragment.containerAtRules),
-        selectors: mergeRecords(baseManifest.selectors, fragment.selectors),
-        utilities: mergeBy(baseManifest.utilities, fragment.utilities, (utility)=>`${utility.id}\0${utility.layer || ''}`),
-        debug: mergeRecords(baseManifest.debug, fragment.debug)
-    };
-    return Object.fromEntries(Object.entries(manifest).filter(([, value])=>value !== undefined && (!Array.isArray(value) || value.length) && (typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length)));
-}
-function createMasterCSSManifest(input = {}, options = {}) {
-    const rootSize = input.rootSize ?? options.baseManifest?.settings?.rootSize ?? 16;
-    const resolveVariableName = createVariableNameResolver(input, options);
-    const variableDefinitions = compileVariables(input.variables, resolveVariableName);
-    const variables = groupMasterCSSManifestVariables(variableDefinitions);
-    const { atRules, breakpointAtRules, containerAtRules } = compileAtRules(variableDefinitions, rootSize);
-    const settings = {
-        ...input.rootSize !== undefined ? {
-            rootSize: input.rootSize
-        } : {},
-        ...input.baseUnit !== undefined ? {
-            baseUnit: input.baseUnit
-        } : {},
-        ...input.defaultMode !== undefined ? {
-            defaultMode: input.defaultMode
-        } : {},
-        ...input.scope !== undefined ? {
-            scope: input.scope
-        } : {},
-        ...input.important !== undefined ? {
-            important: input.important
-        } : {},
-        ...input.modeTrigger !== undefined ? {
-            modeTrigger: input.modeTrigger
-        } : {},
-        ...input.modes?.length ? {
-            modes: [
-                ...input.modes
-            ]
-        } : {}
-    };
-    const variantBaseManifest = mergeManifest(options.baseManifest, {
-        version: 1,
-        ...Object.keys(settings).length ? {
-            settings
-        } : {},
-        ...variables ? {
-            variables
-        } : {},
-        ...atRules ? {
-            atRules
-        } : {},
-        ...breakpointAtRules ? {
-            breakpointAtRules
-        } : {},
-        ...containerAtRules ? {
-            containerAtRules
-        } : {}
-    });
-    const { variants, selectors, atRules: variantAtRules } = compileVariants(input.variants, variantBaseManifest);
-    const utilities = compileUtilities(input.utilities);
-    const animations = compileAnimations(input.animations);
-    const animationOptions = compileAnimationOptions(input.animationOptions);
-    const fragment = {
-        version: 1,
-        ...Object.keys(settings).length ? {
-            settings
-        } : {},
-        ...variables ? {
-            variables
-        } : {},
-        ...animations ? {
-            animations
-        } : {},
-        ...animationOptions ? {
-            animationOptions
-        } : {},
-        ...variants?.length ? {
-            variants
-        } : {},
-        ...atRules || variantAtRules ? {
-            atRules: mergeRecords(atRules, variantAtRules)
-        } : {},
-        ...breakpointAtRules ? {
-            breakpointAtRules
-        } : {},
-        ...containerAtRules ? {
-            containerAtRules
-        } : {},
-        ...selectors ? {
-            selectors
-        } : {},
-        ...utilities?.length ? {
-            utilities
-        } : {}
-    };
-    return mergeManifest(options.baseManifest, fragment);
-}
-
-export { createMasterCSSManifest, createVariableNameResolver };