zyzz 0.0.28 → 0.0.30

package/dist/compiler/internal/Wire.js

@@ -0,0 +1,795 @@
+/**
+ * Decodes Rust `source.extract` results into the frozen data `Source.extract` returns.
+ * The format is documented in `crates/compiler/src/compiler/internal/wire.rs`.
+ * @module
+ */
+import * as Authoring from '../../internal/Authoring.js';
+import * as Binding from '../../internal/Binding.js';
+import * as ClassName from '../../web/internal/ClassName.js';
+import * as Configuration from '../../internal/Configuration.js';
+import * as Identity from '../../internal/Identity.js';
+import { MissingTransformError } from '../../styleFunction.js';
+import * as Source from '../Source.js';
+import * as Style from '../../Style.js';
+import * as Theme from '../../internal/Theme.js';
+import * as Token from '../../internal/Token.js';
+import * as Vars from '../../Vars.js';
+/**
+ * Decodes one extraction result, or throws the error the extraction failed with.
+ * @param text - JSON text returned by the `source.extract` operation.
+ * @returns Frozen calls, styles, theme data, and contributions.
+ * @throws {Source.ExtractError} With every source diagnostic of a failed extraction.
+ */
+export function decode(text, options = {}) {
+    const output = JSON.parse(text);
+    if (output.error)
+        throw failure(output.error);
+    const contracts = (output.contracts ?? []).map(contract);
+    const decoder = create(contracts, options);
+    return decoder.result(output.result ?? {});
+}
+/** Reconstructs the error class a TypeScript extraction throws. */
+function failure(error) {
+    switch (error.name) {
+        case 'Source.ExtractError':
+            return new Source.ExtractError((error.diagnostics ?? []).map((diagnostic) => Object.freeze({
+                code: diagnostic.code,
+                end: diagnostic.end,
+                message: diagnostic.message,
+                source: diagnostic.source,
+                start: diagnostic.start,
+            })));
+        case 'Config.InvalidError':
+            return new Configuration.InvalidError(error.message);
+        case 'Theme.InvalidError':
+            return new Theme.InvalidError(error.path ?? [], error.reason ?? error.message);
+        case 'Vars.InvalidError':
+            return new Vars.InvalidError(error.path ?? [], error.reason ?? error.message);
+        case 'Style.InvalidError':
+            return new Style.InvalidError((error.diagnostics ?? []).map((diagnostic) => {
+                const location = diagnostic.location;
+                return Object.freeze({
+                    code: diagnostic.code,
+                    ...(location
+                        ? {
+                            location: Object.freeze({
+                                end: location.end,
+                                path: Object.freeze([...location.path]),
+                                source: location.source,
+                                start: location.start,
+                            }),
+                        }
+                        : {}),
+                    message: diagnostic.message,
+                    path: Object.freeze([...diagnostic.path]),
+                });
+            }));
+        case 'MissingTransformError':
+            return new MissingTransformError();
+        default:
+            return new Error(error.message);
+    }
+}
+/** Rebuilds a contract with its enumerable properties in creation order. */
+function contract(input) {
+    const value = {};
+    for (const key of input.keys) {
+        if (key === 'variableSet')
+            value.variableSet = true;
+        else if (key === 'mappings')
+            value.mappings = (() => {
+                if (input.mappings === undefined)
+                    return undefined;
+                if (input.mappings === false)
+                    return false;
+                return properties(input.mappings);
+            })();
+        else if (key === 'shorthands')
+            value.shorthands = shorthands(input.shorthands);
+        else
+            value[key] = input[key];
+    }
+    if (input.identity !== null)
+        value[Token.identity] = input.identity;
+    if (input.complete)
+        value[Token.complete] = true;
+    return Object.freeze(value);
+}
+/** Shorthand mappings are frozen null-prototype records, as `Shorthands.read` returns them. */
+function shorthands(input) {
+    return Object.freeze(lookup(input, strings));
+}
+/** A frozen record of frozen string lists. */
+function properties(input) {
+    return Object.freeze(Object.fromEntries(input.map(([key, value]) => [
+        key,
+        Object.freeze([...value]),
+    ])));
+}
+function number(input) {
+    if (typeof input === 'number')
+        return input;
+    const tag = input.n;
+    if (tag === 'NaN')
+        return Number.NaN;
+    if (tag === 'Infinity')
+        return Number.POSITIVE_INFINITY;
+    if (tag === '-Infinity')
+        return Number.NEGATIVE_INFINITY;
+    return -0;
+}
+function isNumber(input) {
+    return (typeof input === 'number' ||
+        (typeof input === 'object' &&
+            input !== null &&
+            !Array.isArray(input) &&
+            'n' in input));
+}
+function strings(input) {
+    return Object.freeze([...input]);
+}
+function record(input, decode) {
+    return Object.freeze(Object.fromEntries(input.map(([key, value]) => [key, decode(value)])));
+}
+/** Authored container names are frozen copies, and an omitted list is a fresh array. */
+function containerNames(input) {
+    const names = input;
+    return names.length ? Object.freeze([...names]) : [];
+}
+/** A mutable null-prototype record. */
+function lookup(input, decode) {
+    return Object.assign(Object.create(null), Object.fromEntries(input.map(([key, value]) => [key, decode(value)])));
+}
+/** Creates a decoder that shares one contract table. */
+function create(contracts, options) {
+    function binding(input) {
+        const value = {
+            name: input.name,
+            type: input.type,
+            ...(input.zero ? { zero: true } : {}),
+            variable: true,
+        };
+        return Object.freeze(input.dynamic
+            ? Object.defineProperty(value, Binding.dynamic, { value: true })
+            : value);
+    }
+    function reference(input) {
+        const value = Token.create({
+            contract: contracts[input.c],
+            group: input.g,
+            path: input.p,
+            value: tokenValue(input.v),
+        });
+        return input.w
+            ? Object.freeze({
+                ...value,
+                [Token.web]: true,
+            })
+            : value;
+    }
+    function expression(input) {
+        const parts = Object.freeze(input.parts.map((part) => {
+            if (typeof part === 'string')
+                return part;
+            const fields = part;
+            if ('binding' in fields)
+                return binding(fields.binding);
+            return reference(fields.ref);
+        }));
+        return Object.freeze(input.group === null
+            ? { [Token.expression]: true, parts }
+            : { [Token.expression]: true, group: input.group, parts });
+    }
+    function tokenValue(input) {
+        if (typeof input === 'string')
+            return input;
+        if (isNumber(input))
+            return number(input);
+        const fields = input;
+        if ('ref' in fields)
+            return reference(fields.ref);
+        if ('expr' in fields)
+            return expression(fields.expr);
+        return record(fields.obj, tokenValue);
+    }
+    function data(input) {
+        if (input === undefined)
+            return undefined;
+        if (input === null ||
+            typeof input === 'string' ||
+            typeof input === 'boolean')
+            return input;
+        if (typeof input === 'number')
+            return input;
+        if (Array.isArray(input))
+            return Object.freeze(input.map(data));
+        const fields = input;
+        if ('n' in fields)
+            return number(fields);
+        if ('$' in fields)
+            return undefined;
+        if ('ref' in fields)
+            return reference(fields.ref);
+        if ('expr' in fields)
+            return expression(fields.expr);
+        if ('binding' in fields)
+            return binding(fields.binding);
+        if ('theme' in fields)
+            return definition(fields.theme);
+        return record(fields.obj, data);
+    }
+    // Authored configuration literals are mutable, and their objects have no prototype.
+    function authored(input) {
+        if (Array.isArray(input))
+            return input.map(authored);
+        if (input === null || typeof input !== 'object')
+            return data(input);
+        const fields = input;
+        if (!('obj' in fields))
+            return data(input);
+        return lookup(fields.obj, authored);
+    }
+    // Theme values flatten token groups into mutable records around the frozen token values.
+    // A group is never a value, so an object with scheme or condition keys is one.
+    function tree(input) {
+        const fields = input;
+        const entries = fields !== null && typeof fields === 'object'
+            ? fields.obj
+            : undefined;
+        if (!entries ||
+            entries.some(([key]) => key === 'default' || key === 'light' || key === 'dark'))
+            return data(input);
+        return Object.fromEntries(entries.map(([key, value]) => [key, tree(value)]));
+    }
+    // Query metadata spreads over the token values of each configured theme.
+    function themeValues(input) {
+        return Object.fromEntries(input.obj.map(([key, value]) => {
+            if (key === 'breakpoint' || key === 'container')
+                return [key, Object.freeze(lookup(value.obj, String))];
+            if (key === 'containerNames')
+                return [key, containerNames(value)];
+            return [key, tree(value)];
+        }));
+    }
+    // Normalized configuration options keep authored literals beside the flattened themes.
+    function configOptions(input) {
+        return Object.fromEntries(input.obj.map(([key, value]) => {
+            if (key === 'theme')
+                return [key, themeValues(value)];
+            if (key === 'themes')
+                return [
+                    key,
+                    Object.fromEntries(value.obj.map(([name, theme]) => [
+                        name,
+                        themeValues(theme),
+                    ])),
+                ];
+            return [key, authored(value)];
+        }));
+    }
+    function definition(input) {
+        const contract = contracts[input.contract];
+        const queries = input.queries;
+        const metadata = Object.freeze({
+            contract,
+            ...(input.cssName !== null ? { cssName: input.cssName } : {}),
+            ...(input.paths !== null
+                ? { paths: properties(input.paths) }
+                : {}),
+            values: record(input.values, tokenValue),
+            // Variable sets always record their query metadata, even when it is empty.
+            ...(contract.variableSet && !queries ? { queries: undefined } : {}),
+            ...(queries
+                ? {
+                    queries: Object.freeze({
+                        breakpoint: Object.freeze(lookup(queries.breakpoint, String)),
+                        containerNames: containerNames(queries.containerNames),
+                        container: Object.freeze(lookup(queries.container, String)),
+                    }),
+                }
+                : {}),
+        });
+        const className = input.className;
+        const value = Object.freeze(Object.defineProperty({
+            get className() {
+                if ('ok' in className)
+                    return className.ok;
+                if (className.error === new MissingTransformError().message)
+                    throw new MissingTransformError();
+                throw new Error(className.error);
+            },
+            style: (styles, options = {}) => {
+                if (!contract[Token.identity])
+                    Identity.requireId(undefined, 'Theme.define');
+                return Authoring.create(styles, {
+                    ...options,
+                    theme: value,
+                });
+            },
+            tokens: data(input.tokens),
+            variants: (styles, options = {}) => Authoring.variants(styles, options),
+            vars: data(input.vars),
+        }, Token.definition, { value: metadata }));
+        return value;
+    }
+    function declarationValue(input) {
+        return data(input);
+    }
+    function style(input) {
+        const declarations = Object.freeze(input.declarations.map(([property, value, important]) => Object.freeze({
+            ...(important ? { important: true } : {}),
+            property: property,
+            value: declarationValue(value),
+        })));
+        const rules = input.rules;
+        const targets = input.targets;
+        const body = rules
+            ? {
+                name: input.name,
+                declarations,
+                rules: Object.freeze(rules.map(([condition, child]) => Object.freeze({
+                    ...(condition !== null
+                        ? { condition: condition }
+                        : {}),
+                    style: style(child),
+                }))),
+            }
+            : { declarations, name: input.name };
+        return Object.freeze({
+            ...body,
+            ...(targets
+                ? {
+                    targets: Object.freeze({
+                        ...(targets.native !== undefined
+                            ? { native: target(targets.native) }
+                            : {}),
+                        ...(targets.ios !== undefined
+                            ? { ios: target(targets.ios) }
+                            : {}),
+                        ...(targets.android !== undefined
+                            ? { android: target(targets.android) }
+                            : {}),
+                        ...(targets.web !== undefined
+                            ? { web: style(targets.web) }
+                            : {}),
+                    }),
+                }
+                : {}),
+            ...(input.composition !== undefined
+                ? { composition: input.composition }
+                : {}),
+            ...(input.cssOutput !== undefined ? { cssOutput: input.cssOutput } : {}),
+        });
+    }
+    // Native target data is copied into frozen null-prototype records, as `Targets.copy` does.
+    function target(input) {
+        if (Array.isArray(input))
+            return Object.freeze(input.map(target));
+        if (input === null || typeof input !== 'object' || !('obj' in input))
+            return data(input);
+        return Object.freeze(lookup(input.obj, target));
+    }
+    function styles(input) {
+        return Object.freeze({
+            styles: Object.freeze(input.styles.map(style)),
+        });
+    }
+    // Compositions copy the styles they combine, and a copy differs from its source in content.
+    function composed(input, sources) {
+        const decoded = style(input);
+        const rules = input.rules;
+        const name = input.name;
+        if (!rules || !decoded.rules)
+            return decoded;
+        const copied = (child) => sources.get(child.name) !== JSON.stringify(child);
+        // Runtime compositions copy each conditional rule with the output mode of its source.
+        if (name.startsWith('composition-'))
+            return Object.freeze({
+                ...decoded,
+                rules: Object.freeze(decoded.rules.map((rule, index) => {
+                    const child = rules[index][1];
+                    return copied(child) && !('cssOutput' in rule.style)
+                        ? Object.freeze({
+                            ...rule,
+                            style: Object.freeze({ ...rule.style, cssOutput: undefined }),
+                        })
+                        : rule;
+                })),
+            });
+        // Static compositions copy referenced styles mutably beside their inline parts.
+        if (decoded.declarations.length ||
+            rules.some(([condition]) => condition !== null))
+            return decoded;
+        return Object.freeze({
+            ...decoded,
+            rules: Object.freeze(decoded.rules.map((rule) => rule.style.name === name
+                ? rule
+                : Object.freeze({ ...rule, style: { ...rule.style } }))),
+        });
+    }
+    function labelled(input) {
+        const inputs = input.styles;
+        const sources = new Map(inputs.map((entry) => [entry.name, JSON.stringify(entry)]));
+        const definition = {
+            styles: Object.freeze(inputs.map((entry) => composed(entry, sources))),
+        };
+        const labels = input.labels;
+        if (labels)
+            Object.defineProperty(definition, ClassName.labels, {
+                value: Object.freeze(Object.fromEntries(labels.map(([name, label, namespace]) => [
+                    name,
+                    { name: label, namespace: namespace ?? undefined },
+                ]))),
+            });
+        return Object.freeze(definition);
+    }
+    // A call's lowered recipe shares the axes and defaults of its recipe metadata.
+    function staticRecipe(input, shared) {
+        return {
+            axes: shared?.axes ??
+                lookup(input.axes, (choices) => [...choices]),
+            defaults: shared?.defaults ?? lookup(input.defaults, (value) => value),
+            rules: input.rules.map((rule) => ({
+                matches: rule.matches.map(([axis, choices]) => [
+                    axis,
+                    [...choices],
+                ]),
+                value: styles(rule.value),
+            })),
+        };
+    }
+    // Recipe metadata is mutable and keyed by null-prototype records, as `Recipes.expand` builds it.
+    function recipe(input) {
+        return {
+            axes: lookup(input.axes, (choices) => [...choices]),
+            defaults: lookup(input.defaults, (value) => value),
+            ...(input.payloads !== undefined
+                ? {
+                    payloads: input.payloads.map((payload) => ({
+                        axis: payload.axis,
+                        choice: payload.choice,
+                        slots: payload.slots.map((slots) => Object.fromEntries(slots)),
+                    })),
+                    defaultPayloads: lookup(input.defaultPayloads, (fields) => lookup(fields, (value) => isNumber(value) ? number(value) : value)),
+                }
+                : {}),
+            ...(input.conditions !== undefined
+                ? { conditions: [...input.conditions] }
+                : {}),
+        };
+    }
+    function slots(input) {
+        return record(input, (value) => binding(value));
+    }
+    // Callback slots are null-prototype records, so field names never meet inherited keys.
+    function fields(input) {
+        return Object.freeze(Object.assign(Object.create(null), Object.fromEntries(input.map(([key, value]) => [
+            key,
+            binding(value),
+        ]))));
+    }
+    function nativeContext(input) {
+        return Object.freeze({
+            defaultVars: input.defaultVars,
+            vars: record(input.vars, (value) => definition(value)),
+        });
+    }
+    function owner(input) {
+        return Object.freeze({
+            attributes: strings(input.attributes),
+            identity: input.identity,
+            slots: strings(input.slots),
+        });
+    }
+    function counts(input) {
+        return new Map(input.map(([start, count]) => [start, count]));
+    }
+    function call(input) {
+        const value = {};
+        const shared = input.recipe !== undefined ? recipe(input.recipe) : undefined;
+        // Without source rewriting, every definition call records its portable identity, if any.
+        if (options.compiler === false &&
+            input.composition === undefined &&
+            input.runtimeComposition === undefined &&
+            input.compositionCase === undefined)
+            value.portable = undefined;
+        for (const [key, entry] of Object.entries(input)) {
+            switch (key) {
+                case 'nativeContext':
+                    value[key] = nativeContext(entry);
+                    break;
+                case 'cssNamespace':
+                    value[key] = entry ?? undefined;
+                    break;
+                case 'portable':
+                    value[key] = entry ?? undefined;
+                    break;
+                // Composition metadata is assembled as mutable lists.
+                case 'portableInputs':
+                case 'compositionCases':
+                case 'composition':
+                    value[key] = [...entry];
+                    break;
+                case 'ownership':
+                    value[key] = owner(entry);
+                    break;
+                case 'runtimeComposition':
+                    value[key] = entry.map((input) => ({
+                        ...(input.applicationStart !== undefined
+                            ? { applicationStart: input.applicationStart }
+                            : {}),
+                        ...(input.condition !== undefined
+                            ? { condition: input.condition }
+                            : {}),
+                        end: input.end,
+                        name: input.name,
+                        owners: input.owners.map((owner) => ({
+                            attributes: [...owner.attributes],
+                            identity: owner.identity,
+                            slots: [...owner.slots],
+                        })),
+                        start: input.start,
+                    }));
+                    break;
+                case 'recipe':
+                    value[key] = shared;
+                    break;
+                case 'dynamicRecipe':
+                case 'staticRecipe':
+                    value[key] = staticRecipe(entry, shared);
+                    break;
+                case 'recipeTypes':
+                    value[key] = lookup(entry, (choices) => lookup(choices, String));
+                    break;
+                case 'shorthands':
+                    value[key] = shorthands(entry);
+                    break;
+                case 'typography':
+                case 'typographyQueries':
+                    value[key] = counts(entry);
+                    break;
+                case 'slots':
+                    value[key] = fields(entry);
+                    break;
+                default:
+                    value[key] = entry;
+            }
+        }
+        return Object.freeze(value);
+    }
+    function signature(input) {
+        return {
+            // Parameters are the evaluated literal records, which have no prototype.
+            parameters: input.parameters.map((parameter) => Object.assign(Object.create(null), {
+                ...(parameter.default !== undefined
+                    ? {
+                        default: isNumber(parameter.default)
+                            ? number(parameter.default)
+                            : parameter.default,
+                    }
+                    : {}),
+                name: parameter.name,
+                ...(parameter.syntax !== undefined
+                    ? { syntax: parameter.syntax }
+                    : {}),
+            })),
+            returns: input.returns,
+        };
+    }
+    // Authored variable mappings stay the mutable null-prototype literal the configuration read.
+    function mappings(input) {
+        if (input === null || input === undefined)
+            return undefined;
+        if (input === false)
+            return false;
+        return lookup(input, (properties) => [
+            ...properties,
+        ]);
+    }
+    // Configuration calls carry `appearance` and stay mutable. Factory calls are frozen.
+    function themeCall(input) {
+        const value = {};
+        for (const [key, entry] of Object.entries(input)) {
+            // Variable configurations always record their mappings, even when none were authored.
+            if (key === 'variableMappings' &&
+                (input.variableConfig || entry === false)) {
+                value[key] = mappings(entry);
+                continue;
+            }
+            if (entry === null || entry === false)
+                continue;
+            switch (key) {
+                case 'function':
+                    value[key] = signature(entry);
+                    break;
+                case 'members':
+                    value[key] = input.appearance
+                        ? Object.fromEntries(entry)
+                        : record(entry, String);
+                    break;
+                case 'options':
+                    value[key] = configOptions(entry);
+                    break;
+                case 'variables':
+                    value[key] = slots(entry);
+                    break;
+                default:
+                    value[key] = entry;
+            }
+        }
+        return (input.appearance ? value : Object.freeze(value));
+    }
+    function alias(input) {
+        const call = input.call;
+        // A style alias copies a fixed set of the theme call's fields, defined or not.
+        if (input.bindings !== null)
+            return {
+                recipe: call.recipe,
+                destructured: input.destructured,
+                end: call.end,
+                name: call.name,
+                start: call.start,
+                tokenType: call.tokenType,
+                type: (call.type ?? undefined),
+                options: call.options === null ? undefined : configOptions(call.options),
+                variableConfig: call.variableConfig ? true : undefined,
+                variableMappings: mappings(call.variableMappings),
+                output: (call.output ?? undefined),
+                bindings: [...input.bindings],
+            };
+        return {
+            ...themeCall(call),
+            destructured: input.destructured,
+            ...(input.retained ? { retained: true } : {}),
+        };
+    }
+    function varsRead(input) {
+        return {
+            defaultVars: input.defaultVars,
+            end: input.end,
+            owner: input.owner,
+            start: input.start,
+            unnamed: input.unnamed,
+            vars: Object.fromEntries(input.vars.map(([key, value]) => [
+                key,
+                definition(value),
+            ])),
+        };
+    }
+    // Contribution data is mutable. Only the styles `Style.define` produces inside it are frozen.
+    function entry(input) {
+        if (input.kind === 'block')
+            return {
+                kind: 'block',
+                header: input.header,
+                entries: input.entries.map(entry),
+            };
+        if (input.kind === 'descriptor')
+            return {
+                kind: 'descriptor',
+                name: input.name,
+                value: (isNumber(input.value) ? number(input.value) : input.value),
+            };
+        return { kind: 'style', style: style(input.style) };
+    }
+    function scalarRecord(input) {
+        return Object.fromEntries(input.map(([key, value]) => [
+            key,
+            isNumber(value) ? number(value) : value,
+        ]));
+    }
+    // Grouping rules nest plain `global` styles around the defined styles of their selectors.
+    function ruleStyle(input) {
+        if (input.name !== 'global')
+            return style(input);
+        return {
+            name: 'global',
+            declarations: [],
+            rules: (input.rules ?? []).map(([condition, child]) => ({
+                condition: condition,
+                style: ruleStyle(child),
+            })),
+        };
+    }
+    function contribution(input) {
+        const value = (() => {
+            switch (input.kind) {
+                case 'block':
+                    return {
+                        kind: 'block',
+                        header: input.header,
+                        entries: input.entries.map(entry),
+                    };
+                case 'descriptor':
+                    return {
+                        kind: 'descriptor',
+                        rule: input.rule,
+                        name: input.name,
+                        declarations: scalarRecord(input.declarations),
+                    };
+                case 'font-face':
+                    return {
+                        kind: 'font-face',
+                        declarations: scalarRecord(input.declarations),
+                    };
+                case 'keyframes':
+                    return {
+                        kind: 'keyframes',
+                        name: input.name,
+                        frames: input.frames.map((frame) => ({
+                            stop: frame.stop,
+                            style: style(frame.style),
+                        })),
+                    };
+                case 'layers':
+                    return { kind: 'layers', names: [...input.names] };
+                case 'rule':
+                    return {
+                        kind: 'rule',
+                        selector: input.selector,
+                        style: ruleStyle(input.style),
+                    };
+                default:
+                    return Object.fromEntries(Object.entries(input).filter(([key]) => key !== 'within'));
+            }
+        })();
+        return (input.within !== undefined
+            ? { ...value, within: [...input.within] }
+            : value);
+    }
+    function contributionCall(input) {
+        return {
+            kind: input.kind,
+            start: input.start,
+            end: input.end,
+            ...(input.function !== undefined
+                ? { function: signature(input.function) }
+                : {}),
+            ...(input.name !== undefined ? { name: input.name } : {}),
+            ...(input.binding !== undefined ? { binding: input.binding } : {}),
+            ...(input.exported !== undefined ? { exported: input.exported } : {}),
+        };
+    }
+    function result(input) {
+        const contributions = (input.contributions ?? []).map(contribution);
+        // Namespaces are the namespace contributions themselves, as a filtered list.
+        const value = {
+            namespaces: contributions.filter((entry) => entry.kind === 'namespace'),
+        };
+        if (input.contributions !== undefined) {
+            value.contributions = contributions;
+            value.contributionStarts = [...input.contributionStarts];
+        }
+        if (input.contributionCalls !== undefined)
+            value.contributionCalls = input.contributionCalls.map(contributionCall);
+        value.calls = Object.freeze(input.calls.map(call));
+        value.styles = labelled(input.styles);
+        if (input.variableCalls !== undefined)
+            value.variableCalls = Object.freeze(input.variableCalls.map((entry) => Object.freeze({
+                explicit: entry.explicit,
+                start: entry.start,
+                end: entry.end,
+                slots: slots(entry.slots),
+            })));
+        value.themeAliases = Object.freeze(input.themeAliases.map(alias));
+        for (const key of ['themeAppearances', 'themeScripts', 'themeSelections'])
+            if (input[key] !== undefined)
+                value[key] = strings(input[key]);
+        value.themeCalls = Object.freeze(input.themeCalls.map(themeCall));
+        if (input.staticThemeReferences !== undefined)
+            value.staticThemeReferences = Object.freeze(input.staticThemeReferences.map((entry) => ({
+                ...entry,
+            })));
+        value.themeReferences = Object.freeze(input.themeReferences.map((entry) => Object.freeze({ ...entry })));
+        // Collected themes are keyed by a null-prototype record. A module without theme
+        // imports collects none and returns an ordinary empty record.
+        value.vars = Object.freeze(input.collectedThemes
+            ? lookup(input.vars, (entry) => definition(entry))
+            : {});
+        if (input.nativeVars !== undefined)
+            value.nativeVars = Object.freeze(input.nativeVars.map(varsRead));
+        return Object.freeze(value);
+    }
+    return { result };
+}
+//# sourceMappingURL=Wire.js.map