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

package/types/transform/generators/transform.js

@@ -55,8 +55,11 @@ const ensureOxcPreevalResult = (services, item, originalAst) => {
             dependencyNames: result.dependencyNames,
             evalCode: result.code,
             metadata: result.metadata,
+            processorClassNames: result.processorClassNames,
+            staticImportLocals: [],
             staticSideEffectImportLocals: [],
             staticDependencies: result.staticDependencies,
+            staticValuesApplied: false,
             staticValueCache: result.staticValueCache,
             staticValueCandidates: result.staticValueCandidates,
         };
@@ -132,6 +135,62 @@ export const prepareCodeForEvalRuntime = (services, item, originalAst) => prepar
     shortCircuitOnMissingMetadata: true,
     stripForEvalRuntime: true,
 });
+function* resolveAndProcessOxcPreparedImports(action, preparedCode, imports) {
+    const { loadedAndParsed } = action.entrypoint;
+    if (imports === null || imports.size === 0) {
+        return preparedCode;
+    }
+    const resolvedImports = yield* action.getNext('resolveImports', action.entrypoint, {
+        imports,
+        phase: 'initial',
+    });
+    let nextCode = preparedCode;
+    let nextResolvedImports = [];
+    let skippedParentDependencyTracking = [];
+    if (resolvedImports.length > 0) {
+        const rewritten = yield* rewriteOptimizedOxcBarrelImports.call(action, preparedCode, loadedAndParsed.evaluator === 'ignored'
+            ? action.entrypoint.name
+            : loadedAndParsed.evalConfig.filename ?? action.entrypoint.name, resolvedImports);
+        nextCode = rewritten.code;
+        if (rewritten.optimizedCount > 0) {
+            skippedParentDependencyTracking = rewritten.generatedSources;
+            const fullyRewrittenSources = new Set(rewritten.fullyRewrittenSources);
+            const partialFallbackSources = new Set(rewritten.partialFallbackSources);
+            for (const dependency of resolvedImports) {
+                if (dependency.resolved &&
+                    (fullyRewrittenSources.has(dependency.source) ||
+                        partialFallbackSources.has(dependency.source))) {
+                    if (partialFallbackSources.has(dependency.source)) {
+                        action.entrypoint.addDependency(dependency);
+                    }
+                    else {
+                        action.entrypoint.addInvalidationDependency(dependency);
+                    }
+                    action.entrypoint.markInvalidateOnDependencyChange(dependency.resolved);
+                }
+            }
+            nextResolvedImports = yield* action.getNext('resolveImports', action.entrypoint, {
+                imports: rewritten.imports,
+                phase: 'rewritten',
+                preResolved: rewritten.preResolvedImports,
+            });
+        }
+        else {
+            nextResolvedImports = resolvedImports;
+        }
+    }
+    if (nextResolvedImports.length !== 0) {
+        yield [
+            'processImports',
+            action.entrypoint,
+            {
+                resolved: nextResolvedImports,
+                skipParentDependencyTracking: skippedParentDependencyTracking,
+            },
+        ];
+    }
+    return nextCode;
+}
 export function* internalTransform(prepareFn) {
     const { only, loadedAndParsed, log } = this.entrypoint;
     if (loadedAndParsed.evaluator === 'ignored') {
@@ -149,7 +208,7 @@ export function* internalTransform(prepareFn) {
         ensureOxcPreevalResult(this.services, this.entrypoint, null);
         yield* resolveStaticOxcPreevalValues.call(this);
     }
-    const [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, null);
+    let [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, null);
     let finalPreparedCode = preparedCode;
     if (loadedAndParsed.evaluator === oxcShaker) {
         if (metadata === null && isPrevalOnly(only)) {
@@ -159,54 +218,10 @@ export function* internalTransform(prepareFn) {
                 metadata: null,
             };
         }
-        let nextCode = preparedCode;
-        let nextResolvedImports = [];
-        let skippedParentDependencyTracking = [];
-        if (imports !== null && imports.size > 0) {
-            const resolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
-                imports,
-                phase: 'initial',
-            });
-            if (resolvedImports.length > 0) {
-                const rewritten = yield* rewriteOptimizedOxcBarrelImports.call(this, preparedCode, loadedAndParsed.evalConfig.filename ?? this.entrypoint.name, resolvedImports);
-                nextCode = rewritten.code;
-                if (rewritten.optimizedCount > 0) {
-                    skippedParentDependencyTracking = rewritten.generatedSources;
-                    const fullyRewrittenSources = new Set(rewritten.fullyRewrittenSources);
-                    const partialFallbackSources = new Set(rewritten.partialFallbackSources);
-                    for (const dependency of resolvedImports) {
-                        if (dependency.resolved &&
-                            (fullyRewrittenSources.has(dependency.source) ||
-                                partialFallbackSources.has(dependency.source))) {
-                            if (partialFallbackSources.has(dependency.source)) {
-                                this.entrypoint.addDependency(dependency);
-                            }
-                            else {
-                                this.entrypoint.addInvalidationDependency(dependency);
-                            }
-                            this.entrypoint.markInvalidateOnDependencyChange(dependency.resolved);
-                        }
-                    }
-                    nextResolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
-                        imports: rewritten.imports,
-                        phase: 'rewritten',
-                        preResolved: rewritten.preResolvedImports,
-                    });
-                }
-                else {
-                    nextResolvedImports = resolvedImports;
-                }
-            }
-        }
-        if (nextResolvedImports.length !== 0) {
-            yield [
-                'processImports',
-                this.entrypoint,
-                {
-                    resolved: nextResolvedImports,
-                    skipParentDependencyTracking: skippedParentDependencyTracking,
-                },
-            ];
+        let nextCode = yield* resolveAndProcessOxcPreparedImports(this, preparedCode, imports);
+        if (yield* resolveStaticOxcPreevalValues.call(this)) {
+            [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, null);
+            nextCode = yield* resolveAndProcessOxcPreparedImports(this, preparedCode, imports);
         }
         finalPreparedCode = this.services.eventEmitter.perf('transform:emitCommonJS', () => emitOxcCommonJS(nextCode, loadedAndParsed.evalConfig.filename ?? this.entrypoint.name).code);
     }

package/types/transform/helpers/loadWywOptions.js

@@ -28,6 +28,10 @@ const explorerSync = cosmiconfigSync('wyw-in-js', {
 const cache = new WeakMap();
 const defaultOverrides = {};
 const nodeModulesRegExp = /[\\/]node_modules[\\/]/;
+const evalResolverModes = new Set(['bundler', 'hybrid', 'native', 'custom']);
+const evalStrategies = new Set(['execute', 'hybrid', 'static']);
+const evalRuntimes = new Set(['nodejs']);
+const evalErrorModes = new Set(['strict', 'loose']);
 const defaultImportLoaders = {
     raw: 'raw',
     url: 'url',
@@ -98,13 +102,14 @@ export function loadWywOptions(overrides = defaultOverrides) {
         globalCache: true,
         happyDOM: true,
         softErrors: false,
-        staticImportValues: false,
         useWeakRefInEval: true,
     };
     const defaultEval = {
-        mode: 'strict',
+        errors: 'strict',
         require: 'warn-and-run',
         resolver: 'bundler',
+        runtime: 'nodejs',
+        strategy: 'hybrid',
     };
     const config = (() => {
         if (configFile === false) {
@@ -120,7 +125,6 @@ export function loadWywOptions(overrides = defaultOverrides) {
     const configEval = config.eval;
     const options = {
         displayName: false,
-        evaluate: true,
         evalConsole: 'pipe',
         extensions: ['.cjs', '.cts', '.js', '.jsx', '.mjs', '.mts', '.ts', '.tsx'],
         outputMetadata: false,
@@ -165,6 +169,22 @@ export function loadWywOptions(overrides = defaultOverrides) {
             ...rest.features,
         },
     };
+    const evalResolver = options.eval?.resolver;
+    if (evalResolver && !evalResolverModes.has(evalResolver)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.resolver "${evalResolver}". Use "bundler", "hybrid", "native", or "custom".`);
+    }
+    const evalStrategy = options.eval?.strategy;
+    if (evalStrategy && !evalStrategies.has(evalStrategy)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.strategy "${evalStrategy}". Use "execute", "hybrid", or "static".`);
+    }
+    const evalRuntime = options.eval?.runtime;
+    if (evalRuntime && !evalRuntimes.has(evalRuntime)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.runtime "${evalRuntime}". Use "nodejs".`);
+    }
+    const evalErrors = options.eval?.errors;
+    if (evalErrors && !evalErrorModes.has(evalErrors)) {
+        throw new Error(`[wyw-in-js] Unsupported eval.errors "${evalErrors}". Use "strict" or "loose".`);
+    }
     cache.set(overrides, options);
     return options;
 }

package/types/transform.js

@@ -47,9 +47,11 @@ const canonicalizeForHash = (value) => {
 const getEvalCacheKey = (pluginOptions, asyncResolveKey, asyncResolve) => {
     const evalOptions = pluginOptions.eval ?? {};
     const payload = JSON.stringify({
-        mode: evalOptions.mode,
+        errors: evalOptions.errors,
         resolver: evalOptions.resolver,
         require: evalOptions.require,
+        runtime: evalOptions.runtime,
+        strategy: evalOptions.strategy,
         globals: canonicalizeForHash(encodeGlobals(evalOptions.globals ?? {})),
         customResolver: getResolverId(evalOptions.customResolver),
         customLoader: getResolverId(evalOptions.customLoader),

package/types/utils/EventEmitter.d.ts

@@ -45,14 +45,29 @@ export interface OnAction {
     (...args: OnActionStartArgs): number;
     (...args: OnActionFinishArgs): void;
 }
+type PerfStatus = 'failed' | 'finished';
+export type PerfFinishEvent = {
+    durationMs: number;
+    error?: unknown;
+    finishedAt: number;
+    isAsync: boolean;
+    method: string;
+    spanId: number;
+    startedAt: number;
+    status: PerfStatus;
+    type: 'perf-span';
+};
 export declare class EventEmitter {
     protected onEvent: OnEvent;
     protected onAction: OnAction;
     protected onEntrypointEvent: OnEntrypointEvent;
+    readonly enabled: boolean;
     static dummy: EventEmitter;
-    constructor(onEvent: OnEvent, onAction: OnAction, onEntrypointEvent: OnEntrypointEvent);
+    private perfSpanId;
+    constructor(onEvent: OnEvent, onAction: OnAction, onEntrypointEvent: OnEntrypointEvent, enabled?: boolean);
     action<TRes>(actonType: string, idx: string, entrypointRef: string, fn: () => TRes): TRes;
     entrypointEvent(sequenceId: number, event: EntrypointEvent): void;
     perf<TRes>(method: string, fn: () => TRes): TRes;
     single(labels: Record<string, unknown>): void;
 }
+export {};

package/types/utils/EventEmitter.js

@@ -8,13 +8,23 @@ export class EventEmitter {
     onEvent;
     onAction;
     onEntrypointEvent;
-    static dummy = new EventEmitter(() => { }, () => 0, () => { });
-    constructor(onEvent, onAction, onEntrypointEvent) {
+    enabled;
+    static dummy = new EventEmitter(() => { }, () => 0, () => { }, false);
+    perfSpanId = 0;
+    constructor(onEvent, onAction, onEntrypointEvent, enabled = true) {
         this.onEvent = onEvent;
         this.onAction = onAction;
         this.onEntrypointEvent = onEntrypointEvent;
+        this.enabled = enabled;
     }
     action(actonType, idx, entrypointRef, fn) {
+        // Fast path: when the emitter is disabled (the dummy used by the
+        // production transform path) skip start/finish bookkeeping and the
+        // Promise hookup. action() is on the hot path for every step of every
+        // action — its per-call overhead is small but ubiquitous.
+        if (!this.enabled) {
+            return fn();
+        }
         const id = this.onAction('start', performance.now(), actonType, idx, entrypointRef);
         try {
             const result = fn();
@@ -35,16 +45,54 @@ export class EventEmitter {
         this.onEntrypointEvent(sequenceId, performance.now(), event);
     }
     perf(method, fn) {
+        // Fast path: see action() above. perf() wraps ~28s of cumulative time
+        // in the production-path CPU profile; the wrapper overhead per call is
+        // small but everywhere.
+        if (!this.enabled) {
+            return fn();
+        }
+        const spanId = this.perfSpanId;
+        this.perfSpanId += 1;
+        const startedAt = performance.now();
         const labels = { method };
-        this.onEvent(labels, 'start');
-        const result = fn();
-        if (result instanceof Promise) {
-            result.then(() => this.onEvent(labels, 'finish'), () => this.onEvent(labels, 'finish'));
+        const startEvent = {
+            method,
+            spanId,
+            startedAt,
+            type: 'perf-span-start',
+        };
+        this.onEvent(labels, 'start', startEvent);
+        const finish = (status, isAsync, error) => {
+            const finishedAt = performance.now();
+            const finishEvent = {
+                durationMs: finishedAt - startedAt,
+                finishedAt,
+                isAsync,
+                method,
+                spanId,
+                startedAt,
+                status,
+                type: 'perf-span',
+            };
+            if (error !== undefined) {
+                finishEvent.error = error;
+            }
+            this.onEvent(labels, 'finish', finishEvent);
+        };
+        try {
+            const result = fn();
+            if (result instanceof Promise) {
+                result.then(() => finish('finished', true), (error) => finish('failed', true, error));
+            }
+            else {
+                finish('finished', false);
+            }
+            return result;
         }
-        else {
-            this.onEvent(labels, 'finish');
+        catch (error) {
+            finish('failed', false, error);
+            throw error;
         }
-        return result;
     }
     single(labels) {
         this.onEvent({

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

@@ -0,0 +1,9 @@
+import type { BaseProcessor, IFileContext } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import { EventEmitter } from '../EventEmitter';
+import type { ApplyOxcProcessorsResult } from './types';
+export declare const applyOxcProcessors: (code: string, fileContext: IFileContext, options: Pick<StrictOptions, "classNameSlug" | "displayName" | "eval" | "extensions" | "staticBindings" | "tagResolver"> & {
+    eventEmitter?: EventEmitter;
+    preserveSideEffectImportOrderLocals?: Set<string>;
+    preserveSideEffectImportLocals?: Set<string>;
+}, callback: (processor: BaseProcessor) => void, cleanupUnused?: boolean) => ApplyOxcProcessorsResult;

package/types/utils/applyOxcProcessors/applyOxcProcessors.js

@@ -0,0 +1,169 @@
+import { collectOxcProcessorImportsFromProgram } from '../collectOxcExportsAndImports';
+import { collectOxcExpressionDependencies } from '../collectOxcTemplateDependencies';
+import { EventEmitter } from '../EventEmitter';
+import { isOxcNode } from '../oxc/ast';
+import { applyOxcReplacements } from '../oxc/replacements';
+import { buildOxcCodeFrameError, createOxcLocationLookup, } from '../oxc/sourceLocations';
+import { getProcessorForImport } from '../processorLookup';
+import { resolveProcessorStaticClassName } from '../processorStaticSemantics';
+import { collectUsedNames } from './cleanupBindings';
+import { addCandidateInlineConstants, collectSameFileProcessorObjectStaticValuesByLocal, collectSameFileProcessorStaticValuesByLocal, collectWYWMetaExtendsHelperNames, getSameFileProcessorObjectProperty, } from './sameFileStaticValues';
+import { collectSameFileProcessorStaticValues, getTagOwner, isTagReferenced, } from './displayName';
+import { buildParams } from './expressionValues';
+import { createProcessor, shouldCollectStaticExpressionValues, } from './processorFactory';
+import { collectProcessorUsages, collectUsageExpressionSpans, } from './processorUsages';
+import { removeUnusedAfterReplacement } from './cleanupRemovals';
+import { insertAddedImports, parseOxc } from './shared';
+export const applyOxcProcessors = (code, fileContext, options, callback, cleanupUnused = false) => {
+    const filename = fileContext.filename ?? 'unknown.js';
+    const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+    const collectStaticExpressionValues = shouldCollectStaticExpressionValues(options);
+    let workingCode = code;
+    let program = parseOxc(workingCode, filename);
+    const definedProcessors = new Map();
+    const removableImportLocals = new Set();
+    const removableExpressionRefs = new Set();
+    eventEmitter.perf('transform:preeval:processTemplate:imports', () => {
+        const imports = eventEmitter.perf('transform:preeval:processTemplate:imports:analysis', () => collectOxcProcessorImportsFromProgram(program, workingCode));
+        eventEmitter.perf('transform:preeval:processTemplate:imports:lookup', () => {
+            imports.forEach((item) => {
+                const localName = item.local.name ?? item.local.code;
+                if (item.imported === 'side-effect' || !localName) {
+                    return;
+                }
+                const [processor, tagSource] = getProcessorForImport({
+                    imported: item.imported,
+                    source: item.source,
+                }, filename, options);
+                if (processor) {
+                    definedProcessors.set(localName, [processor, tagSource]);
+                    removableImportLocals.add(localName);
+                    const rootLocalName = localName.split('.')[0];
+                    if (rootLocalName) {
+                        removableImportLocals.add(rootLocalName);
+                    }
+                }
+            });
+        });
+    });
+    if (definedProcessors.size === 0) {
+        return {
+            code: workingCode,
+            processorClassNamesByLocal: new Map(),
+            processors: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    let processorUsages = eventEmitter.perf('transform:preeval:processTemplate:usages', () => collectProcessorUsages(program, definedProcessors));
+    if (processorUsages.length === 0) {
+        return {
+            code: workingCode,
+            processorClassNamesByLocal: new Map(),
+            processors: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    const targetExpressionSpans = processorUsages.flatMap(collectUsageExpressionSpans);
+    const extracted = targetExpressionSpans.length > 0
+        ? eventEmitter.perf('transform:preeval:processTemplate:deps', () => collectOxcExpressionDependencies(workingCode, filename, collectStaticExpressionValues, targetExpressionSpans, options.staticBindings))
+        : {
+            code: workingCode,
+            dependencyNames: [],
+            expressionValues: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    if (extracted.code !== workingCode) {
+        workingCode = extracted.code;
+        program = eventEmitter.perf('transform:preeval:processTemplate:reparse', () => parseOxc(workingCode, filename));
+        processorUsages = eventEmitter.perf('transform:preeval:processTemplate:usages', () => collectProcessorUsages(program, definedProcessors));
+    }
+    const templateExpressionValues = extracted.expressionValues.map((value) => ({
+        ...value,
+        buildCodeFrameError: (message) => buildOxcCodeFrameError(code, value.ex.loc, message),
+    }));
+    const loc = createOxcLocationLookup(workingCode);
+    const usedNames = eventEmitter.perf('transform:preeval:processTemplate:usedNames', () => collectUsedNames(program));
+    const addedImports = [];
+    const replacements = [];
+    const processors = [];
+    const processorClassNamesByLocal = new Map();
+    const sameFileProcessorsByLocal = new Map();
+    const sameFileProcessorObjectsByLocal = new Map();
+    extracted.dependencyNames.forEach((name) => removableImportLocals.add(name));
+    eventEmitter.perf('transform:preeval:processTemplate:processors', () => {
+        processorUsages.forEach((usage, idx) => {
+            const params = buildParams(usage, workingCode, loc, filename, templateExpressionValues, usage.collapseQualifiedCallee);
+            if (!params) {
+                return;
+            }
+            const created = createProcessor(usage.definedProcessor, params, usage.target, usage.replacementTarget, usage.ancestors, fileContext, options, workingCode, loc, idx, isTagReferenced(program, usage.ancestors), usedNames, replacements);
+            if (!created) {
+                return;
+            }
+            const { astService, processor } = created;
+            const owner = getTagOwner(usage.ancestors);
+            if (owner?.type === 'VariableDeclarator') {
+                const { id } = owner;
+                if (isOxcNode(id) && id.type === 'Identifier') {
+                    removableExpressionRefs.add(id.name);
+                    sameFileProcessorsByLocal.set(id.name, processor);
+                    // Cross-file map (used as a className-only fallback in
+                    // resolveStaticExport) is restricted to processors whose
+                    // runtime value IS the className string. Styled-component
+                    // bindings emit a richer value and must reach consumers via
+                    // resolveProcessorStaticExport so composition still works.
+                    const staticClassName = resolveProcessorStaticClassName(processor);
+                    if (staticClassName) {
+                        processorClassNamesByLocal.set(id.name, staticClassName);
+                    }
+                    else {
+                        const replacement = processor.value;
+                        if ((replacement?.type === 'StringLiteral' ||
+                            replacement?.type === 'Literal') &&
+                            typeof replacement.value === 'string') {
+                            processorClassNamesByLocal.set(id.name, processor.className);
+                        }
+                    }
+                }
+            }
+            const objectProperty = getSameFileProcessorObjectProperty(usage.ancestors);
+            if (objectProperty) {
+                const existing = sameFileProcessorObjectsByLocal.get(objectProperty.localName);
+                const object = existing ?? {
+                    properties: new Map(),
+                    propertyNames: objectProperty.propertyNames,
+                };
+                object.properties.set(objectProperty.propertyName, processor);
+                sameFileProcessorObjectsByLocal.set(objectProperty.localName, object);
+            }
+            processors.push(processor);
+            callback(processor);
+            addedImports.push(...astService.getAddedImports());
+        });
+    });
+    const sameFileProcessorStaticValuesByLocal = collectSameFileProcessorStaticValuesByLocal(sameFileProcessorsByLocal, extracted.expressionValues);
+    const sameFileProcessorObjectStaticValuesByLocal = collectSameFileProcessorObjectStaticValuesByLocal(sameFileProcessorObjectsByLocal, sameFileProcessorsByLocal, extracted.expressionValues);
+    sameFileProcessorObjectStaticValuesByLocal.forEach((value, local) => {
+        sameFileProcessorStaticValuesByLocal.set(local, value);
+    });
+    const replacedCode = applyOxcReplacements(workingCode, replacements);
+    const metadataExtendsHelperNames = collectWYWMetaExtendsHelperNames(replacedCode);
+    const staticValueCandidates = extracted.staticValueCandidates.filter((candidate) => candidate.imports.length > 0 ||
+        !metadataExtendsHelperNames.has(candidate.name));
+    const sameFileProcessorStaticValues = collectSameFileProcessorStaticValues(extracted.expressionValues, sameFileProcessorStaticValuesByLocal);
+    const codeWithAddedImports = insertAddedImports(replacedCode, program, addedImports);
+    return {
+        code: cleanupUnused
+            ? eventEmitter.perf('transform:preeval:processTemplate:cleanup', () => removeUnusedAfterReplacement(codeWithAddedImports, filename, removableImportLocals, new Set([...removableExpressionRefs, ...extracted.dependencyNames]), options.preserveSideEffectImportLocals ?? new Set(), options.preserveSideEffectImportOrderLocals ??
+                options.preserveSideEffectImportLocals ??
+                new Set()))
+            : codeWithAddedImports,
+        processorClassNamesByLocal,
+        processors,
+        staticValueCandidates: addCandidateInlineConstants(staticValueCandidates, sameFileProcessorStaticValuesByLocal),
+        staticValues: [...extracted.staticValues, ...sameFileProcessorStaticValues],
+    };
+};

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

@@ -0,0 +1,12 @@
+import type { Node, Program } from 'oxc-parser';
+import type { TopLevelStatementInfo } from './types';
+export declare const collectUsedNames: (program: Program) => Set<string>;
+export declare const isNodeReference: (node: Node, parent: Node | null) => boolean;
+export declare const collectReferencedNames: (root: Node) => Set<string>;
+export declare const collectImportLocalNames: (node: Node) => string[];
+export declare const getImportSpecifierLocalName: (node: Node) => string | null;
+export declare const collectDeclaredNames: (node: Node) => string[];
+export declare const collectTopLevelBindings: (statement: Node) => Set<string>;
+export declare const collectTopLevelStatementInfos: (program: Program) => TopLevelStatementInfo[];
+export declare const collectTopLevelBindingsFromStatements: (statements: TopLevelStatementInfo[]) => Set<string>;
+export declare const collectRemovableNamesFromStatements: (statements: TopLevelStatementInfo[], initialNames: Set<string>) => Set<string>;