@wyw-in-js/transform 2.0.0-alpha.0 → 2.0.0

package/types/utils/applyOxcProcessors/expressionValues.d.ts

@@ -0,0 +1,11 @@
+import type { Param, Params, SourceLocation } from '@wyw-in-js/processor-utils';
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { Expression, TaggedTemplateExpression } from 'oxc-parser';
+import type { LocationLookup, ProcessorUsage } from './types';
+export declare const literalExpressionValue: (expression: Expression, code: string, source: string, location: SourceLocation) => ExpressionValue | null;
+export declare const expressionValue: (expression: Expression, code: string, loc: LocationLookup, filename?: string | null) => ExpressionValue;
+export declare const withCurrentExpressionLocation: (value: ExpressionValue, expression: Expression, loc: LocationLookup, filename?: string | null) => ExpressionValue;
+export declare const shiftExpressionValue: (expressionValues: ExpressionValue[], expression: Expression, code: string, loc: LocationLookup, filename?: string | null) => ExpressionValue;
+export declare const zipTemplate: (template: TaggedTemplateExpression, code: string, loc: LocationLookup, filename: string | null | undefined, expressionValues: ExpressionValue[]) => Param;
+export declare const buildCalleeParams: (node: Expression, code: string, loc: LocationLookup, filename: string | null | undefined, expressionValues: ExpressionValue[], collapseQualifiedCallee?: boolean) => Params | null;
+export declare const buildParams: (usage: ProcessorUsage, code: string, loc: LocationLookup, filename: string | null | undefined, expressionValues: ExpressionValue[], collapseQualifiedCallee: boolean) => Params | null;

package/types/utils/applyOxcProcessors/expressionValues.js

@@ -0,0 +1,170 @@
+import { ValueType } from '@wyw-in-js/shared';
+import { isNotNull } from '../isNotNull';
+import { buildOxcCodeFrameError } from '../oxc/sourceLocations';
+import { getMemberName, unwrapQualifiedExpression } from './processorUsages';
+import { GENERATED_HELPER_NAME_RE, getSourceLocation } from './shared';
+export const literalExpressionValue = (expression, code, source, location) => {
+    if (expression.type !== 'Literal') {
+        return null;
+    }
+    if (expression.value === null ||
+        typeof expression.value === 'string' ||
+        typeof expression.value === 'number' ||
+        typeof expression.value === 'boolean') {
+        let type;
+        if (expression.value === null) {
+            type = 'NullLiteral';
+        }
+        else if (typeof expression.value === 'string') {
+            type = 'StringLiteral';
+        }
+        else if (typeof expression.value === 'number') {
+            type = 'NumericLiteral';
+        }
+        else {
+            type = 'BooleanLiteral';
+        }
+        const ex = expression.value === null
+            ? { loc: location, type }
+            : {
+                loc: location,
+                type,
+                value: expression.value,
+            };
+        return {
+            buildCodeFrameError: (message) => buildOxcCodeFrameError(code, location, message),
+            ex,
+            kind: ValueType.CONST,
+            source,
+            value: expression.value,
+        };
+    }
+    return null;
+};
+export const expressionValue = (expression, code, loc, filename) => {
+    const source = code.slice(expression.start, expression.end);
+    const location = getSourceLocation(expression.start, expression.end, loc, filename);
+    const literal = literalExpressionValue(expression, code, source, location);
+    if (literal) {
+        return literal;
+    }
+    const helperCallName = expression.type === 'CallExpression' &&
+        expression.arguments.length === 0 &&
+        expression.callee.type === 'Identifier' &&
+        GENERATED_HELPER_NAME_RE.test(expression.callee.name)
+        ? expression.callee.name
+        : null;
+    let ex;
+    if (expression.type === 'Identifier') {
+        ex = { loc: location, name: expression.name, type: 'Identifier' };
+    }
+    else if (helperCallName) {
+        ex = { loc: location, name: helperCallName, type: 'Identifier' };
+    }
+    else {
+        ex = {
+            loc: location,
+            name: code.slice(expression.start, expression.end),
+            type: 'Identifier',
+        };
+    }
+    return {
+        buildCodeFrameError: (message) => buildOxcCodeFrameError(code, location, message),
+        ex,
+        kind: expression.type === 'ArrowFunctionExpression' ||
+            expression.type === 'FunctionExpression'
+            ? ValueType.FUNCTION
+            : ValueType.LAZY,
+        source,
+    };
+};
+export const withCurrentExpressionLocation = (value, expression, loc, filename) => {
+    const location = getSourceLocation(expression.start, expression.end, loc, filename);
+    if (value.kind === ValueType.CONST) {
+        return {
+            ...value,
+            ex: {
+                ...value.ex,
+                loc: location,
+            },
+        };
+    }
+    if (value.kind === ValueType.FUNCTION) {
+        return {
+            ...value,
+            ex: {
+                ...value.ex,
+                loc: location,
+            },
+        };
+    }
+    return {
+        ...value,
+        ex: {
+            ...value.ex,
+            loc: location,
+        },
+    };
+};
+export const shiftExpressionValue = (expressionValues, expression, code, loc, filename) => expressionValues.length > 0
+    ? withCurrentExpressionLocation(expressionValues.shift(), expression, loc, filename)
+    : expressionValue(expression, code, loc, filename);
+export const zipTemplate = (template, code, loc, filename, expressionValues) => {
+    const parts = template.quasi.quasis.flatMap((quasi, idx) => {
+        const expression = template.quasi.expressions[idx];
+        const templateElement = {
+            ...quasi,
+            loc: getSourceLocation(quasi.start, quasi.end, loc, filename),
+        };
+        return [
+            templateElement,
+            expression
+                ? shiftExpressionValue(expressionValues, expression, code, loc, filename)
+                : null,
+        ].filter(isNotNull);
+    });
+    return ['template', parts];
+};
+export const buildCalleeParams = (node, code, loc, filename, expressionValues, collapseQualifiedCallee = false) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (collapseQualifiedCallee &&
+        (expression.type === 'Identifier' || expression.type === 'MemberExpression')) {
+        return [['callee', expression]];
+    }
+    if (expression.type === 'Identifier') {
+        return [['callee', { name: expression.name, type: 'Identifier' }]];
+    }
+    if (expression.type === 'MemberExpression') {
+        const params = buildCalleeParams(expression.object, code, loc, filename, expressionValues, collapseQualifiedCallee);
+        const member = getMemberName(expression);
+        return params && member ? [...params, ['member', member]] : null;
+    }
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        const params = buildCalleeParams(call.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+        if (!params) {
+            return null;
+        }
+        const callValues = call.arguments
+            .filter((arg) => arg.type !== 'SpreadElement')
+            .map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+        return [...params, ['call', ...callValues]];
+    }
+    return null;
+};
+export const buildParams = (usage, code, loc, filename, expressionValues, collapseQualifiedCallee) => {
+    const params = buildCalleeParams(usage.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+    if (!params) {
+        return null;
+    }
+    if (usage.kind === 'template') {
+        return [
+            ...params,
+            zipTemplate(usage.target, code, loc, filename, expressionValues),
+        ];
+    }
+    const callValues = usage.target.arguments
+        .filter((arg) => arg.type !== 'SpreadElement')
+        .map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+    return [...params, ['call', ...callValues]];
+};

package/types/utils/applyOxcProcessors/processorFactory.d.ts

@@ -0,0 +1,7 @@
+import type { Expression as ProcessorExpression, IFileContext, Params } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import type { Expression, Node } from 'oxc-parser';
+import type { CreatedProcessor, DefinedProcessor, LocationLookup, Replacement } from './types';
+export declare const isReplacementPure: (replacement: ProcessorExpression) => boolean;
+export declare const shouldCollectStaticExpressionValues: (options: Pick<StrictOptions, "eval">) => boolean;
+export declare const createProcessor: (definedProcessor: DefinedProcessor, params: Params, target: Expression, replacementTarget: Expression, ancestors: Node[], fileContext: IFileContext, options: Pick<StrictOptions, "classNameSlug" | "displayName" | "extensions" | "tagResolver">, code: string, loc: LocationLookup, idx: number, isReferenced: boolean, usedNames: Set<string>, replacements: Replacement[]) => CreatedProcessor | null;

package/types/utils/applyOxcProcessors/processorFactory.js

@@ -0,0 +1,70 @@
+import { BaseProcessor, expressionToCode } from '@wyw-in-js/processor-utils';
+import { createOxcAstService } from '../oxcAstService';
+import { buildOxcCodeFrameError } from '../oxc/sourceLocations';
+import { getDisplayName } from './displayName';
+import { getRootIdentifier } from './processorUsages';
+import { getSourceLocation } from './shared';
+let didWarnSkipSymbolMismatch = false;
+export const isReplacementPure = (replacement) => replacement.type === 'CallExpression';
+export const shouldCollectStaticExpressionValues = (options) => (options.eval?.strategy ?? 'hybrid') !== 'execute';
+export const createProcessor = (definedProcessor, params, target, replacementTarget, ancestors, fileContext, options, code, loc, idx, isReferenced, usedNames, replacements) => {
+    const [Processor, tagSource] = definedProcessor;
+    const astService = createOxcAstService(usedNames);
+    const replacer = (replacement, isPure) => {
+        const next = typeof replacement === 'function' ? replacement(target) : replacement;
+        const replacementCode = expressionToCode(next);
+        replacements.push({
+            start: replacementTarget.start,
+            end: replacementTarget.end,
+            value: isPure && isReplacementPure(next)
+                ? `/*#__PURE__*/${replacementCode}`
+                : replacementCode,
+        });
+    };
+    try {
+        let displayName;
+        try {
+            displayName = getDisplayName(ancestors, idx, code, fileContext.filename);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Couldn't determine a name for the component")) {
+                let displayNameNode = target;
+                if (target.type === 'TaggedTemplateExpression') {
+                    displayNameNode = target.tag;
+                }
+                else if (target.type === 'CallExpression') {
+                    displayNameNode = target.callee;
+                }
+                const pointerNode = displayNameNode.type === 'MemberExpression'
+                    ? getRootIdentifier(displayNameNode) ?? displayNameNode
+                    : displayNameNode;
+                throw buildOxcCodeFrameError(code, getSourceLocation(pointerNode.start, pointerNode.end, loc, fileContext.filename), error.message);
+            }
+            throw error;
+        }
+        return {
+            astService,
+            processor: new Processor(params, tagSource, astService, getSourceLocation(target.start, target.end, loc, fileContext.filename), replacer, displayName, isReferenced, idx, options, fileContext),
+        };
+    }
+    catch (e) {
+        if (e === BaseProcessor.SKIP) {
+            return null;
+        }
+        if (typeof e === 'symbol' &&
+            e.description === BaseProcessor.SKIP.description) {
+            if (!didWarnSkipSymbolMismatch) {
+                didWarnSkipSymbolMismatch = true;
+                // eslint-disable-next-line no-console
+                console.warn([
+                    "[wyw-in-js] Processor threw Symbol('skip') that does not match BaseProcessor.SKIP identity.",
+                    'This usually means duplicate copies of @wyw-in-js/processor-utils (or the processor) are bundled/installed.',
+                    'Consider deduping dependencies to avoid subtle issues (instanceof checks, sentinels, etc).',
+                ].join('\n'));
+            }
+            return null;
+        }
+        throw e;
+    }
+};

package/types/utils/applyOxcProcessors/processorUsages.d.ts

@@ -0,0 +1,16 @@
+import type { Expression, MemberExpression, Node, Program } from 'oxc-parser';
+import type { DefinedProcessor, ExpressionSpan, OxcIdentifier, ProcessorUsage } from './types';
+export declare const getMemberName: (node: MemberExpression) => string | null;
+export declare const unwrapQualifiedExpression: (node: Expression) => Expression;
+export declare const getRootIdentifier: (node: Expression) => OxcIdentifier | null;
+export declare const getQualifiedName: (node: Expression) => string | null;
+export declare const resolveDefinedProcessor: (callee: Expression, definedProcessors: Map<string, DefinedProcessor>) => {
+    collapseQualifiedCallee: boolean;
+    definedProcessor: DefinedProcessor;
+} | null;
+export declare const isCallTagOfTaggedTemplate: (node: Node, parent: Node | null) => boolean;
+export declare const expandReplacementTarget: (target: Expression, ancestors: Node[]) => Expression;
+export declare const collectProcessorUsages: (program: Program, definedProcessors: Map<string, DefinedProcessor>) => ProcessorUsage[];
+export declare const expressionSpan: (expression: Expression) => ExpressionSpan;
+export declare const collectCallArgumentSpans: (node: Expression) => ExpressionSpan[];
+export declare const collectUsageExpressionSpans: (usage: ProcessorUsage) => ExpressionSpan[];

package/types/utils/applyOxcProcessors/processorUsages.js

@@ -0,0 +1,163 @@
+import { getOxcNodeChildren } from '../oxc/ast';
+export const getMemberName = (node) => {
+    if (node.computed) {
+        return node.property.type === 'Literal' &&
+            typeof node.property.value === 'string'
+            ? node.property.value
+            : null;
+    }
+    return node.property.type === 'Identifier' ? node.property.name : null;
+};
+export const unwrapQualifiedExpression = (node) => {
+    if (node.type === 'TSAsExpression' ||
+        node.type === 'TSSatisfiesExpression' ||
+        node.type === 'TSNonNullExpression' ||
+        node.type === 'TSTypeAssertion' ||
+        node.type === 'ParenthesizedExpression') {
+        return unwrapQualifiedExpression(node.expression);
+    }
+    if (node.type === 'SequenceExpression') {
+        const sequence = node;
+        return unwrapQualifiedExpression(sequence.expressions[sequence.expressions.length - 1] ?? node);
+    }
+    return node;
+};
+export const getRootIdentifier = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'Identifier') {
+        return expression;
+    }
+    if (expression.type === 'MemberExpression') {
+        return getRootIdentifier(expression.object);
+    }
+    if (expression.type === 'CallExpression') {
+        return getRootIdentifier(expression.callee);
+    }
+    return null;
+};
+export const getQualifiedName = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    if (expression.type === 'MemberExpression') {
+        const object = getQualifiedName(expression.object);
+        const member = getMemberName(expression);
+        return object && member ? `${object}.${member}` : null;
+    }
+    if (expression.type === 'CallExpression') {
+        return getQualifiedName(expression.callee);
+    }
+    return null;
+};
+export const resolveDefinedProcessor = (callee, definedProcessors) => {
+    const qualified = getQualifiedName(callee);
+    if (qualified) {
+        const definedProcessor = definedProcessors.get(qualified);
+        if (definedProcessor) {
+            return {
+                collapseQualifiedCallee: qualified.includes('.'),
+                definedProcessor,
+            };
+        }
+    }
+    const root = getRootIdentifier(callee);
+    if (!root) {
+        return null;
+    }
+    const definedProcessor = definedProcessors.get(root.name);
+    return definedProcessor
+        ? {
+            collapseQualifiedCallee: false,
+            definedProcessor,
+        }
+        : null;
+};
+export const isCallTagOfTaggedTemplate = (node, parent) => parent?.type === 'TaggedTemplateExpression' && parent.tag === node;
+export const expandReplacementTarget = (target, ancestors) => {
+    let current = target;
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'SequenceExpression' &&
+            ancestor.expressions[ancestor.expressions.length - 1] === current) {
+            current = ancestor;
+        }
+        else if (ancestor.type === 'ParenthesizedExpression' &&
+            ancestor.expression === current) {
+            current = ancestor;
+        }
+        else {
+            break;
+        }
+    }
+    return current;
+};
+export const collectProcessorUsages = (program, definedProcessors) => {
+    const usages = [];
+    const walk = (node, ancestors, parent = null) => {
+        if (node.type === 'TaggedTemplateExpression') {
+            const callee = node.tag;
+            const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+            if (resolvedProcessor) {
+                usages.push({
+                    ancestors,
+                    callee,
+                    collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+                    definedProcessor: resolvedProcessor.definedProcessor,
+                    kind: 'template',
+                    replacementTarget: expandReplacementTarget(node, ancestors),
+                    target: node,
+                });
+            }
+        }
+        else if (node.type === 'CallExpression' &&
+            !isCallTagOfTaggedTemplate(node, parent)) {
+            const { callee } = node;
+            const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+            if (resolvedProcessor) {
+                usages.push({
+                    ancestors,
+                    callee,
+                    collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+                    definedProcessor: resolvedProcessor.definedProcessor,
+                    kind: 'call',
+                    replacementTarget: expandReplacementTarget(node, ancestors),
+                    target: node,
+                });
+            }
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, [...ancestors, node], node));
+    };
+    walk(program, []);
+    return usages.sort((a, b) => a.target.start - b.target.start);
+};
+export const expressionSpan = (expression) => ({
+    end: expression.end,
+    start: expression.start,
+});
+export const collectCallArgumentSpans = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        const calleeSpans = collectCallArgumentSpans(call.callee);
+        const argumentSpans = call.arguments.flatMap((arg) => arg.type === 'SpreadElement' ? [] : [expressionSpan(arg)]);
+        return [...calleeSpans, ...argumentSpans];
+    }
+    if (expression.type === 'MemberExpression') {
+        return collectCallArgumentSpans(expression.object);
+    }
+    return [];
+};
+export const collectUsageExpressionSpans = (usage) => {
+    const calleeSpans = collectCallArgumentSpans(usage.callee);
+    if (usage.kind === 'template') {
+        return [
+            ...calleeSpans,
+            ...usage.target.quasi.expressions.map((expression) => expressionSpan(expression)),
+        ];
+    }
+    return [
+        ...calleeSpans,
+        ...usage.target.arguments.flatMap((arg) => arg.type === 'SpreadElement' ? [] : [expressionSpan(arg)]),
+    ];
+};

package/types/utils/applyOxcProcessors/sameFileStaticValues.d.ts

@@ -0,0 +1,23 @@
+import type { BaseProcessor } from '@wyw-in-js/processor-utils';
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { Node } from 'oxc-parser';
+import type { OxcStaticValueCandidate } from '../collectOxcTemplateDependencies';
+import { type UnknownProcessorStaticValue } from '../processorStaticSemantics';
+import type { SameFileProcessorObject } from './types';
+export declare const oxcLiteralValue: (expression: Node) => unknown | UnknownProcessorStaticValue;
+export declare const oxcPropertyKeyName: (key: Node) => string | null;
+export declare const collectStaticObjectPropertyNames: (objectExpression: Node) => Set<string> | null;
+export declare const getSameFileProcessorObjectProperty: (ancestors: Node[]) => {
+    localName: string;
+    propertyName: string;
+    propertyNames: Set<string>;
+} | null;
+export declare const createSameFileProcessorStaticValueResolver: (processorsByLocal: Map<string, BaseProcessor>, expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[]) => {
+    resolveLocal: (local: string) => unknown | UnknownProcessorStaticValue;
+    resolveProcessor: (processor: BaseProcessor) => unknown | UnknownProcessorStaticValue;
+};
+export declare const collectSameFileProcessorStaticValuesByLocal: (processorsByLocal: Map<string, BaseProcessor>, expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[]) => Map<string, unknown>;
+export declare const collectSameFileProcessorObjectStaticValuesByLocal: (processorObjectsByLocal: Map<string, SameFileProcessorObject>, processorsByLocal: Map<string, BaseProcessor>, expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[]) => Map<string, unknown>;
+export declare const collectWYWMetaExtendsHelperNames: (code: string) => Set<string>;
+export declare const collectCandidateInlineConstants: (candidate: OxcStaticValueCandidate, processorStaticValuesByLocal: Map<string, unknown>) => Record<string, unknown> | null;
+export declare const addCandidateInlineConstants: (candidates: OxcStaticValueCandidate[], processorStaticValuesByLocal: Map<string, unknown>) => OxcStaticValueCandidate[];

package/types/utils/applyOxcProcessors/sameFileStaticValues.js

@@ -0,0 +1,211 @@
+/* eslint-disable no-restricted-syntax */
+import { isOxcNode } from '../oxc/ast';
+import { processorExpressionToStaticValue, resolveProcessorStaticRuntimeValue, unknownProcessorStaticValue, } from '../processorStaticSemantics';
+import { GENERATED_HELPER_NAME_RE, JS_IDENTIFIER_RE, WYW_META_EXTENDS_HELPER_RE, } from './shared';
+export const oxcLiteralValue = (expression) => {
+    const expressionWithValue = expression;
+    const expressionType = expression.type;
+    if (expressionType === 'StringLiteral' ||
+        expressionType === 'NumericLiteral' ||
+        expressionType === 'BooleanLiteral' ||
+        expressionType === 'Literal') {
+        return expressionWithValue.value;
+    }
+    if (expressionType === 'NullLiteral') {
+        return null;
+    }
+    return unknownProcessorStaticValue;
+};
+export const oxcPropertyKeyName = (key) => {
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    const value = oxcLiteralValue(key);
+    return typeof value === 'string' ? value : null;
+};
+export const collectStaticObjectPropertyNames = (objectExpression) => {
+    if (objectExpression.type !== 'ObjectExpression') {
+        return null;
+    }
+    const { properties } = objectExpression;
+    if (!properties) {
+        return null;
+    }
+    const names = new Set();
+    for (const property of properties) {
+        const propertyType = property.type;
+        if (propertyType !== 'ObjectProperty' && propertyType !== 'Property') {
+            return null;
+        }
+        if (!property.key || !property.value) {
+            return null;
+        }
+        const name = oxcPropertyKeyName(property.key);
+        if (!name || names.has(name)) {
+            return null;
+        }
+        names.add(name);
+    }
+    return names;
+};
+export const getSameFileProcessorObjectProperty = (ancestors) => {
+    let propertyIndex = -1;
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        if (ancestors[idx].type === 'Property') {
+            propertyIndex = idx;
+            break;
+        }
+    }
+    if (propertyIndex <= 0) {
+        return null;
+    }
+    const property = ancestors[propertyIndex];
+    const objectExpression = ancestors[propertyIndex - 1];
+    if (!property.key || objectExpression.type !== 'ObjectExpression') {
+        return null;
+    }
+    const propertyName = oxcPropertyKeyName(property.key);
+    const propertyNames = collectStaticObjectPropertyNames(objectExpression);
+    if (!propertyName || !propertyNames) {
+        return null;
+    }
+    for (let idx = propertyIndex - 2; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'VariableDeclarator') {
+            const { id, init } = ancestor;
+            if (isOxcNode(id) &&
+                id.type === 'Identifier' &&
+                init === objectExpression) {
+                return {
+                    localName: id.name,
+                    propertyName,
+                    propertyNames,
+                };
+            }
+        }
+    }
+    return null;
+};
+export const createSameFileProcessorStaticValueResolver = (processorsByLocal, expressionValues) => {
+    const expressionSourceByName = new Map();
+    expressionValues.forEach((value) => {
+        if (value.ex.type === 'Identifier') {
+            expressionSourceByName.set(value.ex.name, value.source);
+        }
+    });
+    const memo = new Map();
+    const resolving = new Set();
+    function resolveLocal(local) {
+        if (memo.has(local)) {
+            return memo.get(local);
+        }
+        const processor = processorsByLocal.get(local);
+        if (!processor || resolving.has(local)) {
+            return unknownProcessorStaticValue;
+        }
+        resolving.add(local);
+        const contractValue = resolveProcessorStaticRuntimeValue(processor);
+        const value = contractValue !== unknownProcessorStaticValue
+            ? contractValue
+            : processorExpressionToStaticValue(processor.value, (helperName) => {
+                const source = expressionSourceByName.get(helperName);
+                return source ? resolveLocal(source) : unknownProcessorStaticValue;
+            });
+        resolving.delete(local);
+        memo.set(local, value);
+        return value;
+    }
+    function resolveProcessor(processor) {
+        const contractValue = resolveProcessorStaticRuntimeValue(processor);
+        if (contractValue !== unknownProcessorStaticValue) {
+            return contractValue;
+        }
+        return processorExpressionToStaticValue(processor.value, (helperName) => {
+            const source = expressionSourceByName.get(helperName);
+            return source ? resolveLocal(source) : unknownProcessorStaticValue;
+        });
+    }
+    return { resolveLocal, resolveProcessor };
+};
+export const collectSameFileProcessorStaticValuesByLocal = (processorsByLocal, expressionValues) => {
+    const { resolveLocal } = createSameFileProcessorStaticValueResolver(processorsByLocal, expressionValues);
+    const result = new Map();
+    processorsByLocal.forEach((_processor, local) => {
+        const value = resolveLocal(local);
+        if (value !== unknownProcessorStaticValue) {
+            result.set(local, value);
+        }
+    });
+    return result;
+};
+export const collectSameFileProcessorObjectStaticValuesByLocal = (processorObjectsByLocal, processorsByLocal, expressionValues) => {
+    const { resolveProcessor } = createSameFileProcessorStaticValueResolver(processorsByLocal, expressionValues);
+    const result = new Map();
+    for (const [local, object] of processorObjectsByLocal) {
+        if (object.properties.size === object.propertyNames.size) {
+            const value = {};
+            let complete = true;
+            for (const propertyName of object.propertyNames) {
+                const processor = object.properties.get(propertyName);
+                if (!processor) {
+                    complete = false;
+                    break;
+                }
+                const propertyValue = resolveProcessor(processor);
+                if (propertyValue === unknownProcessorStaticValue) {
+                    complete = false;
+                    break;
+                }
+                value[propertyName] = propertyValue;
+            }
+            if (complete) {
+                result.set(local, value);
+            }
+        }
+    }
+    return result;
+};
+export const collectWYWMetaExtendsHelperNames = (code) => {
+    const names = new Set();
+    let match = WYW_META_EXTENDS_HELPER_RE.exec(code);
+    while (match) {
+        const name = match[1];
+        if (name && GENERATED_HELPER_NAME_RE.test(name)) {
+            names.add(name);
+        }
+        match = WYW_META_EXTENDS_HELPER_RE.exec(code);
+    }
+    return names;
+};
+export const collectCandidateInlineConstants = (candidate, processorStaticValuesByLocal) => {
+    const inlineConstants = {};
+    let hasInlineConstant = false;
+    let match = JS_IDENTIFIER_RE.exec(candidate.source);
+    while (match) {
+        const name = match[0];
+        if (processorStaticValuesByLocal.has(name)) {
+            inlineConstants[name] = processorStaticValuesByLocal.get(name);
+            hasInlineConstant = true;
+        }
+        match = JS_IDENTIFIER_RE.exec(candidate.source);
+    }
+    return hasInlineConstant ? inlineConstants : null;
+};
+export const addCandidateInlineConstants = (candidates, processorStaticValuesByLocal) => {
+    if (processorStaticValuesByLocal.size === 0) {
+        return candidates;
+    }
+    return candidates.map((candidate) => {
+        const inlineConstants = collectCandidateInlineConstants(candidate, processorStaticValuesByLocal);
+        if (!inlineConstants) {
+            return candidate;
+        }
+        return {
+            ...candidate,
+            inlineConstants: {
+                ...candidate.inlineConstants,
+                ...inlineConstants,
+            },
+        };
+    });
+};