zyzz 0.0.28 → 0.0.29

package/dist/compiler/internal/Contract.js

@@ -1,753 +0,0 @@
-import * as Config from '../../internal/Configuration.js';
-import * as Configurations from './Configurations.js';
-import * as FunctionSyntax from '../../internal/FunctionSyntax.js';
-import * as Identifiers from './Identifiers.js';
-import * as PackedStyles from './PackedStyles.js';
-import * as Shorthands from '../../internal/Shorthands.js';
-import * as Stylesheets from './Stylesheets.js';
-import * as Theme from '../../internal/Theme.js';
-import * as VariableSets from '../../internal/VariableSets.js';
-import * as Vars from '../../Vars.js';
-import * as Token from '../../internal/Token.js';
-/** Reads versioned JSON as validated data; never evaluates package code. */
-export function read(source, identities, moduleId = '') {
-    const data = record(JSON.parse(source));
-    if (![
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-        22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
-    ].includes(data.version))
-        throw new Error('Unsupported Zyzz contract version.');
-    // Root controls arrived with version 18; older readers must treat them as absent.
-    const rootControls = data.version >= 18;
-    const legacyModes = new Map();
-    if (data.version < 17) {
-        function collect(value) {
-            const entry = record(value);
-            if (entry.options !== undefined && entry.theme !== undefined) {
-                const options = record(entry.options);
-                if (options.cssOutput !== undefined) {
-                    if (options.cssOutput !== 'atomic' && options.cssOutput !== 'grouped')
-                        throw new Error('Invalid packed CSS output mode.');
-                    const theme = record(record(data.themes)[string(entry.theme)]);
-                    const identity = string(theme.identity);
-                    const previous = legacyModes.get(identity);
-                    if (previous !== undefined && previous !== options.cssOutput)
-                        throw new Error('Conflicting packed CSS output modes for one theme identity.');
-                    legacyModes.set(identity, options.cssOutput);
-                }
-            }
-            for (const member of Object.values(record(entry.members ?? {})))
-                collect(member);
-        }
-        for (const entry of Object.values(record(data.exports)))
-            collect(entry);
-    }
-    function validateVariables(entry) {
-        if (data.version < 31 || entry.variableNaming !== undefined)
-            throw new Error('Legacy packed variable names are unsupported. Rebuild the library with the current version of Zyzz.');
-    }
-    function decode(value) {
-        if (!value || typeof value !== 'object')
-            return value;
-        if (Array.isArray(value))
-            return value.map(decode);
-        const fields = record(value);
-        if (Object.hasOwn(fields, '$object'))
-            return Object.fromEntries(Object.entries(record(fields.$object)).map(([key, value]) => [
-                key,
-                decode(value),
-            ]));
-        if (Object.hasOwn(fields, '$composition')) {
-            if (data.version < 29)
-                throw new Error('Composed variables require contract version 29 or later.');
-            const composition = record(fields.$composition);
-            if ((composition.group !== 'color' && composition.group !== 'spacing') ||
-                !Array.isArray(composition.parts))
-                throw new Error('Invalid packed variable composition.');
-            return Vars.compose(composition.group, composition.parts.map(decode));
-        }
-        if (Object.hasOwn(fields, '$variable')) {
-            const reference = record(fields.$variable);
-            const identity = string(reference.identity);
-            validateVariables(reference);
-            let contract = identities.get(identity);
-            if (contract && !contract.variableSet)
-                throw new Error('Conflicting packed variable-set modes for one identity.');
-            if (!contract) {
-                contract = Object.freeze({
-                    variableSet: true,
-                    [Token.identity]: identity,
-                });
-                identities.set(identity, contract);
-            }
-            const resolved = decode(reference.value);
-            return Token.create({
-                contract,
-                group: VariableSets.domain(resolved),
-                path: string(reference.path),
-                value: resolved,
-            });
-        }
-        return Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, decode(value)]));
-    }
-    const themes = Object.create(null);
-    const types = Object.create(null);
-    for (const [name, value] of Object.entries(record(data.themes))) {
-        const entry = record(value);
-        const identity = string(entry.identity);
-        if (Object.keys(record(entry.tokens)).length ||
-            entry.variableNaming !== undefined)
-            validateVariables(entry);
-        if (entry.variableSet === true && data.version < 28)
-            throw new Error('Vars contracts require contract version 28 or later.');
-        const mappings = VariableSets.mappings(entry.mappings);
-        if (entry.cssOutput !== undefined &&
-            entry.cssOutput !== 'atomic' &&
-            entry.cssOutput !== 'grouped')
-            throw new Error('Invalid packed CSS output mode.');
-        const cssOutput = (entry.cssOutput ?? legacyModes.get(identity));
-        if (entry.composition !== undefined) {
-            if (data.version < 34)
-                throw new Error('Composition modes require contract version 34 or later.');
-            if (entry.composition !== 'independent' &&
-                entry.composition !== 'ordered')
-                throw new Error('Invalid packed composition mode.');
-        }
-        const composition = entry.composition;
-        if (entry.defaultLayer !== undefined) {
-            if (data.version < 27)
-                throw new Error('Default layers require contract version 27 or later.');
-            Config.create({ defaultLayer: entry.defaultLayer });
-        }
-        const defaultLayer = entry.defaultLayer;
-        const shorthands = entry.shorthands !== undefined
-            ? Shorthands.read(entry.shorthands)
-            : undefined;
-        let contract = identities.get(identity);
-        if (contract &&
-            Boolean(contract.variableSet) !== (entry.variableSet === true))
-            throw new Error('Conflicting packed variable-set modes for one identity.');
-        if (contract &&
-            JSON.stringify(contract.mappings ?? {}) !== JSON.stringify(mappings ?? {}))
-            throw new Error('Conflicting packed variable mappings for one identity.');
-        if (contract &&
-            Shorthands.signature(contract.shorthands) !==
-                Shorthands.signature(shorthands))
-            throw new Error('Conflicting packed shorthand mappings for one theme identity.');
-        if (contract &&
-            (contract.composition ?? 'ordered') !== (composition ?? 'ordered'))
-            throw new Error('Conflicting packed composition modes for one theme identity.');
-        if (contract &&
-            (contract.cssOutput ?? 'atomic') !== (cssOutput ?? 'atomic'))
-            throw new Error('Conflicting packed CSS output modes for one theme identity.');
-        if (contract && contract.defaultLayer !== defaultLayer)
-            throw new Error('Conflicting packed default layers for one theme identity.');
-        if (!contract) {
-            contract = Object.freeze({
-                ...(entry.variableSet === true
-                    ? {
-                        variableSet: true,
-                        mappings,
-                    }
-                    : {}),
-                ...(entry.shorthands !== undefined
-                    ? { shorthands: Shorthands.read(entry.shorthands) }
-                    : {}),
-                ...(composition ? { composition } : {}),
-                ...(cssOutput ? { cssOutput } : {}),
-                ...(defaultLayer !== undefined ? { defaultLayer } : {}),
-                [Token.complete]: true,
-                [Token.identity]: identity,
-            });
-            identities.set(identity, contract);
-        }
-        const definition = entry.variableSet === true
-            ? VariableSets.theme(Vars.define(decode(entry.tokens)), mappings)
-            : Theme.define(record(entry.tokens));
-        if (data.version < 24 &&
-            Object.hasOwn(definition.tokens, 'typography'))
-            throw new Error('Packed typography sets require contract version 24 or later.');
-        if (data.version < 25 &&
-            (definition[Token.definition].paths ||
-                Object.hasOwn(definition.tokens, 'borderWidth')))
-            throw new Error('Packed responsive typography and border widths require contract version 25 or later.');
-        themes[name] = Token.bind(definition, contract, entry.cssName === undefined ? undefined : string(entry.cssName));
-        types[name] = type(input(definition));
-    }
-    function link(value) {
-        const raw = record(value);
-        if (raw.nativeProvider !== undefined && data.version < 32)
-            throw new Error('Native providers require contract version 32 or later.');
-        // Contracts before version 19 record style authoring exports as `css`.
-        const entry = raw.kind === 'css' && data.version < 19
-            ? { ...raw, kind: 'style' }
-            : raw;
-        if (entry.kind === 'variables') {
-            if (data.version < 14)
-                throw new Error('Legacy variable contracts require recompilation with variable().');
-            const names = new Set();
-            const slots = Object.fromEntries(Object.entries(record(entry.variables)).map(([key, value]) => {
-                const slot = record(value);
-                if (key === 'set' ||
-                    key === '__proto__' ||
-                    names.has(string(slot.name)) ||
-                    !/^--z-[a-zA-Z0-9_-]+$/.test(string(slot.name)) ||
-                    ![
-                        '*',
-                        'color',
-                        'length',
-                        'number',
-                        'percentage',
-                        'signedLength',
-                        'signedPercentage',
-                    ].includes(String(slot.type)))
-                    throw new Error('Invalid packed variable contract.');
-                names.add(string(slot.name));
-                return [
-                    key,
-                    Object.freeze({
-                        name: slot.name,
-                        type: slot.type,
-                        variable: true,
-                    }),
-                ];
-            }));
-            const binding = string(entry.binding);
-            return {
-                binding,
-                kind: 'variables',
-                ...(entry.members
-                    ? {
-                        members: Object.fromEntries(Object.entries(record(entry.members)).map(([name, value]) => [
-                            name,
-                            link(value),
-                        ])),
-                    }
-                    : {}),
-                definition: Theme.define({}),
-                call: {
-                    start: -1,
-                    end: -1,
-                    name: binding,
-                    tokenType: '{}',
-                    variables: Object.freeze(slots),
-                    ...(entry.source !== undefined
-                        ? {
-                            variableOwner: Stylesheets.resolve(moduleId, string(entry.source)),
-                        }
-                        : {}),
-                },
-            };
-        }
-        if (entry.kind === 'rule-reference') {
-            const name = string(entry.name);
-            const reference = string(entry.reference);
-            if (![
-                9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
-                27, 28, 29, 30, 31, 32, 33, 34,
-            ].includes(data.version) ||
-                ![
-                    'cssFunction',
-                    'customMedia',
-                    'colorProfile',
-                    'counterStyle',
-                    'fontPaletteValues',
-                    'positionTry',
-                ].includes(reference) ||
-                !/^(?:--)?z-[a-zA-Z0-9_-]+$/.test(name) ||
-                !name.startsWith(`${reference === 'counterStyle' ? '' : '--'}z-${reference.toLowerCase()}`) ||
-                entry.binding !== name)
-                throw new Error('Invalid named stylesheet identity.');
-            return {
-                binding: string(entry.binding),
-                kind: 'rule-reference',
-                definition: Theme.define({}),
-                call: {
-                    start: -1,
-                    end: -1,
-                    name,
-                    tokenType: '{}',
-                    reference: reference,
-                    ...(reference === 'cssFunction'
-                        ? { function: signature(entry.function, data.version) }
-                        : {}),
-                },
-            };
-        }
-        if (entry.kind === 'animation') {
-            const name = string(entry.name);
-            if (!/^z-k[a-zA-Z0-9_-]+$/.test(name))
-                throw new Error('Invalid animation identity.');
-            return {
-                binding: string(entry.binding),
-                kind: 'animation',
-                definition: Theme.define({}),
-                call: { start: -1, end: -1, name, tokenType: '{}' },
-            };
-        }
-        if (entry.kind === 'style-reference') {
-            if (entry.style !== undefined && data.version < 16)
-                throw new Error('Packed callable styles require contract version 16 or later.');
-            const binding = string(entry.binding);
-            if (!/^z-style-[a-zA-Z0-9_-]+$/.test(binding))
-                throw new Error('Invalid style reference identity.');
-            const members = entry.members === undefined
-                ? undefined
-                : Object.fromEntries(Object.entries(record(entry.members)).map(([key, value]) => {
-                    const member = link(value);
-                    if (member.kind !== 'style-reference' ||
-                        (member.members && data.version < 22))
-                        throw new Error('Invalid style reference member.');
-                    return [key, member];
-                }));
-            const nativeContext = (() => {
-                if (entry.nativeContext === undefined)
-                    return undefined;
-                if (data.version < 33)
-                    throw new Error('Native style catalogs require contract version 33 or later.');
-                if (entry.style === undefined)
-                    throw new Error('Native style catalogs require a packed style.');
-                const context = record(entry.nativeContext);
-                const vars = Object.fromEntries(Object.entries(record(context.vars)).map((entry) => {
-                    const [name, value] = entry;
-                    const theme = themes[string(value)];
-                    if (!name || !theme)
-                        throw new Error('Unknown packed native style catalog.');
-                    return [name, theme];
-                }));
-                const defaultVars = string(context.defaultVars);
-                if (!Object.hasOwn(vars, defaultVars))
-                    throw new Error('Invalid packed native style default.');
-                const identities = new Set(Object.values(vars).map((theme) => theme[Token.definition].contract));
-                if (identities.size !== 1)
-                    throw new Error('Incompatible packed native style catalog.');
-                return { defaultVars, vars };
-            })();
-            return {
-                binding,
-                call: {
-                    start: -1,
-                    end: -1,
-                    name: members ? '' : binding,
-                    tokenType: '{}',
-                },
-                definition: Theme.define({}),
-                kind: 'style-reference',
-                ...(entry.style === undefined
-                    ? {}
-                    : {
-                        style: {
-                            ...PackedStyles.read(entry.style, themes, data.version),
-                            ...(nativeContext ? { nativeContext } : {}),
-                        },
-                    }),
-                ...(members ? { members } : {}),
-            };
-        }
-        if (entry.output !== undefined && entry.output !== 'html')
-            throw new Error('Invalid theme output.');
-        if (entry.recipe !== undefined &&
-            (entry.recipe !== true ||
-                data.version < 15 ||
-                entry.kind !== 'style'))
-            throw new Error('Invalid bound recipe contract.');
-        const theme = string(entry.theme);
-        const definition = themes[theme];
-        if (!definition ||
-            !['config', 'style', 'theme'].includes(String(entry.kind)))
-            throw new Error('Invalid Zyzz contract export.');
-        const members = entry.kind === 'config'
-            ? Object.fromEntries(Object.entries(record(entry.members)).map(([key, value]) => [
-                key,
-                link(value),
-            ]))
-            : undefined;
-        const options = entry.options === undefined ? undefined : record(decode(entry.options));
-        if (options) {
-            if (entry.variableConfig === true &&
-                JSON.stringify(VariableSets.mappings(entry.variableMappings) ?? {}) !==
-                    JSON.stringify(definition[Token.definition].contract.mappings ?? {}))
-                throw new Error('Configuration mappings disagree with linked variable metadata.');
-            if (entry.variableConfig === true)
-                Config.create(variableOptions(options, entry.variableMappings));
-            else
-                Config.create(options);
-            if (data.version >= 17 &&
-                (options.cssOutput ?? 'atomic') !==
-                    (definition[Token.definition].contract.cssOutput ?? 'atomic'))
-                throw new Error('Configuration CSS output disagrees with linked theme metadata.');
-            if ((options.composition ?? 'ordered') !==
-                (definition[Token.definition].contract.composition ?? 'ordered'))
-                throw new Error('Configuration composition disagrees with linked theme metadata.');
-            if (options.defaultLayer !==
-                definition[Token.definition].contract.defaultLayer)
-                throw new Error('Configuration default layer disagrees with linked theme metadata.');
-            if (Shorthands.signature(options.shorthands) !==
-                Shorthands.signature(definition[Token.definition].contract.shorthands))
-                throw new Error('Configuration mappings disagree with linked theme metadata.');
-        }
-        const catalogOnly = !!options?.themes &&
-            (data.version < 4 || entry.catalogOnly === true);
-        const fullConfigType = options
-            ? entry.nativeProvider === true
-                ? `import('zyzz/react-native/react').defineConfig.ReturnType<${Configurations.type(entry.variableConfig === true ? variableOptions(options, entry.variableMappings) : options)}>`
-                : entry.variableConfig === true
-                    ? `import('zyzz').Config.VariableConfig<${Configurations.type(variableOptions(options, entry.variableMappings))}>`
-                    : `import('zyzz').Config.create.ReturnType<${Configurations.type(options)}>`
-            : '';
-        // Helpers a legacy library did not compile are hidden from its consumers' types.
-        const hidden = [
-            ...(rootControls && entry.appearance === true ? [] : ["'appearance'"]),
-            ...(entry.script === true ? [] : ["'script'"]),
-        ];
-        const configType = hidden.length
-            ? `{readonly [key in keyof ${fullConfigType} as key extends ${hidden.join(' | ')} ? never : key]:${fullConfigType}[key]}`
-            : fullConfigType;
-        const outputType = catalogOnly
-            ? `({readonly [key in keyof ${configType} as key extends 'themes' ? never : key]:${configType}[key]} & {readonly themes:{readonly [key in keyof ${configType}['themes']]:${configType}['themes'][key]}})`
-            : configType;
-        if (entry.kind === 'config' && !options)
-            throw new Error('Missing configuration options.');
-        return {
-            binding: string(entry.binding),
-            call: {
-                ...(entry.nativeProvider === true ? { nativeProvider: true } : {}),
-                ...(entry.variableSet === true
-                    ? {
-                        variableSet: true,
-                        type: `import('zyzz').Vars.Definition<${types[theme]}>`,
-                    }
-                    : {}),
-                ...(entry.directVariables === true
-                    ? {
-                        directVariables: true,
-                        type: `import('zyzz').Vars.${entry.variableSet === true ? 'Definition' : 'References'}<${types[theme]}>`,
-                    }
-                    : {}),
-                ...(entry.variableConfig === true
-                    ? {
-                        variableConfig: true,
-                        variableMappings: entry.variableMappings,
-                    }
-                    : {}),
-                ...(entry.recipe === true ? { recipe: true } : {}),
-                ...(entry.output === 'html' ? { output: 'html' } : {}),
-                ...(catalogOnly ? { catalogOnly: true } : {}),
-                ...(entry.script === true ? { script: true } : {}),
-                ...(rootControls && entry.appearance === true
-                    ? { appearance: true }
-                    : {}),
-                ...(rootControls && entry.root === true ? { root: true } : {}),
-                end: -1,
-                name: theme,
-                start: -1,
-                tokenType: types[theme],
-                ...(definition[Token.definition].contract.shorthands ||
-                    entry.output === 'html'
-                    ? {
-                        type: `import('zyzz').Config.create.ReturnType<{theme:${types[theme]};${entry.output === 'html' ? "output:'html';" : ''}shorthands:${Configurations.type(definition[Token.definition].contract.shorthands ?? {})}}>['theme']`,
-                    }
-                    : {}),
-                ...(entry.selection === true ? { selection: true } : {}),
-                ...(entry.initialization === true ? { initialization: true } : {}),
-                ...(options
-                    ? {
-                        options,
-                        type: `${outputType}${entry.initialization === true ? "['script']" : entry.root === true ? "['appearance']" : entry.selection === true ? (entry.variableConfig === true ? "['vars']" : "['themes']") : ''}`,
-                    }
-                    : {}),
-                ...(members
-                    ? {
-                        members: Object.fromEntries(Object.entries(members).map(([key, member]) => [
-                            key,
-                            member.call.name,
-                        ])),
-                    }
-                    : {}),
-            },
-            definition,
-            kind: entry.kind,
-            ...(members ? { members } : {}),
-        };
-    }
-    const links = Object.fromEntries(Object.entries(record(data.exports)).map(([name, value]) => [
-        name,
-        link(value),
-    ]));
-    const classRules = Object.fromEntries(Object.entries(data.classRules === undefined ? {} : record(data.classRules)).map(([name, body]) => {
-        if (!name || /\s/.test(name))
-            throw new Error('Invalid packed class name.');
-        return [name, string(body)];
-    }));
-    return {
-        classRules,
-        links,
-        themes,
-        stylesheets: Stylesheets.read(data.stylesheets),
-    };
-}
-function record(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new Error('Expected a Zyzz contract record.');
-    return value;
-}
-function string(value) {
-    if (typeof value !== 'string' || !value)
-        throw new Error('Expected a nonempty Zyzz contract identity.');
-    return value;
-}
-function input(theme) {
-    return { ...tokens(theme.tokens), ...theme[Token.definition].queries };
-}
-function tokens(tree) {
-    return Object.fromEntries(Object.entries(tree).map(([name, value]) => [
-        name,
-        Token.is(value)
-            ? value.value
-            : tokens(value),
-    ]));
-}
-function type(value) {
-    if (Token.is(value) || Token.isExpression(value))
-        return Configurations.type(value);
-    if (Array.isArray(value))
-        return `readonly [${value.map(type).join(',')}]`;
-    if (!value || typeof value !== 'object')
-        return JSON.stringify(value);
-    return `{${Object.entries(value)
-        .map(([key, value]) => `readonly ${JSON.stringify(key)}:${type(value)}`)
-        .join(';')}}`;
-}
-/** Emits compiler-only metadata without adding it to the runtime module. */
-export function write(links, themes, stylesheets = [], moduleId = '', configurations = [], classRules = {}) {
-    function entry(link) {
-        if (link.kind === 'variables')
-            return {
-                binding: link.binding,
-                kind: link.kind,
-                variables: link.call.variables,
-                ...(link.members
-                    ? {
-                        members: Object.fromEntries(Object.entries(link.members).map(([name, member]) => [
-                            name,
-                            entry(member),
-                        ])),
-                    }
-                    : {}),
-                ...(link.call.variableOwner
-                    ? { source: Stylesheets.relative(moduleId, link.call.variableOwner) }
-                    : {}),
-            };
-        if (link.kind === 'rule-reference')
-            return {
-                binding: link.binding,
-                kind: link.kind,
-                name: link.call.name,
-                reference: link.call.reference,
-                ...(link.call.function ? { function: link.call.function } : {}),
-            };
-        if (link.kind === 'animation')
-            return { binding: link.binding, kind: link.kind, name: link.call.name };
-        if (link.kind === 'style-reference')
-            return {
-                binding: link.binding,
-                kind: link.kind,
-                ...(link.style?.nativeContext
-                    ? {
-                        nativeContext: {
-                            defaultVars: link.style.nativeContext.defaultVars,
-                            vars: Object.fromEntries(Object.entries(link.style.nativeContext.vars).map((entry) => {
-                                const [name, definition] = entry;
-                                const theme = Object.entries(themes).find((candidate) => candidate[1][Token.definition].contract ===
-                                    definition[Token.definition].contract &&
-                                    JSON.stringify(input(candidate[1])) ===
-                                        JSON.stringify(input(definition)));
-                                if (!theme)
-                                    throw new Error('Missing packed native style catalog.');
-                                return [name, theme[0]];
-                            })),
-                        },
-                    }
-                    : {}),
-                ...(link.style ? { style: PackedStyles.write(link.style) } : {}),
-                ...(link.members
-                    ? {
-                        members: Object.fromEntries(Object.entries(link.members).map(([name, value]) => [
-                            name,
-                            entry(value),
-                        ])),
-                    }
-                    : {}),
-            };
-        return {
-            ...(link.call.variableSet ? { variableSet: true } : {}),
-            ...(link.call.nativeProvider ? { nativeProvider: true } : {}),
-            ...(link.call.directVariables ? { directVariables: true } : {}),
-            ...(link.call.variableConfig
-                ? { variableConfig: true, variableMappings: link.call.variableMappings }
-                : {}),
-            ...(link.call.recipe ? { recipe: true } : {}),
-            ...(link.call.output ? { output: link.call.output } : {}),
-            ...(link.call.script &&
-                (link.kind === 'config' || link.call.initialization)
-                ? { script: true }
-                : {}),
-            ...(link.call.appearance && (link.kind === 'config' || link.call.root)
-                ? { appearance: true }
-                : {}),
-            binding: link.binding,
-            kind: link.kind,
-            theme: link.call.name,
-            ...(link.call.catalogOnly ? { catalogOnly: true } : {}),
-            ...(link.call.selection ? { selection: true } : {}),
-            ...(link.call.initialization ? { initialization: true } : {}),
-            ...(link.call.root ? { root: true } : {}),
-            ...(link.call.options ? { options: encode(link.call.options) } : {}),
-            ...(link.members
-                ? {
-                    members: Object.fromEntries(Object.entries(link.members).map(([key, link]) => [
-                        key,
-                        entry(link),
-                    ])),
-                }
-                : {}),
-        };
-    }
-    return JSON.stringify({
-        ...(Object.keys(classRules).length ? { classRules } : {}),
-        ...(stylesheets.length
-            ? { stylesheets: Stylesheets.write(stylesheets) }
-            : {}),
-        // Local configurations publish their catalogs so documents restore
-        // selections for modules that export styles but not the configuration.
-        ...(configurations.length ? { configurations } : {}),
-        exports: Object.fromEntries(Object.entries(links).map(([name, link]) => [name, entry(link)])),
-        themes: Object.fromEntries(Object.entries(themes).map(([name, theme]) => [
-            name,
-            {
-                ...(theme[Token.definition].cssName !== undefined
-                    ? { cssName: theme[Token.definition].cssName }
-                    : {}),
-                ...(theme[Token.definition].contract.shorthands
-                    ? { shorthands: theme[Token.definition].contract.shorthands }
-                    : {}),
-                ...(theme[Token.definition].contract.defaultLayer !== undefined
-                    ? { defaultLayer: theme[Token.definition].contract.defaultLayer }
-                    : {}),
-                ...(theme[Token.definition].contract.composition
-                    ? { composition: theme[Token.definition].contract.composition }
-                    : {}),
-                ...(theme[Token.definition].contract.cssOutput
-                    ? { cssOutput: theme[Token.definition].contract.cssOutput }
-                    : {}),
-                ...(theme[Token.definition].contract.variableSet
-                    ? {
-                        variableSet: true,
-                        mappings: theme[Token.definition].contract.mappings,
-                    }
-                    : {}),
-                identity: theme[Token.definition].contract[Token.identity],
-                tokens: encode(input(theme)),
-            },
-        ])),
-        version: (() => {
-            if (Object.values(themes).some((theme) => theme[Token.definition].contract.composition) ||
-                Object.values(links).some(composed))
-                return 34;
-            if (Object.values(links).some(nativeCatalog))
-                return 33;
-            if (Object.values(links).some(nativeProvider))
-                return 32;
-            return 31;
-        })(),
-    });
-    function composed(link) {
-        return (Boolean(link.style?.style.composition) ||
-            Object.values(link.members ?? {}).some(composed));
-    }
-    function nativeProvider(link) {
-        return (link.call.nativeProvider === true ||
-            Object.values(link.members ?? {}).some(nativeProvider));
-    }
-    function nativeCatalog(link) {
-        return (Boolean(link.style?.nativeContext) ||
-            Object.values(link.members ?? {}).some(nativeCatalog));
-    }
-}
-function signature(input, version) {
-    const value = record(input);
-    if (!FunctionSyntax.accepts(string(value.returns)) ||
-        !Array.isArray(value.parameters))
-        throw new Error('Invalid packed CSS function signature.');
-    if (version < 12 &&
-        (/[\\\u0080-\uffff]/.test(String(value.returns)) ||
-            value.parameters.some((input) => {
-                const parameter = record(input);
-                return /[\\\u0080-\uffff]/.test(string(parameter.name) + string(parameter.syntax ?? '*'));
-            })))
-        throw new Error('Extended CSS function signatures require contract version 12.');
-    const names = new Set();
-    const parameters = value.parameters.map((input) => {
-        const parameter = record(input);
-        const name = string(parameter.name);
-        if (!Identifiers.read(name)?.startsWith('--') ||
-            Identifiers.read(name) === '--' ||
-            names.has(Identifiers.read(name)) ||
-            (parameter.syntax !== undefined &&
-                !FunctionSyntax.accepts(string(parameter.syntax))) ||
-            (parameter.default !== undefined &&
-                typeof parameter.default !== 'number' &&
-                typeof parameter.default !== 'string'))
-            throw new Error('Invalid packed CSS function parameter.');
-        names.add(Identifiers.read(name));
-        return {
-            name: name,
-            ...(parameter.syntax !== undefined
-                ? {
-                    syntax: parameter.syntax,
-                }
-                : {}),
-            ...(parameter.default !== undefined
-                ? { default: parameter.default }
-                : {}),
-        };
-    });
-    return {
-        parameters,
-        returns: value.returns,
-    };
-}
-function encode(value) {
-    if (Token.isExpression(value) && 'group' in value)
-        return {
-            $composition: { group: value.group, parts: value.parts.map(encode) },
-        };
-    if (Token.is(value))
-        return {
-            $variable: {
-                identity: value.contract[Token.identity],
-                path: value.path,
-                value: encode(value.value),
-            },
-        };
-    if (Array.isArray(value))
-        return value.map(encode);
-    if (!value || typeof value !== 'object')
-        return value;
-    const fields = Object.fromEntries(Object.entries(value).map(([key, value]) => [key, encode(value)]));
-    return Object.hasOwn(fields, '$composition') ||
-        Object.hasOwn(fields, '$variable') ||
-        Object.hasOwn(fields, '$object')
-        ? { $object: fields }
-        : fields;
-}
-function variableOptions(options, mappings) {
-    const { theme, themes, defaultTheme, ...rest } = options;
-    return {
-        ...rest,
-        vars: (themes ?? theme),
-        ...(themes ? { defaultVars: String(defaultTheme) } : {}),
-        ...(mappings !== undefined ? { mappings } : {}),
-    };
-}
-//# sourceMappingURL=Contract.js.map