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

package/types/utils/applyOxcProcessors/cleanupRemovals.js

@@ -0,0 +1,567 @@
+/* eslint-disable no-restricted-syntax,no-continue */
+import { getOxcNodeChildren, isOxcNode } from '../oxc/ast';
+import { applyOxcReplacements } from '../oxc/replacements';
+import { collectDeclaredNames, collectImportLocalNames, collectReferencedNames, collectRemovableNamesFromStatements, collectTopLevelBindings, collectTopLevelBindingsFromStatements, collectTopLevelStatementInfos, getImportSpecifierLocalName, isNodeReference, } from './cleanupBindings';
+import { GENERATED_HELPER_NAME_RE, parseOxc } from './shared';
+export const createScopedCleanupScope = (parent) => ({
+    bindings: new Map(),
+    parent,
+});
+export const resolveScopedBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        const bindingId = current.bindings.get(name);
+        if (bindingId) {
+            return bindingId;
+        }
+        current = current.parent;
+    }
+    return null;
+};
+export const collectScopedBindingInfos = (program) => {
+    const bindings = new Map();
+    let sequence = 0;
+    const addBinding = (scope, name, kind, declaration) => {
+        const id = `${kind}:${name}:${declaration.start}:${sequence}`;
+        sequence += 1;
+        bindings.set(id, {
+            declaration,
+            dependencies: new Set(),
+            externalReferences: 0,
+            id,
+            incomingFromBindings: new Set(),
+            kind,
+            name,
+        });
+        scope.bindings.set(name, id);
+        return id;
+    };
+    const addPatternBindings = (scope, pattern, kind, declaration) => {
+        collectDeclaredNames(pattern).forEach((name) => {
+            addBinding(scope, name, kind, declaration);
+        });
+    };
+    const recordReference = (scope, name, ownerBindingId) => {
+        const targetId = resolveScopedBinding(scope, name);
+        if (!targetId) {
+            return;
+        }
+        const target = bindings.get(targetId);
+        if (!target) {
+            return;
+        }
+        if (ownerBindingId && ownerBindingId !== targetId) {
+            target.incomingFromBindings.add(ownerBindingId);
+            bindings.get(ownerBindingId)?.dependencies.add(targetId);
+            return;
+        }
+        target.externalReferences += 1;
+    };
+    let walk;
+    function walkPatternReferenceSubexpressions(node, scope, ownerBindingId) {
+        if (node.type === 'Identifier') {
+            return;
+        }
+        if (node.type === 'TSParameterProperty') {
+            walkPatternReferenceSubexpressions(node.parameter, scope, ownerBindingId);
+            return;
+        }
+        if (node.type === 'RestElement') {
+            walkPatternReferenceSubexpressions(node.argument, scope, ownerBindingId);
+            return;
+        }
+        if (node.type === 'AssignmentPattern') {
+            walkPatternReferenceSubexpressions(node.left, scope, ownerBindingId);
+            walk(node.right, scope, node, ownerBindingId);
+            return;
+        }
+        if (node.type === 'ObjectPattern') {
+            node.properties.forEach((property) => {
+                if (property.type === 'RestElement') {
+                    walkPatternReferenceSubexpressions(property.argument, scope, ownerBindingId);
+                    return;
+                }
+                if (property.computed && isOxcNode(property.key)) {
+                    walk(property.key, scope, property, ownerBindingId);
+                }
+                walkPatternReferenceSubexpressions(property.value, scope, ownerBindingId);
+            });
+            return;
+        }
+        if (node.type === 'ArrayPattern') {
+            node.elements.forEach((element) => {
+                if (element && isOxcNode(element)) {
+                    walkPatternReferenceSubexpressions(element, scope, ownerBindingId);
+                }
+            });
+        }
+    }
+    walk = (node, scope, parent = null, ownerBindingId = null) => {
+        if (node.type === 'ImportDeclaration') {
+            const { specifiers } = node;
+            if (Array.isArray(specifiers)) {
+                specifiers.forEach((specifier) => {
+                    const { local } = specifier;
+                    if (isOxcNode(local) &&
+                        local.type === 'Identifier' &&
+                        typeof local.name === 'string') {
+                        addBinding(scope, local.name, 'import', node);
+                    }
+                });
+            }
+            return;
+        }
+        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+            walk(node.declaration, scope, node, ownerBindingId);
+            collectTopLevelBindings(node).forEach((name) => {
+                recordReference(scope, name, ownerBindingId);
+            });
+            return;
+        }
+        if (node.type === 'ExportDefaultDeclaration') {
+            const { declaration } = node;
+            if (isOxcNode(declaration)) {
+                walk(declaration, scope, node, ownerBindingId);
+                if ((declaration.type === 'FunctionDeclaration' ||
+                    declaration.type === 'ClassDeclaration') &&
+                    declaration.id) {
+                    recordReference(scope, declaration.id.name, ownerBindingId);
+                }
+            }
+            return;
+        }
+        if (node.type === 'VariableDeclaration') {
+            const { declarations } = node;
+            if (!Array.isArray(declarations)) {
+                return;
+            }
+            declarations.forEach((declarator) => {
+                const { id } = declarator;
+                if (isOxcNode(id)) {
+                    addPatternBindings(scope, id, 'variable', node);
+                }
+            });
+            declarations.forEach((declarator) => {
+                const { id } = declarator;
+                const { init } = declarator;
+                if (!isOxcNode(id) || !isOxcNode(init)) {
+                    return;
+                }
+                const ownerName = collectDeclaredNames(id)[0] ?? null;
+                const nextOwner = ownerName !== null ? resolveScopedBinding(scope, ownerName) : null;
+                walk(init, scope, declarator, nextOwner);
+            });
+            return;
+        }
+        if (node.type === 'FunctionDeclaration' && node.id) {
+            const functionBindingId = addBinding(scope, node.id.name, 'function', node);
+            const fnScope = createScopedCleanupScope(scope);
+            node.params.forEach((param) => {
+                addPatternBindings(fnScope, param, 'param', param);
+                walkPatternReferenceSubexpressions(param, fnScope, functionBindingId);
+            });
+            if (node.body) {
+                walk(node.body, fnScope, node, functionBindingId);
+            }
+            return;
+        }
+        if (node.type === 'FunctionExpression' ||
+            node.type === 'ArrowFunctionExpression') {
+            const fnScope = createScopedCleanupScope(scope);
+            if (node.type === 'FunctionExpression' && node.id) {
+                addBinding(fnScope, node.id.name, 'function', node);
+            }
+            node.params.forEach((param) => {
+                addPatternBindings(fnScope, param, 'param', param);
+                walkPatternReferenceSubexpressions(param, fnScope, ownerBindingId);
+            });
+            if (node.body) {
+                walk(node.body, fnScope, node, ownerBindingId);
+            }
+            return;
+        }
+        if (node.type === 'BlockStatement') {
+            const blockScope = createScopedCleanupScope(scope);
+            getOxcNodeChildren(node).forEach((child) => walk(child, blockScope, node, ownerBindingId));
+            return;
+        }
+        if (isNodeReference(node, parent) &&
+            'name' in node &&
+            typeof node.name === 'string') {
+            recordReference(scope, node.name, ownerBindingId);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, scope, node, ownerBindingId));
+    };
+    walk(program, createScopedCleanupScope(null));
+    return bindings;
+};
+export const collectScopedRemovableBindingIds = (bindings, initialNames) => {
+    const removable = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const binding of bindings.values()) {
+            if (!removable.has(binding.id) &&
+                binding.kind !== 'import' &&
+                binding.kind !== 'param' &&
+                binding.externalReferences === 0) {
+                const seededByName = initialNames.has(binding.name) ||
+                    (GENERATED_HELPER_NAME_RE.test(binding.name) &&
+                        binding.incomingFromBindings.size === 0);
+                const allIncomingRemovable = binding.incomingFromBindings.size > 0 &&
+                    [...binding.incomingFromBindings].every((sourceId) => removable.has(sourceId));
+                if ((seededByName && binding.incomingFromBindings.size === 0) ||
+                    allIncomingRemovable) {
+                    removable.add(binding.id);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return removable;
+};
+export function expandImportRemovalRange(code, start, end) {
+    let removalStart = start;
+    while (removalStart > 0 &&
+        (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+        removalStart -= 1;
+    }
+    let removalEnd = end;
+    if (code[removalEnd] === ';') {
+        removalEnd += 1;
+    }
+    while (removalEnd < code.length &&
+        (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+        removalEnd += 1;
+    }
+    if (code[removalEnd] === '\r' && code[removalEnd + 1] === '\n') {
+        removalEnd += 2;
+    }
+    else if (code[removalEnd] === '\n') {
+        removalEnd += 1;
+    }
+    return {
+        end: removalEnd,
+        start: removalStart,
+        value: '',
+    };
+}
+export const collectUnusedScopedDeclarationRemovals = (code, bindings, initialRemovableNames) => {
+    const removableBindingIds = collectScopedRemovableBindingIds(bindings, initialRemovableNames);
+    const removals = new Map();
+    bindings.forEach((binding) => {
+        if (!removableBindingIds.has(binding.id) ||
+            binding.kind === 'import' ||
+            binding.kind === 'param' ||
+            binding.externalReferences > 0 ||
+            [...binding.incomingFromBindings].some((sourceId) => !removableBindingIds.has(sourceId))) {
+            return;
+        }
+        if (binding.kind === 'function' &&
+            binding.declaration.type === 'FunctionDeclaration') {
+            const range = expandImportRemovalRange(code, binding.declaration.start, binding.declaration.end);
+            removals.set(`${range.start}:${range.end}`, range);
+            return;
+        }
+        if (binding.declaration.type !== 'VariableDeclaration') {
+            return;
+        }
+        const { declarations } = binding.declaration;
+        if (!Array.isArray(declarations) || declarations.length !== 1) {
+            return;
+        }
+        const range = expandImportRemovalRange(code, binding.declaration.start, binding.declaration.end);
+        removals.set(`${range.start}:${range.end}`, range);
+    });
+    return [...removals.values()];
+};
+export const expandImportSpecifierRemovalRange = (code, start, end) => {
+    let removalStart = start;
+    let removalEnd = end;
+    let whitespaceStart = removalStart;
+    while (whitespaceStart > 0 &&
+        (code[whitespaceStart - 1] === ' ' || code[whitespaceStart - 1] === '\t')) {
+        whitespaceStart -= 1;
+    }
+    if (code[whitespaceStart - 1] !== '{') {
+        removalStart = whitespaceStart;
+    }
+    while (removalEnd < code.length &&
+        (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+        removalEnd += 1;
+    }
+    if (code[removalEnd] === ',') {
+        removalEnd += 1;
+        while (removalEnd < code.length &&
+            (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+            removalEnd += 1;
+        }
+    }
+    else {
+        while (removalStart > 0 &&
+            (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+            removalStart -= 1;
+        }
+        if (code[removalStart - 1] === ',') {
+            removalStart -= 1;
+            while (removalStart > 0 &&
+                (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+                removalStart -= 1;
+            }
+        }
+    }
+    return {
+        end: removalEnd,
+        start: removalStart,
+        value: '',
+    };
+};
+export const mergeEmptyRemovalRanges = (removals) => {
+    if (removals.length <= 1) {
+        return removals;
+    }
+    const sorted = [...removals].sort((a, b) => a.start - b.start);
+    const merged = [];
+    sorted.forEach((removal) => {
+        const previous = merged[merged.length - 1];
+        if (previous &&
+            previous.value === '' &&
+            removal.value === '' &&
+            removal.start <= previous.end) {
+            previous.end = Math.max(previous.end, removal.end);
+            return;
+        }
+        merged.push({ ...removal });
+    });
+    return merged;
+};
+export const collectUnusedImportRemovals = (code, program, referencedNames, removableNames, preserveSideEffectImportLocals, preserveSideEffectImportOrderLocals = preserveSideEffectImportLocals) => {
+    const removals = [];
+    const importSourceByLocal = new Map();
+    const removedSideEffectImportRanges = [];
+    const keptImportRangesBySource = new Map();
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration') {
+            return;
+        }
+        const localNames = collectImportLocalNames(statement);
+        const source = code.slice(statement.source.start, statement.source.end);
+        const orderedLocalNames = localNames.filter((localName) => preserveSideEffectImportOrderLocals.has(localName));
+        const sideEffectLocalNames = localNames.filter((localName) => preserveSideEffectImportLocals.has(localName));
+        [...orderedLocalNames, ...sideEffectLocalNames].forEach((localName) => {
+            importSourceByLocal.set(localName, source);
+        });
+        const removableLocalNames = localNames.filter((localName) => removableNames.has(localName));
+        if (removableLocalNames.length > 0 &&
+            removableLocalNames.length === localNames.length &&
+            removableLocalNames.every((localName) => !referencedNames.has(localName))) {
+            if (removableLocalNames.some((localName) => preserveSideEffectImportLocals.has(localName))) {
+                removedSideEffectImportRanges.push({
+                    end: statement.end,
+                    start: statement.start,
+                });
+                return;
+            }
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+            return;
+        }
+        if (orderedLocalNames.length > 0 && !keptImportRangesBySource.has(source)) {
+            keptImportRangesBySource.set(source, {
+                end: statement.end,
+                start: statement.start,
+            });
+        }
+        const { specifiers } = statement;
+        if (!Array.isArray(specifiers) || specifiers.length <= 1) {
+            return;
+        }
+        specifiers.forEach((specifier) => {
+            if (!isOxcNode(specifier)) {
+                return;
+            }
+            const localName = getImportSpecifierLocalName(specifier);
+            if (localName &&
+                removableNames.has(localName) &&
+                !referencedNames.has(localName)) {
+                removals.push(expandImportSpecifierRemovalRange(code, specifier.start, specifier.end));
+            }
+        });
+    });
+    if (removedSideEffectImportRanges.length > 0) {
+        const seenSources = new Set();
+        const removedRanges = removedSideEffectImportRanges.sort((a, b) => a.start - b.start);
+        const [firstRemoved, ...restRemoved] = removedRanges;
+        const pendingImports = [];
+        let insertionAfterLastKept = null;
+        let usedFirstRemovedRange = false;
+        const flushBefore = (position) => {
+            if (pendingImports.length === 0) {
+                return;
+            }
+            removals.push({
+                end: position,
+                start: position,
+                value: `${pendingImports.join('\n')}\n`,
+            });
+            pendingImports.length = 0;
+        };
+        [...preserveSideEffectImportOrderLocals].forEach((localName) => {
+            const source = importSourceByLocal.get(localName);
+            if (!source) {
+                return;
+            }
+            const keptRange = keptImportRangesBySource.get(source);
+            if (keptRange) {
+                flushBefore(keptRange.start);
+                insertionAfterLastKept = keptRange.end;
+                if (preserveSideEffectImportLocals.has(localName)) {
+                    seenSources.add(source);
+                }
+                return;
+            }
+            if (!preserveSideEffectImportLocals.has(localName) ||
+                seenSources.has(source)) {
+                return;
+            }
+            seenSources.add(source);
+            pendingImports.push(`import ${source};`);
+        });
+        if (pendingImports.length > 0) {
+            if (insertionAfterLastKept !== null) {
+                removals.push({
+                    end: insertionAfterLastKept,
+                    start: insertionAfterLastKept,
+                    value: `\n${pendingImports.join('\n')}`,
+                });
+            }
+            else if (firstRemoved) {
+                usedFirstRemovedRange = true;
+                removals.push({
+                    end: firstRemoved.end,
+                    start: firstRemoved.start,
+                    value: pendingImports.join('\n'),
+                });
+            }
+        }
+        removals.push(...(usedFirstRemovedRange ? restRemoved : removedRanges).map((range) => ({
+            ...range,
+            value: '',
+        })));
+    }
+    return removals;
+};
+export const collectUnusedTopLevelDeclarationRemovals = (code, program, referencedNames, removableNames) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration') {
+            return;
+        }
+        const localNames = [...collectTopLevelBindings(statement)];
+        if (localNames.length > 0 &&
+            localNames.every((localName) => removableNames.has(localName)) &&
+            localNames.every((localName) => !referencedNames.has(localName))) {
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+        }
+    });
+    return removals;
+};
+export const collectUnusedGeneratedHelperDeclarationRemovals = (code, program, referencedNames) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration') {
+            return;
+        }
+        const localNames = [...collectTopLevelBindings(statement)];
+        if (localNames.length > 0 &&
+            localNames.every((localName) => GENERATED_HELPER_NAME_RE.test(localName)) &&
+            localNames.every((localName) => !referencedNames.has(localName))) {
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+        }
+    });
+    return removals;
+};
+export const collectTopLevelExpressionStatementRemovals = (code, statements, topLevelBindings, removableExpressionRefs) => {
+    const removals = [];
+    statements.forEach((statement) => {
+        if (statement.node.type !== 'ExpressionStatement') {
+            return;
+        }
+        const { expression } = statement.node;
+        const isPureExpression = expression.type === 'Identifier' ||
+            expression.type === 'Literal' ||
+            expression.type === 'ObjectExpression' ||
+            expression.type === 'ArrayExpression' ||
+            expression.type === 'ArrowFunctionExpression' ||
+            expression.type === 'FunctionExpression' ||
+            (expression.type === 'TemplateLiteral' &&
+                expression.expressions.length === 0);
+        if (!isPureExpression) {
+            return;
+        }
+        const localReferences = [...statement.references].filter((name) => topLevelBindings.has(name));
+        if (localReferences.length > 0 &&
+            localReferences.every((name) => removableExpressionRefs.has(name))) {
+            removals.push(expandImportRemovalRange(code, statement.node.start, statement.node.end));
+        }
+    });
+    return removals;
+};
+export const collectEmptyTopLevelBlockRemovals = (code, program) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'BlockStatement' || statement.body.length > 0) {
+            return;
+        }
+        removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+    });
+    return removals;
+};
+export const removeUnusedAfterReplacement = (code, filename, initialRemovableNames, removableExpressionRefs, preserveSideEffectImportLocals, preserveSideEffectImportOrderLocals = preserveSideEffectImportLocals) => {
+    let current = code;
+    let program = null;
+    const cumulativeRemovableNames = new Set(initialRemovableNames);
+    // Incremental cleanup loop: validate-by-parsing the next iteration's
+    // candidate code AND reuse that parse as the next iter's `program` input,
+    // instead of re-parsing at the top of the next iter. Saves one parse per
+    // loop revolution (N+1 parses for an N-iter loop instead of 2N).
+    // Also short-circuits a round earlier when no removals were collected.
+    for (let idx = 0; idx < 5; idx += 1) {
+        const previous = current;
+        if (program === null) {
+            program = parseOxc(current, filename);
+        }
+        const statements = collectTopLevelStatementInfos(program);
+        const removableNames = collectRemovableNamesFromStatements(statements, cumulativeRemovableNames);
+        removableNames.forEach((name) => cumulativeRemovableNames.add(name));
+        const referencedNames = collectReferencedNames(program);
+        const topLevelBindings = collectTopLevelBindingsFromStatements(statements);
+        const scopedBindings = collectScopedBindingInfos(program);
+        const removals = mergeEmptyRemovalRanges([
+            ...collectUnusedScopedDeclarationRemovals(current, scopedBindings, cumulativeRemovableNames),
+            ...collectUnusedTopLevelDeclarationRemovals(current, program, referencedNames, cumulativeRemovableNames),
+            ...collectUnusedGeneratedHelperDeclarationRemovals(current, program, referencedNames),
+            ...collectUnusedImportRemovals(current, program, referencedNames, cumulativeRemovableNames, preserveSideEffectImportLocals, preserveSideEffectImportOrderLocals),
+            ...collectTopLevelExpressionStatementRemovals(current, statements, topLevelBindings, removableExpressionRefs),
+            ...collectEmptyTopLevelBlockRemovals(current, program),
+        ]);
+        if (removals.length === 0) {
+            // Convergence: next iter would parse the same code and see the same
+            // removable set. Skip the round of walks + parse.
+            return current;
+        }
+        const next = applyOxcReplacements(current, removals);
+        try {
+            // Validate + capture the AST for the next iteration in one parse.
+            program = parseOxc(next, filename);
+            current = next;
+        }
+        catch {
+            // Pathological removal — drop this iteration and return prior state.
+            return current;
+        }
+        if (current === previous) {
+            return current;
+        }
+    }
+    return current;
+};

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

@@ -0,0 +1,9 @@
+import type { ExpressionValue } from '@wyw-in-js/shared';
+import type { Node, Program } from 'oxc-parser';
+import type { OxcStaticValue } from '../collectOxcTemplateDependencies';
+import type { AnyNode } from './types';
+export declare const getPropertyKeyName: (property: AnyNode, code: string) => string | null;
+export declare const getDisplayName: (ancestors: Node[], idx: number, code: string, filename?: string | null) => string;
+export declare const getTagOwner: (ancestors: Node[]) => AnyNode | null;
+export declare const isTagReferenced: (program: Program, ancestors: Node[]) => boolean;
+export declare const collectSameFileProcessorStaticValues: (expressionValues: Omit<ExpressionValue, "buildCodeFrameError">[], processorStaticValuesByLocal: Map<string, unknown>) => OxcStaticValue[];

package/types/utils/applyOxcProcessors/displayName.js

@@ -0,0 +1,113 @@
+/* eslint-disable no-restricted-syntax */
+import { basename, dirname } from 'path';
+import { ValueType } from '@wyw-in-js/shared';
+import { isOxcNode, walkOxc } from '../oxc/ast';
+import { isNodeReference } from './cleanupBindings';
+export const getPropertyKeyName = (property, code) => {
+    const { key } = property;
+    if (!isOxcNode(key)) {
+        return null;
+    }
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    if (key.type === 'Literal') {
+        return String(key.value);
+    }
+    return typeof key.start === 'number' && typeof key.end === 'number'
+        ? code.slice(key.start, key.end)
+        : null;
+};
+export const getDisplayName = (ancestors, idx, code, filename) => {
+    const owner = [...ancestors].reverse().find((node) => {
+        return (node.type === 'Property' ||
+            node.type === 'JSXOpeningElement' ||
+            node.type === 'VariableDeclarator');
+    });
+    if (owner?.type === 'Property') {
+        const keyName = getPropertyKeyName(owner, code);
+        if (keyName) {
+            return keyName;
+        }
+    }
+    else if (owner?.type === 'JSXOpeningElement') {
+        const { name } = owner;
+        if (isOxcNode(name) && name.type === 'JSXIdentifier') {
+            return name.name;
+        }
+    }
+    else if (owner?.type === 'VariableDeclarator') {
+        const { id } = owner;
+        if (isOxcNode(id) && id.type === 'Identifier') {
+            return id.name;
+        }
+    }
+    let displayName = basename(filename ?? 'unknown').replace(/\.[a-z\d]+$/, '');
+    if (filename && /^index\.[a-z\d]+$/.test(basename(filename))) {
+        displayName = basename(dirname(filename));
+    }
+    if (!displayName) {
+        throw new Error("Couldn't determine a name for the component. Ensure that it's either:\n" +
+            '- Assigned to a variable\n' +
+            '- Is an object property\n' +
+            '- Is a prop in a JSX element\n');
+    }
+    return `${displayName}${idx}`;
+};
+export const getTagOwner = (ancestors) => {
+    const owner = [...ancestors]
+        .reverse()
+        .find((node) => node.type === 'Property' ||
+        node.type === 'JSXOpeningElement' ||
+        node.type === 'VariableDeclarator');
+    return owner ?? null;
+};
+export const isTagReferenced = (program, ancestors) => {
+    const owner = getTagOwner(ancestors);
+    if (owner?.type !== 'VariableDeclarator') {
+        return true;
+    }
+    const { id } = owner;
+    if (!isOxcNode(id) || id.type !== 'Identifier') {
+        return true;
+    }
+    if (ancestors.some((node) => node.type === 'ExportNamedDeclaration')) {
+        return true;
+    }
+    let referenced = false;
+    walkOxc(program, (node, parent) => {
+        const referenceName = node.type === 'Identifier' || node.type === 'JSXIdentifier'
+            ? node.name
+            : null;
+        if (referenced ||
+            referenceName !== id.name ||
+            (node.type === 'Identifier' &&
+                node.start === id.start &&
+                node.end === id.end)) {
+            return;
+        }
+        referenced = isNodeReference(node, parent);
+    });
+    return referenced;
+};
+export const collectSameFileProcessorStaticValues = (expressionValues, processorStaticValuesByLocal) => {
+    const staticValues = [];
+    const seen = new Set();
+    expressionValues.forEach((value) => {
+        if (value.kind !== ValueType.LAZY) {
+            return;
+        }
+        const staticValue = processorStaticValuesByLocal.get(value.source);
+        if (staticValue === undefined ||
+            value.ex.type !== 'Identifier' ||
+            seen.has(value.ex.name)) {
+            return;
+        }
+        seen.add(value.ex.name);
+        staticValues.push({
+            name: value.ex.name,
+            value: staticValue,
+        });
+    });
+    return staticValues;
+};