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

package/types/transform/generators/resolveStaticOxcValues/programAnalysis.js

@@ -0,0 +1,133 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { collectImportBindings, isSafeLiteral, unwrapExpression, } from './staticExpression';
+export const collectLocalConstExpressions = (program) => {
+    const result = new Map();
+    const collect = (declaration) => {
+        if (declaration.kind !== 'const') {
+            return;
+        }
+        declaration.declarations.forEach((declarator) => {
+            if (declarator.id.type === 'Identifier' && declarator.init) {
+                result.set(declarator.id.name, declarator.init);
+            }
+        });
+    };
+    program.body.forEach((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            collect(statement);
+            return;
+        }
+        if (statement.type === 'ExportNamedDeclaration' &&
+            statement.declaration?.type === 'VariableDeclaration') {
+            collect(statement.declaration);
+        }
+    });
+    return result;
+};
+export const objectPropertyKeyName = (node) => {
+    const unwrapped = unwrapExpression(node);
+    if (unwrapped.type === 'Identifier') {
+        return unwrapped.name;
+    }
+    if (isSafeLiteral(unwrapped) && typeof unwrapped.value === 'string') {
+        return unwrapped.value;
+    }
+    return null;
+};
+export const findObjectPropertyValue = (expr, name) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'ObjectExpression') {
+        return null;
+    }
+    for (const property of unwrapped.properties) {
+        if (property.type === 'SpreadElement') {
+            continue;
+        }
+        const propertyNode = property;
+        if (propertyNode.computed) {
+            continue;
+        }
+        const key = propertyNode.key;
+        const value = propertyNode.value;
+        if (key && value && objectPropertyKeyName(key) === name) {
+            return value;
+        }
+    }
+    return null;
+};
+export const topLevelStatements = (program) => {
+    const result = [];
+    program.body.forEach((statement) => {
+        if (statement.type === 'ExportNamedDeclaration' ||
+            statement.type === 'ExportDefaultDeclaration') {
+            result.push(statement.declaration ?? statement);
+            return;
+        }
+        result.push(statement);
+    });
+    return result;
+};
+export const findTopLevelConstExpression = (program, name) => {
+    for (const statement of topLevelStatements(program)) {
+        if (statement.type !== 'VariableDeclaration' ||
+            statement.kind !== 'const') {
+            continue;
+        }
+        for (const declarator of statement.declarations) {
+            if (declarator.id.type === 'Identifier' &&
+                declarator.id.name === name &&
+                declarator.init) {
+                return declarator.init;
+            }
+        }
+    }
+    return null;
+};
+export const hasTopLevelBinding = (program, name) => {
+    if (collectImportBindings(program).has(name)) {
+        return true;
+    }
+    return topLevelStatements(program).some((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            return statement.declarations.some((declarator) => declarator.id.type === 'Identifier' && declarator.id.name === name);
+        }
+        if (statement.type === 'FunctionDeclaration') {
+            return statement.id?.name === name;
+        }
+        if (statement.type === 'ClassDeclaration') {
+            return statement.id?.name === name;
+        }
+        return false;
+    });
+};
+export const isTopLevelFunctionOrClass = (program, name) => topLevelStatements(program).some((statement) => {
+    if (statement.type === 'FunctionDeclaration') {
+        return statement.id?.name === name;
+    }
+    if (statement.type === 'ClassDeclaration') {
+        return statement.id?.name === name;
+    }
+    return false;
+});
+export const functionReturnExpression = (expr, options = {}) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'ArrowFunctionExpression' &&
+        unwrapped.type !== 'FunctionExpression') {
+        return null;
+    }
+    if (unwrapped.async ||
+        (!options.allowParams && unwrapped.params.length > 0) ||
+        !unwrapped.body) {
+        return null;
+    }
+    if (unwrapped.body.type !== 'BlockStatement') {
+        return unwrapped.body;
+    }
+    if (unwrapped.body.body.length !== 1) {
+        return null;
+    }
+    const [statement] = unwrapped.body.body;
+    return statement.type === 'ReturnStatement' && statement.argument
+        ? statement.argument
+        : null;
+};

package/types/transform/generators/resolveStaticOxcValues/prune.d.ts

@@ -0,0 +1,15 @@
+import type { ImportDeclaration, Node, Program } from 'oxc-parser';
+export declare const isIdentifierBindingPosition: (node: Node, parent: Node | null) => boolean;
+export declare const isPropertyKeyOnlyIdentifier: (node: Node, parent: Node | null) => boolean;
+export declare const collectUsedIdentifierNames: (program: Program) => Set<string>;
+export declare const removableStaticHelperNames: (program: Program, staticValueNames: Set<string>) => Set<string>;
+export declare const collectImportLocalReferences: (node: Node, importLocals: Set<string>, result: Set<string>) => void;
+export declare const removeStaticHelperDeclarations: (code: string, filename: string, staticValueNames: Set<string>) => {
+    code: string;
+    removed: Set<string>;
+    removedImportLocals: Set<string>;
+};
+export declare const importSpecifierLocalName: (specifier: ImportDeclaration["specifiers"][number]) => string | null;
+export declare const removeUnusedStaticImports: (code: string, filename: string, staticImportLocals: Set<string>, sideEffectImportLocals: Set<string>) => string;
+export declare const replaceStaticWYWMetaExtendsHelpers: (code: string, filename: string, helperValues: Map<string, unknown>) => string;
+export declare const pruneStaticPreevalCode: (code: string, filename: string, staticValueNames: Set<string>, staticImportLocals: Set<string>, staticExtendsHelperValues: Map<string, unknown>, sideEffectImportLocals: Set<string>) => string;

package/types/transform/generators/resolveStaticOxcValues/prune.js

@@ -0,0 +1,220 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { getOxcNodeChildren } from '../../../utils/oxc/ast';
+import { applyOxcReplacements } from '../../../utils/oxc/replacements';
+import { parseProgram } from './environment';
+import { collectImportBindings, unwrapExpression } from './staticExpression';
+import { findWYWMetaExtendsExpression, staticWYWMetaExtendsReplacementCode, } from './processorStaticModel';
+export const isIdentifierBindingPosition = (node, parent) => {
+    if (node.type !== 'Identifier' || !parent) {
+        return false;
+    }
+    if ((parent.type === 'VariableDeclarator' && parent.id === node) ||
+        (parent.type === 'FunctionDeclaration' && parent.id === node) ||
+        (parent.type === 'FunctionExpression' && parent.id === node) ||
+        (parent.type === 'ClassDeclaration' && parent.id === node) ||
+        (parent.type === 'ClassExpression' && parent.id === node)) {
+        return true;
+    }
+    if ((parent.type === 'ArrowFunctionExpression' ||
+        parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression') &&
+        parent.params.some((param) => param === node)) {
+        return true;
+    }
+    return ((parent.type === 'ImportSpecifier' && parent.local === node) ||
+        (parent.type === 'ImportDefaultSpecifier' && parent.local === node) ||
+        (parent.type === 'ImportNamespaceSpecifier' && parent.local === node));
+};
+export const isPropertyKeyOnlyIdentifier = (node, parent) => node.type === 'Identifier' &&
+    !!parent &&
+    ((parent.type === 'MemberExpression' &&
+        parent.property === node &&
+        !parent.computed) ||
+        (parent.type === 'Property' &&
+            parent.key === node &&
+            !parent.computed &&
+            !parent.shorthand));
+export const collectUsedIdentifierNames = (program) => {
+    const used = new Set();
+    const walk = (node, parent) => {
+        if (node.type === 'ImportDeclaration') {
+            return;
+        }
+        if (node.type === 'Identifier' &&
+            !isIdentifierBindingPosition(node, parent) &&
+            !isPropertyKeyOnlyIdentifier(node, parent)) {
+            used.add(node.name);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(program, null);
+    return used;
+};
+export const removableStaticHelperNames = (program, staticValueNames) => {
+    const used = collectUsedIdentifierNames(program);
+    const result = new Set();
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration') {
+            return;
+        }
+        statement.declarations.forEach((declarator) => {
+            if (declarator.id.type === 'Identifier' &&
+                staticValueNames.has(declarator.id.name) &&
+                !used.has(declarator.id.name)) {
+                result.add(declarator.id.name);
+            }
+        });
+    });
+    return result;
+};
+export const collectImportLocalReferences = (node, importLocals, result) => {
+    const walk = (item, parent) => {
+        if (item.type === 'Identifier' &&
+            importLocals.has(item.name) &&
+            !isIdentifierBindingPosition(item, parent) &&
+            !isPropertyKeyOnlyIdentifier(item, parent)) {
+            result.add(item.name);
+        }
+        getOxcNodeChildren(item).forEach((child) => walk(child, item));
+    };
+    walk(node, null);
+};
+export const removeStaticHelperDeclarations = (code, filename, staticValueNames) => {
+    if (staticValueNames.size === 0) {
+        return { code, removed: new Set(), removedImportLocals: new Set() };
+    }
+    const program = parseProgram(code, filename);
+    const removableNames = removableStaticHelperNames(program, staticValueNames);
+    const importLocals = new Set();
+    collectImportBindings(program).forEach((_, local) => importLocals.add(local));
+    const removedImportLocals = new Set();
+    const ranges = [];
+    const replacements = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration' ||
+            statement.declarations.length === 0) {
+            return;
+        }
+        const removableIndexes = statement.declarations.flatMap((declarator, index) => declarator.id.type === 'Identifier' &&
+            removableNames.has(declarator.id.name)
+            ? [index]
+            : []);
+        if (removableIndexes.length === 0) {
+            return;
+        }
+        removableIndexes.forEach((index) => {
+            collectImportLocalReferences(statement.declarations[index], importLocals, removedImportLocals);
+        });
+        if (removableIndexes.length === statement.declarations.length) {
+            ranges.push({
+                end: statement.end,
+                start: statement.start,
+            });
+            return;
+        }
+        const keptDeclarations = statement.declarations
+            .filter((_, index) => !removableIndexes.includes(index))
+            .map((declarator) => code.slice(declarator.start, declarator.end));
+        replacements.push({
+            end: statement.end,
+            start: statement.start,
+            text: `${statement.kind} ${keptDeclarations.join(', ')};`,
+        });
+    });
+    return {
+        code: applyOxcReplacements(code, [
+            ...ranges.map((range) => ({ ...range, text: '' })),
+            ...replacements,
+        ]),
+        removed: removableNames,
+        removedImportLocals,
+    };
+};
+export const importSpecifierLocalName = (specifier) => specifier.local?.name ?? null;
+export const removeUnusedStaticImports = (code, filename, staticImportLocals, sideEffectImportLocals) => {
+    if (staticImportLocals.size === 0) {
+        return code;
+    }
+    const program = parseProgram(code, filename);
+    const used = collectUsedIdentifierNames(program);
+    const ranges = [];
+    const replacements = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration' ||
+            statement.specifiers.length === 0) {
+            return;
+        }
+        const removable = statement.specifiers.flatMap((specifier, index) => {
+            const localName = importSpecifierLocalName(specifier);
+            return localName &&
+                staticImportLocals.has(localName) &&
+                !used.has(localName)
+                ? [{ index, localName }]
+                : [];
+        });
+        if (removable.length === 0) {
+            return;
+        }
+        if (removable.length === statement.specifiers.length) {
+            if (removable.some((item) => sideEffectImportLocals.has(item.localName))) {
+                replacements.push({
+                    end: statement.end,
+                    start: statement.start,
+                    text: `import ${code.slice(statement.source.start, statement.source.end)};`,
+                });
+                return;
+            }
+            ranges.push({
+                end: statement.end,
+                start: statement.start,
+            });
+        }
+    });
+    return applyOxcReplacements(code, [
+        ...ranges.map((range) => ({ ...range, text: '' })),
+        ...replacements,
+    ]);
+};
+export const replaceStaticWYWMetaExtendsHelpers = (code, filename, helperValues) => {
+    if (helperValues.size === 0) {
+        return code;
+    }
+    const program = parseProgram(code, filename);
+    const replacements = [];
+    const visit = (node) => {
+        if (node.type === 'ObjectExpression') {
+            const extendsExpression = findWYWMetaExtendsExpression(node);
+            if (extendsExpression) {
+                const unwrapped = unwrapExpression(extendsExpression);
+                if (unwrapped.type === 'CallExpression' &&
+                    unwrapped.callee.type === 'Identifier' &&
+                    unwrapped.arguments.length === 0 &&
+                    helperValues.has(unwrapped.callee.name)) {
+                    const replacement = staticWYWMetaExtendsReplacementCode(helperValues.get(unwrapped.callee.name));
+                    if (replacement) {
+                        replacements.push({
+                            end: extendsExpression.end,
+                            start: extendsExpression.start,
+                            text: replacement,
+                        });
+                    }
+                }
+            }
+        }
+        getOxcNodeChildren(node).forEach(visit);
+    };
+    visit(program);
+    return applyOxcReplacements(code, replacements);
+};
+export const pruneStaticPreevalCode = (code, filename, staticValueNames, staticImportLocals, staticExtendsHelperValues, sideEffectImportLocals) => {
+    const codeWithMetadataPruned = replaceStaticWYWMetaExtendsHelpers(code, filename, staticExtendsHelperValues);
+    const helpersRemoved = removeStaticHelperDeclarations(codeWithMetadataPruned, filename, staticValueNames);
+    if (helpersRemoved.removed.size === 0) {
+        return codeWithMetadataPruned;
+    }
+    const importLocalsToPrune = new Set([
+        ...staticImportLocals,
+        ...helpersRemoved.removedImportLocals,
+    ]);
+    return removeUnusedStaticImports(helpersRemoved.code, filename, importLocalsToPrune, sideEffectImportLocals);
+};

package/types/transform/generators/resolveStaticOxcValues/resolveStaticOxcPreevalValues.d.ts

@@ -0,0 +1,2 @@
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+export declare function resolveStaticOxcPreevalValues(this: ITransformAction): SyncScenarioFor<boolean>;

package/types/transform/generators/resolveStaticOxcValues/resolveStaticOxcPreevalValues.js

@@ -0,0 +1,197 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { isAbsolute } from 'path';
+import { appendOxcWywPreval } from '../../../utils/oxcPreevalStage';
+import { stripQueryAndHash } from '../../../utils/parseRequest';
+import { resolveCandidateValue, resolveOpaqueRuntimeCandidateValue, } from './candidateResolver';
+import { debugStaticResolve, getEvalStrategy, getStaticStrategyFailure, parseProgram, } from './environment';
+import { collectWYWMetaExtendsHelperNames, createSameFileStaticWYWMetaHelperResolver, } from './processorStaticModel';
+import { pruneStaticPreevalCode } from './prune';
+import { runtimeCallbackPlaceholder } from './staticExpression';
+export function* resolveStaticOxcPreevalValues() {
+    const preevalResult = this.entrypoint.getPreevalResult();
+    if (!preevalResult) {
+        return false;
+    }
+    const candidates = preevalResult.staticValueCandidates ?? [];
+    const evalDependencyNames = new Set(preevalResult.dependencyNames ?? []);
+    if (candidates.length === 0 && evalDependencyNames.size === 0) {
+        return false;
+    }
+    const filename = this.entrypoint.loadedAndParsed.evaluator === 'ignored'
+        ? this.entrypoint.name
+        : this.entrypoint.loadedAndParsed.evalConfig.filename ??
+            this.entrypoint.name;
+    const evalStrategy = getEvalStrategy(this);
+    if (evalStrategy === 'execute') {
+        return false;
+    }
+    const staticOnly = evalStrategy === 'static';
+    const staticValueCache = preevalResult.staticValueCache ?? new Map();
+    const staticDependencies = new Set(preevalResult.staticDependencies ?? []);
+    const staticImportLocals = new Set();
+    const sideEffectImportLocals = new Set();
+    const staticNullWYWMetaExtendsHelpers = new Set(preevalResult.staticNullWYWMetaExtendsHelpers ?? []);
+    const memo = new Map();
+    const opaqueRuntimeBaseHelpers = collectWYWMetaExtendsHelperNames(parseProgram(preevalResult.baseCode ?? preevalResult.code, filename));
+    // Names of candidates resolved to runtime callbacks (function values).
+    // They keep the file out of evalFile but their helper declarations must
+    // not be pruned — the runtime call site relies on them.
+    const runtimeOnlyCandidateNames = new Set(preevalResult.runtimeOnlyStaticValueNames ?? []);
+    let changed = false;
+    let hasKnownStaticCandidate = false;
+    const resolveSameFileStaticWYWMetaHelpers = createSameFileStaticWYWMetaHelperResolver(preevalResult.baseCode ?? preevalResult.code, filename);
+    const applySameFileStaticWYWMetaHelpers = () => {
+        let appliedAny = false;
+        for (;;) {
+            let applied = false;
+            const values = resolveSameFileStaticWYWMetaHelpers(staticValueCache);
+            values.forEach((value, name) => {
+                if (staticValueCache.has(name) ||
+                    (!evalDependencyNames.has(name) &&
+                        !opaqueRuntimeBaseHelpers.has(name))) {
+                    return;
+                }
+                staticValueCache.set(name, value);
+                debugStaticResolve(this, {
+                    candidate: name,
+                    filename,
+                    phase: 'candidate',
+                    reason: 'same-file-static-metadata',
+                    status: 'resolved',
+                });
+                applied = true;
+            });
+            if (!applied) {
+                break;
+            }
+            appliedAny = true;
+        }
+        if (appliedAny) {
+            changed = true;
+            hasKnownStaticCandidate = true;
+        }
+        return appliedAny;
+    };
+    applySameFileStaticWYWMetaHelpers();
+    for (const candidate of candidates) {
+        applySameFileStaticWYWMetaHelpers();
+        const isOpaqueRuntimeBaseHelper = opaqueRuntimeBaseHelpers.has(candidate.name);
+        if (!evalDependencyNames.has(candidate.name) &&
+            !isOpaqueRuntimeBaseHelper &&
+            !staticValueCache.has(candidate.name)) {
+            debugStaticResolve(this, {
+                candidate: candidate.name,
+                filename,
+                phase: 'candidate',
+                reason: 'not-eval-dependency',
+                status: 'skipped',
+            });
+            continue;
+        }
+        if (staticValueCache.has(candidate.name)) {
+            hasKnownStaticCandidate = true;
+            candidate.imports.forEach((item) => staticImportLocals.add(item.importLocal ?? item.local));
+            if (isOpaqueRuntimeBaseHelper &&
+                staticValueCache.get(candidate.name) === null) {
+                staticNullWYWMetaExtendsHelpers.add(candidate.name);
+            }
+            debugStaticResolve(this, {
+                candidate: candidate.name,
+                filename,
+                phase: 'candidate',
+                reason: 'already-static',
+                status: 'skipped',
+            });
+            continue;
+        }
+        let resolved;
+        let resolvedOpaqueRuntimeBase = false;
+        if (isOpaqueRuntimeBaseHelper) {
+            resolved = yield* resolveOpaqueRuntimeCandidateValue(this, candidate, filename);
+            resolvedOpaqueRuntimeBase = !!resolved;
+            if (!resolved) {
+                resolved = yield* resolveCandidateValue(this, candidate, filename, memo);
+            }
+        }
+        else {
+            resolved = yield* resolveCandidateValue(this, candidate, filename, memo);
+        }
+        if (!resolved) {
+            continue;
+        }
+        if (resolvedOpaqueRuntimeBase) {
+            debugStaticResolve(this, {
+                candidate: candidate.name,
+                filename,
+                phase: 'candidate',
+                reason: 'opaque-runtime-component',
+                status: 'resolved',
+            });
+            staticNullWYWMetaExtendsHelpers.add(candidate.name);
+        }
+        if (resolved.runtimeOnly) {
+            // Runtime callback — seed a callable placeholder for collect() but
+            // track it separately so the `_exp = () => target` helper survives
+            // pruning. The runtime call site relies on that helper declaration.
+            runtimeOnlyCandidateNames.add(candidate.name);
+            staticValueCache.set(candidate.name, runtimeCallbackPlaceholder);
+        }
+        else {
+            staticValueCache.set(candidate.name, resolved.value);
+        }
+        hasKnownStaticCandidate = true;
+        candidate.imports.forEach((item) => staticImportLocals.add(item.importLocal ?? item.local));
+        resolved.dependencies.forEach((dependency) => staticDependencies.add(dependency));
+        resolved.sideEffectImportLocals?.forEach((local) => sideEffectImportLocals.add(local));
+        changed = true;
+        applySameFileStaticWYWMetaHelpers();
+    }
+    if (!changed &&
+        (!hasKnownStaticCandidate || preevalResult.staticValuesApplied)) {
+        if (staticOnly && evalDependencyNames.size > 0) {
+            throw getStaticStrategyFailure(filename, evalDependencyNames);
+        }
+        return false;
+    }
+    const dependencyNames = (preevalResult.dependencyNames ?? []).filter((name) => !staticValueCache.has(name) && !runtimeOnlyCandidateNames.has(name));
+    if (staticOnly && dependencyNames.length > 0) {
+        throw getStaticStrategyFailure(filename, dependencyNames);
+    }
+    preevalResult.dependencyNames = dependencyNames;
+    preevalResult.staticValueCache = staticValueCache;
+    preevalResult.staticDependencies = [...staticDependencies];
+    preevalResult.staticNullWYWMetaExtendsHelpers = [
+        ...staticNullWYWMetaExtendsHelpers,
+    ];
+    preevalResult.runtimeOnlyStaticValueNames = [...runtimeOnlyCandidateNames];
+    preevalResult.staticValuesApplied = true;
+    const originalBaseCode = preevalResult.baseCode ?? preevalResult.code;
+    const prunableStaticValueNames = new Set([...staticValueCache.keys()].filter((name) => !runtimeOnlyCandidateNames.has(name)));
+    const staticExtendsHelperValues = new Map([...staticValueCache].filter(([name]) => !runtimeOnlyCandidateNames.has(name)));
+    staticNullWYWMetaExtendsHelpers.forEach((name) => {
+        if (!staticExtendsHelperValues.has(name)) {
+            staticExtendsHelperValues.set(name, null);
+        }
+    });
+    const baseCode = pruneStaticPreevalCode(originalBaseCode, filename, prunableStaticValueNames, staticImportLocals, staticExtendsHelperValues, sideEffectImportLocals);
+    const evalBaseCode = sideEffectImportLocals.size > 0
+        ? pruneStaticPreevalCode(originalBaseCode, filename, prunableStaticValueNames, staticImportLocals, staticExtendsHelperValues, new Set())
+        : baseCode;
+    preevalResult.baseCode = baseCode;
+    preevalResult.code = appendOxcWywPreval(baseCode, filename, dependencyNames);
+    preevalResult.evalCode = appendOxcWywPreval(evalBaseCode, filename, dependencyNames);
+    preevalResult.staticSideEffectImportLocals = [...sideEffectImportLocals];
+    for (const dependency of staticDependencies) {
+        const strippedDependency = stripQueryAndHash(dependency);
+        if (isAbsolute(strippedDependency)) {
+            this.services.cache.checkFreshness(dependency, strippedDependency);
+        }
+        this.entrypoint.addInvalidationDependency({
+            only: ['*'],
+            resolved: dependency,
+            source: dependency,
+        });
+        this.entrypoint.markInvalidateOnDependencyChange(dependency);
+    }
+    return true;
+}

package/types/transform/generators/resolveStaticOxcValues/staticExpression.d.ts

@@ -0,0 +1,25 @@
+import type { Expression, ImportDeclaration, ModuleExportName, Node, Program } from 'oxc-parser';
+import type { CollectImportBindingsOptions, ImportBinding, StaticExportResult, StaticExpressionOptions } from './types';
+export declare const moduleExportName: (node: ModuleExportName) => string;
+export declare const unwrapExpression: (expr: Node) => Node;
+export declare const isProcessEnvMember: (node: Node) => boolean;
+export declare const isSafeLiteral: (node: Node) => node is Node & {
+    type: "Literal";
+    value: boolean | null | number | string;
+};
+export declare const isSafeStaticExpression: (expr: Node, options?: StaticExpressionOptions) => boolean;
+export declare const isTypeOnlyImport: (statement: ImportDeclaration) => boolean;
+export declare const getImportBinding: (statement: ImportDeclaration, specifier: ImportDeclaration["specifiers"][number], options?: CollectImportBindingsOptions) => ImportBinding | null;
+export declare const collectImportBindings: (program: Program, options?: CollectImportBindingsOptions) => Map<string, ImportBinding>;
+export declare const parseStaticExpressionSource: (source: string, filename: string) => Expression | null;
+export declare const isRuntimeCallbackExpression: (expression: Expression | null) => boolean;
+export declare const runtimeCallbackPlaceholder: () => undefined;
+export declare const isIdentifierBindingPosition: (node: Node, parent: Node | null) => boolean;
+export declare const isPropertyKeyOnlyIdentifier: (node: Node, parent: Node | null) => boolean;
+export declare const expressionUsesNameOnlyAsZeroArgCalls: (expression: Node, name: string) => boolean;
+export declare const bindStaticResolvedValue: (env: Map<string, unknown>, expression: Node, local: string, resolved: StaticExportResult, options?: {
+    wrapNonCallable?: boolean;
+}) => boolean;
+export declare const isSafeFunctionBodyExpression: (body: Node, options: StaticExpressionOptions) => boolean;
+export declare const collectStaticFunctionBodyReferences: (body: Node, references: Set<string>, options: StaticExpressionOptions) => boolean;
+export declare const collectStaticExpressionReferences: (expr: Node, references: Set<string>, options?: StaticExpressionOptions) => boolean;