zyzz 0.0.28 → 0.0.29

package/dist/compiler/internal/Themes.js

@@ -1,1577 +0,0 @@
-import * as Identity from '../../internal/Identity.js';
-import * as Identifiers from './Identifiers.js';
-import * as Config from '../../internal/Configuration.js';
-import * as Expression from './Expression.js';
-import * as Configurations from './Configurations.js';
-import * as Token from '../../internal/Token.js';
-import * as Theme from '../../internal/Theme.js';
-import * as VariableSets from '../../internal/VariableSets.js';
-import * as Vars from '../../Vars.js';
-/** Internal context passed between graph extraction and module rewriting. */
-export const context = Symbol('zyzz.source.graph');
-/** Resolves the variable alternatives a linked configuration or variable set exposes to native hooks. */
-export function varsRead(link) {
-    const named = link.call.options?.themes !== undefined;
-    const vars = (() => {
-        if (!named)
-            return { default: link.definition };
-        return Object.fromEntries(Object.entries(link.members ?? {}).flatMap((entry) => {
-            const [key, member] = entry;
-            const path = JSON.parse(key);
-            if (path.length === 1 && link.call.selection)
-                return [[path[0], member.definition]];
-            if (path.length === 2 && path[0] === 'themes')
-                return [[path[1], member.definition]];
-            return [];
-        }));
-    })();
-    return {
-        defaultVars: named ? String(link.call.options.defaultTheme) : 'default',
-        owner: link.call.name,
-        unnamed: !named,
-        vars,
-    };
-}
-/** Collects immutable module-level themes without evaluating source. */
-export function collect(program, options) {
-    const staticTokens = [];
-    const aliases = [];
-    const aliasBindings = new Map();
-    const aliasReferences = new Set();
-    const appearances = new Set();
-    const scopeApplications = new Map();
-    const selections = new Set();
-    const selectionUses = new Set();
-    const calls = [];
-    const scripts = new Set();
-    const definitions = new Map();
-    const factories = new Set();
-    const imports = new Set();
-    const variableImports = new Set();
-    const configImports = new Set();
-    const factoryImports = new Map();
-    const nativeFactories = new Set();
-    const configs = new Map();
-    const configBindings = new Map();
-    const factoryReferences = new Set();
-    const references = [];
-    const varsReads = [];
-    const styles = new Map();
-    const themes = Object.create(null);
-    const tokens = new Map();
-    for (const node of program.body) {
-        if (node.type !== 'ImportDeclaration' ||
-            !['zyzz', 'zyzz/react-native', 'zyzz/react-native/react'].includes(node.source.value) ||
-            node.importKind === 'type')
-            continue;
-        for (const specifier of node.specifiers) {
-            if (node.source.value !== 'zyzz') {
-                if (specifier.type === 'ImportSpecifier' &&
-                    specifier.importKind !== 'type' &&
-                    (specifier.imported.type === 'Identifier'
-                        ? specifier.imported.name
-                        : specifier.imported.value) === 'defineConfig') {
-                    factoryImports.set(specifier.start, 'create');
-                    nativeFactories.add(specifier.local.name);
-                }
-                continue;
-            }
-            if (specifier.type === 'ImportSpecifier' &&
-                specifier.importKind !== 'type' &&
-                (specifier.imported.type === 'Identifier'
-                    ? specifier.imported.name
-                    : specifier.imported.value) === 'Vars') {
-                imports.add(specifier.start);
-                variableImports.add(specifier.start);
-            }
-            else if (specifier.type === 'ImportSpecifier' &&
-                specifier.importKind !== 'type' &&
-                (specifier.imported.type === 'Identifier'
-                    ? specifier.imported.name
-                    : specifier.imported.value) === 'Config')
-                configImports.add(specifier.start);
-            else if (specifier.type === 'ImportSpecifier' &&
-                specifier.importKind !== 'type' &&
-                ['defineConfig', 'defineVars', 'extendVars'].includes(specifier.imported.type === 'Identifier'
-                    ? specifier.imported.name
-                    : specifier.imported.value)) {
-                const name = specifier.imported.type === 'Identifier'
-                    ? specifier.imported.name
-                    : specifier.imported.value;
-                if (name === 'defineConfig')
-                    factoryImports.set(specifier.start, 'create');
-                else if (name === 'defineVars')
-                    factoryImports.set(specifier.start, 'define');
-                else
-                    factoryImports.set(specifier.start, 'extend');
-            }
-        }
-    }
-    if (!imports.size &&
-        !configImports.size &&
-        !factoryImports.size &&
-        !Object.keys(options.links ?? {}).length)
-        return undefined;
-    const names = new Map();
-    const aliasNames = new Map();
-    const exports = Object.create(null);
-    for (const node of program.body) {
-        if (node.type !== 'ImportDeclaration' || node.importKind === 'type')
-            continue;
-        for (const specifier of node.specifiers) {
-            const link = options.links?.[specifier.local.name];
-            if (!link ||
-                link.kind === 'style-reference' ||
-                link.kind === 'animation' ||
-                link.kind === 'rule-reference' ||
-                link.kind === 'variables')
-                continue;
-            const call = { ...link.call, start: -1, end: -1 };
-            themes[call.name] = link.definition;
-            if (link.kind === 'config') {
-                const imported = {
-                    ...link,
-                    call,
-                    members: Object.fromEntries(Object.entries(link.members ?? {}).map(([key, member]) => [
-                        key,
-                        { ...member, call: { ...member.call, start: -1, end: -1 } },
-                    ])),
-                };
-                configs.set(specifier.local.name, imported);
-                configBindings.set(specifier.start, imported);
-                for (const member of Object.values(link.members ?? {}))
-                    themes[member.call.name] = member.definition;
-            }
-            else if (link.kind === 'theme') {
-                definitions.set(specifier.start, call);
-                names.set(specifier.local.name, call);
-            }
-            else {
-                const alias = { ...call, destructured: false };
-                aliasBindings.set(specifier.start, alias);
-                aliasNames.set(specifier.local.name, alias);
-            }
-        }
-    }
-    const namespaces = new Set();
-    const configNamespaces = new Set();
-    const factoryFunctions = new Map();
-    const variableNamespaces = new Set();
-    for (const node of program.body)
-        if (node.type === 'ImportDeclaration')
-            for (const specifier of node.specifiers)
-                if (variableImports.has(specifier.start))
-                    variableNamespaces.add(specifier.local.name);
-    for (const node of program.body)
-        if (node.type === 'ImportDeclaration')
-            for (const specifier of node.specifiers)
-                if (imports.has(specifier.start))
-                    namespaces.add(specifier.local.name);
-                else if (configImports.has(specifier.start))
-                    configNamespaces.add(specifier.local.name);
-                else if (factoryImports.has(specifier.start))
-                    factoryFunctions.set(specifier.local.name, factoryImports.get(specifier.start));
-    function resolve(node) {
-        if (node.type === 'Identifier') {
-            const config = configs.get(node.name);
-            if (config)
-                return config;
-            const call = names.get(node.name);
-            if (call)
-                return {
-                    binding: call.name,
-                    call,
-                    definition: themes[call.name],
-                    kind: 'theme',
-                };
-            return undefined;
-        }
-        if (node.type !== 'MemberExpression' || node.optional)
-            return undefined;
-        const path = [];
-        let root = node;
-        while (root.type === 'MemberExpression') {
-            const key = (() => {
-                if (root.property.type === 'Identifier' && !root.computed) {
-                    return root.property.name;
-                }
-                if (root.property.type === 'Literal' &&
-                    root.computed &&
-                    (typeof root.property.value === 'string' ||
-                        typeof root.property.value === 'number')) {
-                    return String(root.property.value);
-                }
-                return undefined;
-            })();
-            if (root.optional || key === undefined)
-                return undefined;
-            path.unshift(key);
-            root = root.object;
-        }
-        const config = root.type === 'Identifier' ? configs.get(root.name) : undefined;
-        if (config &&
-            !config.call.selection &&
-            !config.call.initialization &&
-            !config.call.root &&
-            path.length === 1 &&
-            ['themes', 'vars', 'script', 'appearance'].includes(path[0])) {
-            const key = path[0];
-            if (config.call.variableConfig && key === 'themes')
-                return undefined;
-            if (key === 'script')
-                scripts.add(config.call.name);
-            if (key === 'appearance')
-                appearances.add(config.call.name);
-            if (key === 'themes' && !config.call.options?.themes)
-                return undefined;
-            if (key === 'themes' || key === 'vars')
-                selections.add(config.call.name);
-            if (key === 'script' && !config.call.script)
-                fail('This packed configuration does not provide script(); rebuild its library with initialization support.', node);
-            if (key === 'appearance' && !config.call.appearance)
-                fail('This packed configuration does not provide appearance; rebuild its library with root control support.', node);
-            const members = Object.fromEntries(Object.entries(config.members ?? {}).flatMap(([name, member]) => {
-                const parts = JSON.parse(name);
-                return (key === 'themes' || key === 'vars') && parts[0] === 'themes'
-                    ? [[JSON.stringify(parts.slice(1)), member]]
-                    : [];
-            }));
-            return {
-                ...config,
-                members,
-                binding: `${config.binding}:${key}`,
-                call: {
-                    ...config.call,
-                    members: Object.fromEntries(Object.entries(members).map(([name, member]) => [
-                        name,
-                        member.call.name,
-                    ])),
-                    ...helper(key),
-                    type: `${config.call.type}['${key}']`,
-                },
-            };
-        }
-        return config?.members?.[JSON.stringify(path)];
-    }
-    /** Marks which configuration helper a destructured or member binding represents. */
-    function helper(key) {
-        if (key === 'script')
-            return { initialization: true };
-        if (key === 'appearance')
-            return { root: true };
-        return { selection: true };
-    }
-    function readReference(node, derived) {
-        if (node.type !== 'MemberExpression')
-            return undefined;
-        const path = [];
-        let root = node;
-        while (root.type === 'MemberExpression' && !root.optional) {
-            const key = !root.computed && root.property.type === 'Identifier'
-                ? root.property.name
-                : root.property.type === 'Literal'
-                    ? String(root.property.value)
-                    : undefined;
-            if (key === undefined)
-                return undefined;
-            path.unshift(key);
-            root = root.object;
-        }
-        if (root.type !== 'Identifier')
-            return undefined;
-        const name = root.name;
-        let value = (() => {
-            if (derived?.name === name)
-                return derived.vars;
-            const call = names.get(name);
-            if (call) {
-                if (!call.variableSet &&
-                    !call.directVariables &&
-                    !['vars', 'tokens'].includes(path.shift()))
-                    return undefined;
-                return themes[call.name]?.tokens;
-            }
-            // Config-bound vars read the configured variables, so they follow set scoping.
-            const config = configs.get(name);
-            if (!config?.call.variableConfig ||
-                (!config.call.selection && path.shift() !== 'vars'))
-                return undefined;
-            return themes[config.call.name]?.tokens;
-        })();
-        if (value === undefined)
-            return undefined;
-        for (const key of path)
-            value =
-                value && typeof value === 'object'
-                    ? Object.getOwnPropertyDescriptor(value, key)?.value
-                    : undefined;
-        return Token.is(value) ? value : undefined;
-    }
-    function data(node, derived) {
-        const reference = readReference(node, derived);
-        if (reference) {
-            factoryReferences.add(node.start);
-            return reference;
-        }
-        if (node.type === 'TSAsExpression' || node.type === 'TSSatisfiesExpression')
-            return data(node.expression, derived);
-        if (node.type === 'CallExpression' && !node.optional) {
-            const callee = node.callee;
-            if (callee.type === 'MemberExpression' &&
-                !callee.computed &&
-                !callee.optional &&
-                callee.object.type === 'Identifier' &&
-                variableNamespaces.has(callee.object.name) &&
-                derived?.name !== callee.object.name &&
-                callee.property.type === 'Identifier' &&
-                callee.property.name === 'compose') {
-                if (node.arguments.length !== 2)
-                    return fail('Vars.compose requires a literal domain and parts array.', node);
-                const group = data(node.arguments[0], derived);
-                const parts = data(node.arguments[1], derived);
-                if ((group !== 'color' && group !== 'spacing') || !Array.isArray(parts))
-                    return fail('Vars.compose requires a literal domain and parts array.', node);
-                factoryReferences.add(callee.start);
-                return Vars.compose(group, parts);
-            }
-        }
-        if (node.type === 'Literal' &&
-            (typeof node.value === 'string' || typeof node.value === 'number'))
-            return node.value;
-        if (node.type === 'UnaryExpression' &&
-            (node.operator === '+' || node.operator === '-') &&
-            node.argument.type === 'Literal' &&
-            typeof node.argument.value === 'number')
-            return node.operator === '-' ? -node.argument.value : node.argument.value;
-        if (node.type === 'ArrayExpression')
-            return node.elements.map((element) => {
-                if (!element || element.type === 'SpreadElement')
-                    return fail('Theme arrays require dense literal elements.', node);
-                return data(element, derived);
-            });
-        if (node.type !== 'ObjectExpression')
-            return fail('Theme values must be literal data; expressions are not evaluated.', node);
-        const result = Object.create(null);
-        for (const property of node.properties) {
-            if (property.type !== 'Property' ||
-                property.computed ||
-                property.method ||
-                property.shorthand ||
-                property.kind !== 'init')
-                return fail('Theme data requires explicit properties without spreads, methods, or computed keys.', property);
-            const key = (() => {
-                if (property.key.type === 'Identifier') {
-                    return property.key.name;
-                }
-                if (property.key.type === 'Literal' &&
-                    (typeof property.key.value === 'string' ||
-                        typeof property.key.value === 'number')) {
-                    return String(property.key.value);
-                }
-                return undefined;
-            })();
-            if (key === undefined || Object.hasOwn(result, key))
-                return fail('Theme data requires unique literal keys.', property);
-            result[key] = data(property.value, derived);
-        }
-        return result;
-    }
-    /** Reads a derived-variables callback as one parameter name and a literal body. */
-    function derivation(argument) {
-        const callback = argument && Expression.unwrap(argument);
-        if (callback?.type !== 'ArrowFunctionExpression' &&
-            callback?.type !== 'FunctionExpression')
-            return undefined;
-        const parameter = callback.params[0];
-        const body = (() => {
-            if (callback.body?.type !== 'BlockStatement')
-                return callback.body;
-            if (callback.body.body.length === 1 &&
-                callback.body.body[0]?.type === 'ReturnStatement')
-                return callback.body.body[0].argument;
-            return undefined;
-        })();
-        if (callback.async ||
-            callback.generator ||
-            callback.params.length !== 1 ||
-            parameter?.type !== 'Identifier' ||
-            !body)
-            fail('Derived variables require one named parameter and a literal return value.', callback);
-        return { body, name: parameter.name };
-    }
-    /** Authored values of an extension, keeping base values at existing paths as `Vars.extend` types do. */
-    function extendedValues(base, extension) {
-        const metadata = extension[Token.definition];
-        const known = base[Token.definition].values;
-        const tree = Object.create(null);
-        for (const path of Object.keys(metadata.values)) {
-            const parts = metadata.paths?.[path] ?? path.split('.');
-            const source = Object.hasOwn(known, path) ? base : extension;
-            let target = tree;
-            let token = source.tokens;
-            for (const part of parts.slice(0, -1)) {
-                target = (target[part] ??= Object.create(null));
-                token = token[part];
-            }
-            const name = parts.at(-1);
-            // Every metadata path has a reference in its own token tree.
-            target[name] = token[name].value;
-        }
-        return tree;
-    }
-    function fail(message, node) {
-        throw new InvalidError(message, node);
-    }
-    function type(node) {
-        if (node.type === 'TSAsExpression' || node.type === 'TSSatisfiesExpression')
-            return type(node.expression);
-        if (node.type !== 'ObjectExpression')
-            return Configurations.type(data(node));
-        return `{${node.properties
-            .map((property) => {
-            if (property.type !== 'Property')
-                return fail('Expected validated theme properties.', property);
-            const key = (() => {
-                if (property.key.type === 'Identifier') {
-                    return JSON.stringify(property.key.name);
-                }
-                if (property.key.type === 'Literal') {
-                    return JSON.stringify(property.key.value);
-                }
-                return fail('Expected a literal theme key.', property.key);
-            })();
-            return `readonly ${key}:${type(property.value)}`;
-        })
-            .join(';')}}`;
-    }
-    for (const statement of program.body) {
-        const declaration = statement.type === 'ExportNamedDeclaration'
-            ? statement.declaration
-            : statement;
-        if (declaration?.type !== 'VariableDeclaration')
-            continue;
-        for (const variable of declaration.declarations) {
-            registerAlias({ declaration, statement, variable });
-            const expression = variable.init;
-            if (expression?.type !== 'CallExpression' || expression.optional)
-                continue;
-            const member = expression.callee;
-            const directFactory = member.type === 'Identifier'
-                ? factoryFunctions.get(member.name)
-                : undefined;
-            if (!directFactory &&
-                (member.type !== 'MemberExpression' ||
-                    member.object.type !== 'Identifier' ||
-                    (!namespaces.has(member.object.name) &&
-                        !configNamespaces.has(member.object.name)) ||
-                    member.computed ||
-                    member.optional ||
-                    member.property.type !== 'Identifier' ||
-                    !(configNamespaces.has(member.object.name)
-                        ? ['create']
-                        : ['define', 'extend']).includes(member.property.name)))
-                continue;
-            const config = directFactory === 'create' ||
-                (member.type === 'MemberExpression' &&
-                    member.object.type === 'Identifier' &&
-                    configNamespaces.has(member.object.name));
-            const method = member.type === 'MemberExpression' &&
-                member.property.type === 'Identifier'
-                ? member.property.name
-                : directFactory;
-            const variableSet = directFactory === 'define' ||
-                directFactory === 'extend' ||
-                (member.type === 'MemberExpression' &&
-                    member.object.type === 'Identifier' &&
-                    variableNamespaces.has(member.object.name));
-            if ((statement.type === 'ExportNamedDeclaration' && !options.linked) ||
-                declaration.kind !== 'const' ||
-                (variable.id.type !== 'Identifier' &&
-                    !(config && variable.id.type === 'ObjectPattern')))
-                fail('Define local themes with a module-level const; exported themes require source linking.', variable);
-            const bindings = (() => {
-                if (variable.id.type !== 'ObjectPattern')
-                    return [];
-                return variable.id.properties.map((property) => {
-                    if (property.type !== 'Property' ||
-                        property.computed ||
-                        property.key.type !== 'Identifier' ||
-                        property.value.type !== 'Identifier')
-                        fail('Configuration destructuring requires named bindings without defaults, rest, or nested patterns.', property);
-                    return { key: property.key.name, id: property.value };
-                });
-            })();
-            const binding = variable.id.type === 'Identifier'
-                ? variable.id.name
-                : bindings[0]?.id.name;
-            if (!binding)
-                fail('Configuration destructuring requires a binding.', variable);
-            let name = `${options.namespace}-${binding}`;
-            if (!config && method === 'define') {
-                const argument = expression.arguments[1];
-                const callback = argument && Expression.unwrap(argument);
-                const id = Identifiers.explicit(expression, callback?.type === 'ArrowFunctionExpression' ||
-                    callback?.type === 'FunctionExpression'
-                    ? 2
-                    : 1);
-                if (id !== undefined)
-                    name = Identity.requireId(id, 'Vars.define');
-            }
-            if (!config && method === 'extend') {
-                const argument = expression.arguments[2];
-                const callback = argument && Expression.unwrap(argument);
-                const id = Identifiers.explicit(expression, callback?.type === 'ArrowFunctionExpression' ||
-                    callback?.type === 'FunctionExpression'
-                    ? 3
-                    : 2);
-                if (id !== undefined)
-                    name = Identity.requireId(id, 'Vars.extend');
-            }
-            if (config) {
-                const nativeProvider = member.type === 'Identifier' && nativeFactories.has(member.name);
-                if (nativeProvider && !options.native)
-                    fail('Native defineConfig requires a native compilation target.', expression);
-                try {
-                    const link = Configurations.collect({
-                        data,
-                        expression,
-                        name,
-                        nativeProvider,
-                        resolve: (node) => {
-                            const link = resolve(node);
-                            if (link)
-                                factoryReferences.add(node.start);
-                            return link;
-                        },
-                    });
-                    if (variable.id.type === 'Identifier') {
-                        configs.set(variable.id.name, link);
-                        configBindings.set(variable.id.start, link);
-                        if (statement.type === 'ExportNamedDeclaration')
-                            exports[variable.id.name] = link;
-                    }
-                    calls.push(link.call);
-                    factories.add(expression.start);
-                    for (const member of Object.values(link.members ?? {}))
-                        themes[member.call.name] = member.definition;
-                    themes[link.call.name] = link.definition;
-                    for (const { key, id } of bindings) {
-                        if (key === 'Provider' && link.call.nativeProvider)
-                            continue;
-                        if ((key === 'style' || key === 'variants') &&
-                            !link.call.selection &&
-                            !link.call.initialization) {
-                            const alias = {
-                                ...link.call,
-                                recipe: key === 'variants',
-                                destructured: false,
-                            };
-                            aliasBindings.set(id.start, alias);
-                            aliasNames.set(id.name, alias);
-                            if (statement.type === 'ExportNamedDeclaration')
-                                exports[id.name] = {
-                                    ...link,
-                                    binding: `${options.namespace}-${id.name}`,
-                                    call: alias,
-                                    kind: 'style',
-                                };
-                            continue;
-                        }
-                        if (!link.call.selection &&
-                            !link.call.initialization &&
-                            !link.call.root &&
-                            (key === 'script' ||
-                                key === 'appearance' ||
-                                (key === 'themes' && link.call.options?.themes) ||
-                                (key === 'vars' && link.call.variableConfig))) {
-                            if ((key === 'script' && !link.call.script) ||
-                                (key === 'appearance' && !link.call.appearance) ||
-                                link.call.selection ||
-                                link.call.initialization)
-                                fail('This configuration helper is not available on the linked contract.', id);
-                            if (key === 'script')
-                                scripts.add(link.call.name);
-                            if (key === 'appearance')
-                                appearances.add(link.call.name);
-                            if (key === 'themes' || key === 'vars')
-                                selections.add(link.call.name);
-                            const members = Object.fromEntries(Object.entries(link.members ?? {}).flatMap(([pathKey, member]) => {
-                                const path = JSON.parse(pathKey);
-                                return (key === 'themes' || key === 'vars') &&
-                                    (path[0] === 'themes' || path[0] === 'vars')
-                                    ? [[JSON.stringify(path.slice(1)), member]]
-                                    : [];
-                            }));
-                            const selection = {
-                                ...link,
-                                members,
-                                call: {
-                                    ...link.call,
-                                    members: Object.fromEntries(Object.entries(members).map(([key, member]) => [
-                                        key,
-                                        member.call.name,
-                                    ])),
-                                    ...helper(key),
-                                    type: `${link.call.type}['${key}']`,
-                                },
-                            };
-                            configs.set(id.name, selection);
-                            configBindings.set(id.start, selection);
-                            if (statement.type === 'ExportNamedDeclaration')
-                                exports[id.name] = selection;
-                            continue;
-                        }
-                        if (link.call.variableConfig && ['theme', 'themes'].includes(key))
-                            fail('Use vars for references and scope selection.', id);
-                        const member = link.members?.[JSON.stringify([key])];
-                        if (!member)
-                            fail('Destructure only style and the configured single theme; other helpers remain unsupported.', id);
-                        definitions.set(id.start, member.call);
-                        names.set(id.name, member.call);
-                        if (statement.type === 'ExportNamedDeclaration')
-                            exports[id.name] = member;
-                    }
-                }
-                catch (error) {
-                    if (!(error instanceof Config.InvalidError) &&
-                        !(error instanceof Vars.InvalidError))
-                        throw error;
-                    fail(error.message, expression);
-                }
-                continue;
-            }
-            let definition;
-            let tokenType;
-            let output;
-            try {
-                if (method === 'define') {
-                    if (expression.arguments.length < 1 ||
-                        expression.arguments.length > 3)
-                        fail('Vars.define requires one literal variable object.', expression);
-                    let input = data(expression.arguments[0]);
-                    tokenType = type(expression.arguments[0]);
-                    const derive = variableSet
-                        ? derivation(expression.arguments[1])
-                        : undefined;
-                    if (derive) {
-                        const base = VariableSets.build(input, Object.freeze({ variableSet: true, [Token.identity]: name }));
-                        input = VariableSets.merge(input, data(derive.body, { name: derive.name, vars: base }));
-                        tokenType = Configurations.type(input);
-                    }
-                    else if (expression.arguments.length > 2)
-                        fail('Vars.define accepts a third argument only with a derived callback.', expression);
-                    const original = variableSet
-                        ? VariableSets.theme(VariableSets.build(input, Object.freeze({ variableSet: true, [Token.identity]: name })))
-                        : Theme.define(input);
-                    definition = Token.bind(original, Object.freeze({
-                        ...original[Token.definition].contract,
-                        [Token.identity]: name,
-                    }));
-                }
-                else {
-                    const base = expression.arguments[0];
-                    const parent = base ? resolve(base)?.call : undefined;
-                    const derive = variableSet
-                        ? derivation(expression.arguments[2])
-                        : undefined;
-                    const arity = derive ? 3 : 2;
-                    // A trailing options object names a new set over the base's variables.
-                    const id = expression.arguments.length === arity + 1
-                        ? Identifiers.explicit(expression, arity)
-                        : undefined;
-                    const named = id !== undefined;
-                    if ((expression.arguments.length !== arity && !named) ||
-                        !parent)
-                        fail('Vars.extend requires a preceding variable set and literal overrides.', expression);
-                    factoryReferences.add(base.start);
-                    tokenType = parent.tokenType;
-                    output = parent.output;
-                    if (variableSet) {
-                        const theme = themes[parent.name];
-                        const original = VariableSets.from(theme[Token.definition]);
-                        const extend = Vars.extend;
-                        const extended = extend(original, data(expression.arguments[1]), (vars) => derive
-                            ? data(derive.body, {
-                                name: derive.name,
-                                vars: vars,
-                            })
-                            : {}, { id });
-                        definition = named
-                            ? Token.bind(VariableSets.theme(extended), Object.freeze({
-                                ...extended[Token.definition].contract,
-                                [Token.identity]: name,
-                            }))
-                            : VariableSets.theme(extended);
-                        const metadata = definition[Token.definition];
-                        // Additions grow the token contract; overridden leaves keep their base types, as in `Vars.extend`.
-                        if (named ||
-                            Object.keys(metadata.values).length !==
-                                Object.keys(theme[Token.definition].values).length ||
-                            JSON.stringify(metadata.queries) !==
-                                JSON.stringify(theme[Token.definition].queries))
-                            tokenType = Configurations.type({
-                                ...extendedValues(theme, definition),
-                                ...metadata.queries,
-                            });
-                    }
-                    else
-                        definition = Theme.extend(themes[parent.name], data(expression.arguments[1]));
-                    // Extensions share their base identity, so the binding keeps sibling sets distinct.
-                    if (!named &&
-                        definition[Token.definition].contract[Token.identity]?.startsWith('id-'))
-                        name = `${definition.className.slice('z-theme-'.length)}-${binding}`;
-                }
-            }
-            catch (error) {
-                if (error instanceof InvalidError)
-                    throw error;
-                if (!(error instanceof Theme.InvalidError) &&
-                    !(error instanceof Vars.InvalidError))
-                    throw error;
-                fail(error.message, expression);
-            }
-            const call = Object.freeze({
-                ...(variableSet
-                    ? {
-                        variableSet: true,
-                        directVariables: true,
-                        type: `import('zyzz').Vars.Definition<${tokenType}>`,
-                    }
-                    : {}),
-                ...(output ? { output } : {}),
-                end: expression.end,
-                name,
-                start: expression.start,
-                tokenType,
-                ...(definition[Token.definition].contract.shorthands ||
-                    output === 'html'
-                    ? {
-                        type: `import('zyzz').Config.create.ReturnType<{theme:${tokenType};${output === 'html' ? "output:'html';" : ''}shorthands:${Configurations.type(definition[Token.definition].contract.shorthands ?? {})}}>['theme']`,
-                    }
-                    : {}),
-            });
-            definition = Token.bind(definition, definition[Token.definition].contract, binding);
-            calls.push(call);
-            definitions.set(variable.id.start, call);
-            factories.add(expression.start);
-            names.set(binding, call);
-            themes[name] = definition;
-            if (statement.type === 'ExportNamedDeclaration')
-                exports[binding] = {
-                    binding: name,
-                    call,
-                    definition,
-                    kind: 'theme',
-                };
-        }
-    }
-    function registerAlias(input) {
-        const { declaration, statement, variable } = input;
-        const expression = variable.init;
-        if (!expression)
-            return;
-        const linked = resolve(expression);
-        if (linked?.kind === 'config' && variable.id.type === 'ObjectPattern') {
-            if (statement.type === 'ExportNamedDeclaration' && !options.linked)
-                fail('Exported configuration destructuring requires source linking.', variable);
-            if (declaration.kind !== 'const')
-                fail('Configuration destructuring requires const bindings.', variable);
-            const link = linked;
-            const bindings = variable.id.properties.map((property) => {
-                if (property.type !== 'Property' ||
-                    property.computed ||
-                    property.key.type !== 'Identifier' ||
-                    property.value.type !== 'Identifier')
-                    return fail('Configuration destructuring requires named bindings without defaults or rest.', property);
-                return { key: property.key.name, id: property.value };
-            });
-            aliasReferences.add(expression.start);
-            aliases.push({
-                ...link.call,
-                start: expression.start,
-                end: expression.end,
-                destructured: false,
-                retained: true,
-            });
-            for (const { key, id } of bindings) {
-                if (key === 'Provider' &&
-                    link.call.nativeProvider &&
-                    !link.call.initialization &&
-                    !link.call.root &&
-                    !link.call.selection)
-                    continue;
-                if ((key === 'style' || key === 'variants') &&
-                    !link.call.selection &&
-                    !link.call.initialization) {
-                    const alias = {
-                        ...link.call,
-                        recipe: key === 'variants',
-                        destructured: false,
-                    };
-                    aliasBindings.set(id.start, alias);
-                    aliasNames.set(id.name, alias);
-                    if (statement.type === 'ExportNamedDeclaration')
-                        exports[id.name] = {
-                            ...link,
-                            binding: `${options.namespace}-${id.name}`,
-                            call: alias,
-                            kind: 'style',
-                        };
-                    continue;
-                }
-                if (!link.call.selection &&
-                    !link.call.initialization &&
-                    !link.call.root &&
-                    (key === 'script' ||
-                        key === 'appearance' ||
-                        (key === 'themes' && link.call.options?.themes) ||
-                        (key === 'vars' && link.call.variableConfig))) {
-                    if ((key === 'script' && !link.call.script) ||
-                        (key === 'appearance' && !link.call.appearance) ||
-                        link.call.selection ||
-                        link.call.initialization)
-                        fail('This configuration helper is not available on the linked contract.', id);
-                    if (key === 'script')
-                        scripts.add(link.call.name);
-                    if (key === 'appearance')
-                        appearances.add(link.call.name);
-                    if (key === 'themes' || key === 'vars')
-                        selections.add(link.call.name);
-                    const members = Object.fromEntries(Object.entries(link.members ?? {}).flatMap(([pathKey, member]) => {
-                        const path = JSON.parse(pathKey);
-                        return (key === 'themes' || key === 'vars') &&
-                            (path[0] === 'themes' || path[0] === 'vars')
-                            ? [[JSON.stringify(path.slice(1)), member]]
-                            : [];
-                    }));
-                    const selection = {
-                        ...link,
-                        members,
-                        call: {
-                            ...link.call,
-                            members: Object.fromEntries(Object.entries(members).map(([key, member]) => [
-                                key,
-                                member.call.name,
-                            ])),
-                            ...helper(key),
-                            type: `${link.call.type}['${key}']`,
-                        },
-                    };
-                    configs.set(id.name, selection);
-                    configBindings.set(id.start, selection);
-                    if (statement.type === 'ExportNamedDeclaration')
-                        exports[id.name] = selection;
-                    continue;
-                }
-                if (link.call.variableConfig && ['theme', 'themes'].includes(key))
-                    fail('Use vars for references and scope selection.', id);
-                const member = link.members?.[JSON.stringify([key])];
-                if (!member)
-                    fail('Destructure only style and the configured single theme; other helpers remain unsupported.', id);
-                definitions.set(id.start, member.call);
-                names.set(id.name, member.call);
-                if (statement.type === 'ExportNamedDeclaration')
-                    exports[id.name] = member;
-            }
-            return;
-        }
-        if (linked && variable.id.type === 'Identifier') {
-            if (expression.start < linked.call.end)
-                fail('Authoring aliases must follow their definition.', expression);
-            if (declaration.kind !== 'const' ||
-                (statement.type === 'ExportNamedDeclaration' && !options.linked))
-                fail('Authoring aliases require module-level const bindings.', variable);
-            if (linked.kind === 'config') {
-                configs.set(variable.id.name, linked);
-                configBindings.set(variable.id.start, linked);
-            }
-            else {
-                names.set(variable.id.name, linked.call);
-                definitions.set(variable.id.start, linked.call);
-            }
-            aliases.push({
-                ...linked.call,
-                start: expression.start,
-                end: expression.end,
-                destructured: false,
-                retained: true,
-            });
-            aliasReferences.add(expression.start);
-            if (statement.type === 'ExportNamedDeclaration')
-                exports[variable.id.name] = linked;
-            return;
-        }
-        const member = (() => {
-            if (expression.type === 'MemberExpression' &&
-                !expression.computed &&
-                !expression.optional &&
-                expression.property.type === 'Identifier' &&
-                ['style', 'variants'].includes(expression.property.name)) {
-                return expression.object;
-            }
-            return undefined;
-        })();
-        const destructured = variable.id.type === 'ObjectPattern' && expression.type === 'Identifier';
-        const source = member ?? (expression.type === 'Identifier' ? expression : undefined);
-        if (!source)
-            return;
-        const theme = (() => {
-            if (member || destructured) {
-                return resolve(source)?.call;
-            }
-            if (source.type === 'Identifier') {
-                return aliasNames.get(source.name);
-            }
-            return undefined;
-        })();
-        if (!theme)
-            return;
-        const bindings = (() => {
-            if (destructured && variable.id.type === 'ObjectPattern') {
-                if (!variable.id.properties.length)
-                    fail('Theme destructuring requires an authoring binding.', variable.id);
-                return variable.id.properties.map((property) => {
-                    if (property.type !== 'Property' ||
-                        property.computed ||
-                        property.key.type !== 'Identifier' ||
-                        (property.key.name !== 'style' &&
-                            property.key.name !== 'variants') ||
-                        property.value.type !== 'Identifier')
-                        fail('Destructure only style or variants into const bindings without defaults or rest properties.', property);
-                    return { id: property.value, member: property.key.name };
-                });
-            }
-            if (variable.id.type !== 'Identifier')
-                fail('Theme authoring aliases require named const bindings.', variable);
-            const recipe = expression.type === 'MemberExpression' &&
-                expression.property.type === 'Identifier'
-                ? expression.property.name === 'variants'
-                : theme.recipe;
-            return [
-                {
-                    id: variable.id,
-                    member: recipe ? 'variants' : 'style',
-                },
-            ];
-        })();
-        if (declaration.kind !== 'const' ||
-            (statement.type === 'ExportNamedDeclaration' && !options.linked))
-            fail('Theme style aliases require a local module-level const binding.', variable);
-        if (expression.start < theme.end)
-            fail('Theme style aliases must follow their definition.', expression);
-        for (const [index, { id, member }] of bindings.entries()) {
-            const alias = Object.freeze({
-                recipe: member === 'variants',
-                destructured,
-                end: expression.end,
-                name: theme.name,
-                start: expression.start,
-                tokenType: theme.tokenType,
-                type: theme.type,
-                options: theme.options,
-                variableConfig: theme.variableConfig,
-                variableMappings: theme.variableMappings,
-                output: theme.output,
-            });
-            // Each local/exported name keeps its own callable identity, while the
-            // shared initializer is rewritten once with every destructured member.
-            if (index === 0)
-                aliases.push({
-                    ...alias,
-                    bindings: bindings.map(({ member }) => member),
-                });
-            aliasBindings.set(id.start, alias);
-            aliasNames.set(id.name, alias);
-            if (statement.type === 'ExportNamedDeclaration')
-                exports[id.name] = {
-                    binding: `${options.namespace}-${id.name}`,
-                    call: alias,
-                    definition: themes[alias.name],
-                    kind: 'style',
-                };
-        }
-        aliasReferences.add(source.start);
-    }
-    const exportReferences = new Set();
-    if (options.linked)
-        for (const statement of program.body) {
-            if (statement.type !== 'ExportNamedDeclaration' ||
-                statement.source ||
-                statement.exportKind === 'type')
-                continue;
-            for (const specifier of statement.specifiers) {
-                if (specifier.exportKind === 'type')
-                    continue;
-                const name = specifier.local.type === 'Identifier'
-                    ? specifier.local.name
-                    : specifier.local.value;
-                const call = configs.get(name)?.call ?? names.get(name) ?? aliasNames.get(name);
-                if (!call)
-                    continue;
-                const exported = specifier.exported.type === 'Identifier'
-                    ? specifier.exported.name
-                    : specifier.exported.value;
-                exports[exported] = configs.get(name) ??
-                    options.links?.[name] ?? {
-                    binding: `${options.namespace}-${name}`,
-                    call,
-                    definition: themes[call.name],
-                    kind: names.has(name) ? 'theme' : 'style',
-                };
-                exportReferences.add(specifier.local.start);
-            }
-        }
-    function reference(node, parent, ancestors, binding, lookup) {
-        const grandparent = ancestors.at(-3);
-        if (binding?.type === 'Import' &&
-            (imports.has(binding.node.start) ||
-                configImports.has(binding.node.start) ||
-                factoryImports.has(binding.node.start))) {
-            if (factoryImports.has(binding.node.start) &&
-                parent.type === 'CallExpression' &&
-                factories.has(parent.start))
-                return true;
-            if (parent.type === 'MemberExpression' &&
-                grandparent?.type === 'CallExpression' &&
-                (factories.has(grandparent.start) ||
-                    factoryReferences.has(parent.start)))
-                return true;
-            fail('Theme factories require direct module-level const declarations; aliases and indirect references require source linking.', node);
-        }
-        const alias = binding?.type === 'Variable' || binding?.type === 'Import'
-            ? aliasBindings.get(binding.node.start)
-            : undefined;
-        if (alias) {
-            if (node.start === binding.node.start ||
-                exportReferences.has(node.start))
-                return true;
-            if (node.start < alias.end)
-                fail('Theme style alias references must follow their definition.', node);
-            if (aliasReferences.has(node.start))
-                return true;
-            if (parent.type !== 'CallExpression' ||
-                parent.callee !== node ||
-                parent.optional)
-                fail('Theme style aliases support direct calls only; exporting or escaping them requires source linking.', node);
-            styles.set(parent.start, {
-                call: parent,
-                recipe: alias.recipe,
-                theme: themes[alias.name],
-                output: alias.output ??
-                    (alias.options?.output === 'html' ? 'html' : undefined),
-            });
-            return true;
-        }
-        const config = binding?.type === 'Variable' || binding?.type === 'Import'
-            ? configBindings.get(binding.node.start)
-            : undefined;
-        if (config) {
-            if (node.start === binding.node.start)
-                return true;
-            if (exportReferences.has(node.start) || aliasReferences.has(node.start))
-                return true;
-            if (node.start < config.call.end &&
-                config.call.start >= 0 &&
-                binding?.type !== 'Import')
-                fail('Configuration references must follow their definition.', node);
-            if (config.call.variableConfig &&
-                config.call.selection &&
-                readVars(node, parent, config, lookup))
-                return true;
-            // Root controls are an ordinary runtime object; any read or call is valid.
-            if (config.call.root) {
-                appearances.add(config.call.name);
-                return true;
-            }
-            if ((config.call.selection || config.call.initialization) &&
-                parent.type === 'CallExpression' &&
-                parent.callee === node &&
-                !parent.optional) {
-                if (config.call.selection && config.call.catalogOnly)
-                    fail('This legacy catalog is not callable; rebuild its library.', node);
-                if (config.call.selection) {
-                    selections.add(config.call.name);
-                    selectionUses.add(config.call.name);
-                    scopeApplications.set(parent.start, {
-                        end: parent.end,
-                        output: config.call.options?.output === 'html' ? 'html' : undefined,
-                    });
-                }
-                if (config.call.initialization)
-                    scripts.add(config.call.name);
-                return true;
-            }
-            let target = node;
-            const path = [];
-            for (let index = ancestors.length - 2; index >= 0; index--) {
-                const member = ancestors[index];
-                if (member.type !== 'MemberExpression' ||
-                    member.object !== target ||
-                    member.optional)
-                    break;
-                const key = (() => {
-                    if (member.property.type === 'Identifier' && !member.computed) {
-                        return member.property.name;
-                    }
-                    if (member.property.type === 'Literal' &&
-                        member.computed &&
-                        (typeof member.property.value === 'string' ||
-                            typeof member.property.value === 'number')) {
-                        return String(member.property.value);
-                    }
-                    return undefined;
-                })();
-                if (key === undefined)
-                    break;
-                path.push(key);
-                target = member;
-                if (path.length === 1 &&
-                    path[0] === 'Provider' &&
-                    config.call.nativeProvider &&
-                    !config.call.initialization &&
-                    !config.call.root &&
-                    !config.call.selection)
-                    return true;
-                if (config.call.variableConfig &&
-                    path.length === 1 &&
-                    path[0] === 'vars' &&
-                    readVars(target, ancestors[index - 1], config, lookup))
-                    return true;
-                if (aliasReferences.has(target.start) ||
-                    factoryReferences.has(target.start))
-                    return true;
-                if (path.length === 1 &&
-                    path[0] === 'appearance' &&
-                    !config.call.selection &&
-                    !config.call.initialization) {
-                    if (!config.call.appearance)
-                        fail('This packed configuration does not provide appearance; rebuild its library with root control support.', target);
-                    appearances.add(config.call.name);
-                    return true;
-                }
-                if (path.length === 1 &&
-                    !config.call.selection &&
-                    !config.call.initialization &&
-                    ['script', 'themes', 'vars'].includes(path[0]) &&
-                    ancestors[index - 1]?.type === 'CallExpression' &&
-                    ancestors[index - 1].callee === target &&
-                    !ancestors[index - 1].optional) {
-                    if (path[0] === 'vars' && !config.call.variableConfig)
-                        fail('This configuration has no vars.', target);
-                    if (path[0] === 'themes' && !config.call.options?.themes)
-                        fail('Theme selection requires a named catalog.', target);
-                    if ((path[0] === 'themes' || path[0] === 'vars') &&
-                        config.call.catalogOnly)
-                        fail('This legacy catalog is not callable; rebuild its library.', target);
-                    if (path[0] === 'script') {
-                        if (!config.call.script)
-                            fail('This packed configuration does not provide script(); rebuild its library with initialization support.', target);
-                        scripts.add(config.call.name);
-                    }
-                    if (path[0] === 'themes' || path[0] === 'vars') {
-                        selections.add(config.call.name);
-                        selectionUses.add(config.call.name);
-                        const application = ancestors[index - 1];
-                        scopeApplications.set(application.start, {
-                            end: application.end,
-                            output: config.call.options?.output === 'html' ? 'html' : undefined,
-                        });
-                    }
-                    return true;
-                }
-                if (path.length === 1 &&
-                    (path[0] === 'style' || path[0] === 'variants')) {
-                    const call = ancestors[index - 1];
-                    if (call?.type !== 'CallExpression' ||
-                        call.callee !== target ||
-                        call.optional)
-                        break;
-                    styles.set(call.start, {
-                        call,
-                        recipe: path[0] === 'variants',
-                        theme: config.definition,
-                        output: config.call.options?.output === 'html' ? 'html' : undefined,
-                    });
-                    return true;
-                }
-                if (config.call.variableConfig &&
-                    ['theme', 'themes'].includes(path[0]))
-                    fail('Use vars for references and scope selection.', target);
-                const linked = config.call.variableConfig && config.call.selection
-                    ? undefined
-                    : config.members?.[JSON.stringify(path)];
-                if (linked)
-                    return themeReference(target, ancestors[index - 1], ancestors.slice(0, index + 1), linked.call);
-            }
-            if (config.call.selection && config.call.variableConfig && path.length)
-                return themeReference(node, parent, ancestors, {
-                    ...config.call,
-                    directVariables: true,
-                });
-            // A compiled selector is an ordinary runtime function, so passing or storing it is safe.
-            if (config.call.selection && !config.call.catalogOnly && !path.length) {
-                selections.add(config.call.name);
-                selectionUses.add(config.call.name);
-                return true;
-            }
-            fail('Use direct configuration style calls or static theme members; configurations cannot escape or be mutated.', node);
-        }
-        const theme = binding?.type === 'Variable' || binding?.type === 'Import'
-            ? definitions.get(binding.node.start)
-            : undefined;
-        if (!theme)
-            return false;
-        if (node.start === binding.node.start)
-            return true;
-        if (theme.variableSet &&
-            readVars(node, parent, {
-                call: theme,
-                definition: themes[theme.name],
-            }, lookup))
-            return true;
-        return themeReference(node, parent, ancestors, theme);
-    }
-    function readVars(node, parent, link, lookup) {
-        if (!options.native ||
-            parent.type !== 'CallExpression' ||
-            parent.optional ||
-            parent.arguments[0] !== node)
-            return false;
-        const callee = parent.callee;
-        const name = callee.type === 'Identifier'
-            ? callee.name
-            : callee.type === 'MemberExpression' &&
-                !callee.computed &&
-                !callee.optional &&
-                callee.object.type === 'Identifier' &&
-                callee.property.type === 'Identifier' &&
-                ['useAnimatedVars', 'useVars'].includes(callee.property.name)
-                ? callee.object.name
-                : undefined;
-        const binding = name === undefined ? undefined : lookup(name);
-        if (binding?.type !== 'Import' ||
-            ![
-                'zyzz/react-native',
-                'zyzz/react-native/reanimated',
-                'zyzz/react-native/react',
-            ].includes(binding.importNode.source.value) ||
-            binding.importNode.importKind === 'type')
-            return false;
-        const specifier = binding.node;
-        if (callee.type === 'Identifier'
-            ? specifier.type !== 'ImportSpecifier' ||
-                specifier.importKind === 'type' ||
-                !['useAnimatedVars', 'useVars'].includes(specifier.imported.type === 'Identifier'
-                    ? specifier.imported.name
-                    : specifier.imported.value)
-            : specifier.type !== 'ImportNamespaceSpecifier')
-            return false;
-        varsReads.push({ ...varsRead(link), end: node.end, start: node.start });
-        return true;
-    }
-    function themeReference(node, parent, ancestors, theme) {
-        const grandparent = ancestors.at(-3);
-        if (factoryReferences.has(node.start) ||
-            ancestors.some((ancestor) => factoryReferences.has(ancestor.start)))
-            return true;
-        if (exportReferences.has(node.start))
-            return true;
-        if (aliasReferences.has(node.start))
-            return true;
-        if (node.start < theme.end)
-            fail('Theme references must follow their local definition.', node);
-        if (parent.type === 'CallExpression' &&
-            factories.has(parent.start) &&
-            parent.arguments[0] === node)
-            return true;
-        if (parent.type === 'MemberExpression' &&
-            parent.object === node &&
-            (theme.directVariables ||
-                (parent.property.type === 'Identifier' &&
-                    !parent.computed &&
-                    ['tokens', 'vars'].includes(parent.property.name)) ||
-                (parent.property.type === 'Literal' &&
-                    parent.computed &&
-                    ['tokens', 'vars'].includes(String(parent.property.value))))) {
-            if (parent.optional)
-                fail('Token references cannot use optional access.', parent);
-            const variable = theme.directVariables ||
-                (parent.property.type === 'Identifier'
-                    ? parent.property.name === 'vars'
-                    : parent.property.type === 'Literal' &&
-                        parent.property.value === 'vars');
-            let value = variable && !theme.directVariables
-                ? themes[theme.name].vars
-                : themes[theme.name].tokens;
-            let target = theme.directVariables ? node : parent;
-            let index = ancestors.length - (theme.directVariables ? 2 : 3);
-            for (; index >= 0; index--) {
-                const ancestor = ancestors[index];
-                if (ancestor.type !== 'MemberExpression' || ancestor.object !== target)
-                    break;
-                const key = (() => {
-                    if (ancestor.property.type === 'Identifier' && !ancestor.computed) {
-                        return ancestor.property.name;
-                    }
-                    if (ancestor.property.type === 'Literal' &&
-                        ancestor.computed &&
-                        (typeof ancestor.property.value === 'string' ||
-                            typeof ancestor.property.value === 'number')) {
-                        return String(ancestor.property.value);
-                    }
-                    return undefined;
-                })();
-                if (ancestor.optional || key === undefined)
-                    fail('Token paths require static property names without optional access.', ancestor);
-                value =
-                    value && typeof value === 'object' && !Token.is(value)
-                        ? Object.getOwnPropertyDescriptor(value, key)?.value
-                        : undefined;
-                if (value === undefined)
-                    fail('Unknown theme token path.', ancestor);
-                target = ancestor;
-            }
-            if (!Token.is(value))
-                fail('Expected a scalar theme token reference.', target);
-            const reference = value;
-            for (; index >= 0; index--) {
-                const ancestor = ancestors[index];
-                if ((ancestor.type === 'TSAsExpression' ||
-                    ancestor.type === 'TSSatisfiesExpression' ||
-                    ancestor.type === 'TSNonNullExpression' ||
-                    ancestor.type === 'TSTypeAssertion') &&
-                    ancestor.expression === target)
-                    target = ancestor;
-                else
-                    break;
-            }
-            const valueTarget = target;
-            if (variable) {
-                while (index >= 0) {
-                    const ancestor = ancestors[index];
-                    if (!((ancestor.type === 'TemplateLiteral' &&
-                        ancestor.expressions.includes(target)) ||
-                        ((ancestor.type === 'TSAsExpression' ||
-                            ancestor.type === 'TSSatisfiesExpression' ||
-                            ancestor.type === 'TSNonNullExpression' ||
-                            ancestor.type === 'TSTypeAssertion') &&
-                            ancestor.expression === target)))
-                        break;
-                    target = ancestor;
-                    index--;
-                }
-            }
-            const array = ancestors[index];
-            if (array?.type === 'ArrayExpression' &&
-                array.elements.includes(target)) {
-                target = array;
-                index--;
-                for (; index >= 0; index--) {
-                    const ancestor = ancestors[index];
-                    if ((ancestor.type === 'TSAsExpression' ||
-                        ancestor.type === 'TSSatisfiesExpression' ||
-                        ancestor.type === 'TSNonNullExpression' ||
-                        ancestor.type === 'TSTypeAssertion') &&
-                        ancestor.expression === target)
-                        target = ancestor;
-                    else
-                        break;
-                }
-            }
-            const property = ancestors[index];
-            const object = ancestors[index - 1];
-            let argument = object;
-            let callIndex = index - 2;
-            for (; callIndex >= 0; callIndex--) {
-                const ancestor = ancestors[callIndex];
-                if (ancestor.type === 'Property' &&
-                    ancestor.value === argument &&
-                    ancestors[callIndex - 1]?.type === 'ObjectExpression') {
-                    argument = ancestors[--callIndex];
-                    continue;
-                }
-                if ((ancestor.type === 'TSAsExpression' ||
-                    ancestor.type === 'TSSatisfiesExpression' ||
-                    ancestor.type === 'TSNonNullExpression' ||
-                    ancestor.type === 'TSTypeAssertion') &&
-                    ancestor.expression === argument)
-                    argument = ancestor;
-                else
-                    break;
-            }
-            if (ancestors[callIndex]?.type === 'ArrowFunctionExpression' &&
-                ancestors[callIndex].body === argument) {
-                argument = ancestors[callIndex];
-                callIndex--;
-            }
-            while (callIndex >= 0) {
-                const wrapper = ancestors[callIndex];
-                if ((wrapper.type === 'TSAsExpression' ||
-                    wrapper.type === 'TSSatisfiesExpression' ||
-                    wrapper.type === 'TSNonNullExpression' ||
-                    wrapper.type === 'TSTypeAssertion') &&
-                    wrapper.expression === argument) {
-                    argument = wrapper;
-                    callIndex--;
-                }
-                else
-                    break;
-            }
-            const call = ancestors[callIndex];
-            if (property?.type !== 'Property' ||
-                property.value !== target ||
-                object?.type !== 'ObjectExpression' ||
-                call?.type !== 'CallExpression' ||
-                call.arguments[0] !== argument ||
-                (!styles.has(call.start) && !options.contributionCalls?.has(call.start))) {
-                if (ancestors.some((node) => node.type === 'VariableDeclarator' &&
-                    options.staticBindings?.has(node.start)))
-                    staticTokens.push(valueTarget);
-                else
-                    fail('Token references must be direct property values in bound theme style calls.', target);
-            }
-            tokens.set(valueTarget.start, { end: valueTarget.end, reference });
-            const unwrapped = Expression.unwrap(valueTarget);
-            tokens.set(unwrapped.start, { end: unwrapped.end, reference });
-            return true;
-        }
-        if (parent.type !== 'MemberExpression' ||
-            parent.object !== node ||
-            parent.computed ||
-            parent.optional ||
-            parent.property.type !== 'Identifier')
-            fail('Use Config.create or Vars.extend with variable definitions; other references require source linking.', node);
-        if (['style', 'variants'].includes(parent.property.name) &&
-            grandparent?.type === 'CallExpression' &&
-            grandparent.callee === parent &&
-            !grandparent.optional) {
-            styles.set(grandparent.start, {
-                call: grandparent,
-                recipe: parent.property.name === 'variants',
-                theme: themes[theme.name],
-                output: theme.output,
-            });
-            return true;
-        }
-        if (parent.property.name !== 'className')
-            fail('Only direct theme.style calls and theme.className reads are supported here.', parent);
-        let target = parent;
-        for (let index = ancestors.length - 3; index >= 0; index--) {
-            const ancestor = ancestors[index];
-            if ((ancestor.type === 'AssignmentExpression' &&
-                ancestor.left === target) ||
-                (ancestor.type === 'UpdateExpression' &&
-                    ancestor.argument === target) ||
-                (ancestor.type === 'UnaryExpression' &&
-                    ancestor.operator === 'delete') ||
-                ((ancestor.type === 'ForInStatement' ||
-                    ancestor.type === 'ForOfStatement') &&
-                    ancestor.left === target))
-                fail('Theme scope properties cannot be reassigned.', ancestor);
-            if (((ancestor.type === 'TSAsExpression' ||
-                ancestor.type === 'TSNonNullExpression' ||
-                ancestor.type === 'TSSatisfiesExpression' ||
-                ancestor.type === 'TSTypeAssertion') &&
-                ancestor.expression === target) ||
-                (ancestor.type === 'Property' && ancestor.value === target) ||
-                ancestor.type === 'ObjectPattern' ||
-                ancestor.type === 'ArrayPattern' ||
-                (ancestor.type === 'RestElement' && ancestor.argument === target) ||
-                (ancestor.type === 'AssignmentPattern' && ancestor.left === target))
-                target = ancestor;
-            else
-                break;
-        }
-        references.push(Object.freeze({ end: parent.end, name: theme.name, start: parent.start }));
-        return true;
-    }
-    for (const link of Object.values(exports))
-        if (link.kind === 'config' &&
-            !link.call.selection &&
-            !link.call.initialization &&
-            !link.call.root) {
-            if (link.call.script)
-                scripts.add(link.call.name);
-            if (link.call.appearance)
-                appearances.add(link.call.name);
-        }
-    const nativeContexts = new Map();
-    return {
-        nativeContext(start, end) {
-            const theme = styles.get(start)?.theme;
-            const contract = theme?.[Token.definition].contract ??
-                [...tokens].find(([offset]) => offset >= start && offset < end)?.[1]
-                    .reference.contract;
-            if (!contract)
-                return undefined;
-            const cached = nativeContexts.get(contract);
-            if (cached)
-                return cached;
-            const config = [...configs.values()].find((value) => value.definition[Token.definition].contract === contract);
-            if (!config?.call.options?.themes) {
-                const alias = [...aliasNames.values()].find((value) => themes[value.name]?.[Token.definition].contract === contract &&
-                    value.options?.themes);
-                if (!alias?.options?.themes)
-                    return undefined;
-                const context = {
-                    defaultVars: String(alias.options.defaultTheme),
-                    vars: Object.fromEntries(Object.entries(alias.options.themes).map(([name, values]) => [
-                        name,
-                        Token.bind(contract.variableSet
-                            ? VariableSets.theme(Vars.define(values))
-                            : Theme.define(values), contract),
-                    ])),
-                };
-                Object.freeze(context.vars);
-                nativeContexts.set(contract, Object.freeze(context));
-                return context;
-            }
-            const entries = Object.entries(config.members ?? {}).flatMap(([key, value]) => {
-                const path = JSON.parse(key);
-                if (config.call.selection && path.length === 1)
-                    return [[path[0], value.definition]];
-                return (path[0] === 'themes' || path[0] === 'vars') &&
-                    path.length === 2
-                    ? [[path[1], value.definition]]
-                    : [];
-            });
-            const context = Object.freeze({
-                defaultVars: String(config.call.options.defaultTheme),
-                vars: Object.freeze(Object.fromEntries(entries)),
-            });
-            nativeContexts.set(contract, context);
-            return context;
-        },
-        aliases,
-        appearances,
-        calls,
-        exports: Object.freeze(exports),
-        reference,
-        references,
-        scopeApplications,
-        scripts,
-        selections,
-        selectionUses,
-        staticTokens,
-        styles,
-        themes: Object.freeze(themes),
-        tokens,
-        varsReads,
-    };
-}
-/** Located failure from unsupported or invalid local theme syntax. */
-export class InvalidError extends Error {
-    /** Retains a source span for the public extractor diagnostic. */
-    constructor(message, node) {
-        super(message);
-        this.end = node.end;
-        this.start = node.start;
-    }
-    /** Exclusive source offset. */
-    end;
-    /** Namespaced diagnostic identity. */
-    name = 'Source.ThemeInvalidError';
-    /** Inclusive source offset. */
-    start;
-}
-//# sourceMappingURL=Themes.js.map