@wyw-in-js/transform 0.8.0 → 1.0.0

package/types/options/buildOptions.js

@@ -1,14 +1,131 @@
 "use strict";
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="./babel-merge.d.ts" />
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOptions = void 0;
-const babel_merge_1 = __importDefault(require("babel-merge"));
+exports.buildOptions = buildOptions;
 const isNotNull_1 = require("../utils/isNotNull");
 const cache = new WeakMap();
+const isPlainObject = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+const mergeArraysUnique = (source = [], overrides = []) => [
+    ...new Set([...source, ...overrides]),
+];
+const mergeUnknown = (source, overrides) => {
+    if (Array.isArray(source) && Array.isArray(overrides)) {
+        return mergeArraysUnique(source, overrides);
+    }
+    if (isPlainObject(source) && isPlainObject(overrides)) {
+        const result = { ...source };
+        for (const [key, value] of Object.entries(overrides)) {
+            result[key] = key in source ? mergeUnknown(source[key], value) : value;
+        }
+        return result;
+    }
+    return overrides;
+};
+const getItemKey = (item) => {
+    if (typeof item === 'string')
+        return item;
+    if (Array.isArray(item))
+        return getItemKey(item[0]);
+    if (typeof item === 'object' && item !== null && 'key' in item) {
+        const { key } = item;
+        return typeof key === 'string' ? key : null;
+    }
+    return null;
+};
+const getItemOptions = (item) => {
+    if (!Array.isArray(item))
+        return {};
+    const options = item[1];
+    return isPlainObject(options) ? options : {};
+};
+const toItemWithOptions = (key, options) => Object.keys(options).length ? [key, options] : key;
+const normalizeKey = (key) => key.replace(/\\/g, '/');
+const extractPackageNameFromPath = (key) => {
+    const match = normalizeKey(key).match(/\/node_modules\/(@[^/]+\/[^/]+|[^/]+)\//);
+    return match?.[1] ?? null;
+};
+const addBabelVariants = (kind, variants, key) => {
+    const prefix = kind === 'preset'
+        ? ['@babel/preset-', 'babel-preset-']
+        : ['@babel/plugin-', 'babel-plugin-'];
+    const normalized = normalizeKey(key);
+    variants.add(normalized);
+    const packageNameFromPath = extractPackageNameFromPath(normalized);
+    if (packageNameFromPath) {
+        variants.add(packageNameFromPath);
+    }
+    for (const p of prefix) {
+        if (normalized.startsWith(p)) {
+            variants.add(normalized.slice(p.length));
+        }
+    }
+    if (!normalized.includes('/') && !normalized.startsWith('.')) {
+        variants.add(`${prefix[0]}${normalized}`);
+        variants.add(`${prefix[1]}${normalized}`);
+    }
+};
+const areKeysCompatible = (kind, a, b) => {
+    const aVariants = new Set();
+    addBabelVariants(kind, aVariants, a);
+    const bVariants = new Set();
+    addBabelVariants(kind, bVariants, b);
+    for (const aVar of aVariants) {
+        if (bVariants.has(aVar))
+            return true;
+    }
+    return false;
+};
+const mergeConfigItems = (kind, source, overrides) => {
+    const combined = [...(source ?? []), ...(overrides ?? [])];
+    return combined.reduce((reduction, override) => {
+        const overrideKey = getItemKey(override);
+        if (!overrideKey) {
+            reduction.push(override);
+            return reduction;
+        }
+        const overrideOptions = getItemOptions(override);
+        const base = reduction.find((candidate) => {
+            const baseKey = getItemKey(candidate);
+            return baseKey ? areKeysCompatible(kind, baseKey, overrideKey) : false;
+        });
+        if (!base) {
+            reduction.push(toItemWithOptions(overrideKey, overrideOptions));
+            return reduction;
+        }
+        const index = reduction.indexOf(base);
+        const baseKey = getItemKey(base) ?? overrideKey;
+        const baseOptions = getItemOptions(base);
+        const options = mergeUnknown(baseOptions, overrideOptions);
+        reduction.splice(index, 1, toItemWithOptions(baseKey, options));
+        return reduction;
+    }, []);
+};
+const babelMerge = (source, overrides) => {
+    const { plugins: sourcePlugins, presets: sourcePresets, env: sourceEnv, ...sourceRest } = source;
+    const { plugins: overridesPlugins, presets: overridesPresets, env: overridesEnv, ...overridesRest } = overrides;
+    const plugins = mergeConfigItems('plugin', sourcePlugins, overridesPlugins);
+    const presets = mergeConfigItems('preset', sourcePresets, overridesPresets);
+    const merged = mergeUnknown(sourceRest, overridesRest);
+    if (presets.length)
+        merged.presets = presets;
+    if (plugins.length)
+        merged.plugins = plugins;
+    const envNames = new Set([
+        ...Object.keys(sourceEnv ?? {}),
+        ...Object.keys(overridesEnv ?? {}),
+    ]);
+    if (envNames.size) {
+        merged.env = {};
+        for (const name of envNames) {
+            merged.env[name] = babelMerge(sourceEnv?.[name] ?? {}, overridesEnv?.[name] ?? {});
+        }
+    }
+    return merged;
+};
 const merge = (a, b) => {
     if (!cache.has(a)) {
         cache.set(a, new WeakMap());
@@ -17,7 +134,7 @@ const merge = (a, b) => {
     if (cacheForA.has(b)) {
         return cacheForA.get(b);
     }
-    const result = (0, babel_merge_1.default)(a, b);
+    const result = babelMerge(a, b);
     cacheForA.set(b, result);
     return result;
 };
@@ -32,4 +149,3 @@ function buildOptions(...configs) {
         .filter(isNotNull_1.isNotNull)
         .reduce(merge);
 }
-exports.buildOptions = buildOptions;

package/types/options/loadBabelOptions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadBabelOptions = void 0;
+exports.loadBabelOptions = loadBabelOptions;
 const cache = new WeakMap();
 const empty = {};
 function loadBabelOptions(babel, filename, overrides = empty) {
@@ -24,4 +24,3 @@ function loadBabelOptions(babel, filename, overrides = empty) {
     cache.set(overrides, fileCache);
     return babelOptions;
 }
-exports.loadBabelOptions = loadBabelOptions;

package/types/plugins/babel-transform.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = babelTransform;
 const shared_1 = require("@wyw-in-js/shared");
 const loadWywOptions_1 = require("../transform/helpers/loadWywOptions");
 const cache_1 = require("../cache");
@@ -46,4 +47,3 @@ function babelTransform(babel, options) {
         },
     };
 }
-exports.default = babelTransform;

package/types/plugins/collector.js

@@ -4,7 +4,9 @@
  * all usages of WYW-processors.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collector = exports.filename = void 0;
+exports.filename = void 0;
+exports.collector = collector;
+exports.default = collectorPlugin;
 const shared_1 = require("@wyw-in-js/shared");
 const EventEmitter_1 = require("../utils/EventEmitter");
 const getTagProcessor_1 = require("../utils/getTagProcessor");
@@ -32,7 +34,6 @@ function collector(file, options, values) {
     }
     return processors;
 }
-exports.collector = collector;
 function collectorPlugin(babel, options) {
     const values = options.values ?? new Map();
     const debug = shared_1.logger.extend('collector');
@@ -59,4 +60,3 @@ function collectorPlugin(babel, options) {
         },
     };
 }
-exports.default = collectorPlugin;

package/types/plugins/dynamic-import.js

@@ -1,40 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dynamicImport;
+const getMemberExpressionPropertyName_1 = require("../utils/getMemberExpressionPropertyName");
+const unwrapExpression_1 = require("../utils/unwrapExpression");
 /**
  * The plugin that replaces `import()` with `__wyw_dynamic_import` as Node VM does not support dynamic imports yet.
  */
 function dynamicImport(babel) {
     const { types: t } = babel;
+    const isStringLikeExpression = (node) => {
+        const expression = (0, unwrapExpression_1.unwrapExpression)(node);
+        if (t.isStringLiteral(expression) || t.isTemplateLiteral(expression)) {
+            return true;
+        }
+        if (t.isBinaryExpression(expression) && expression.operator === '+') {
+            return ((t.isExpression(expression.left) &&
+                isStringLikeExpression(expression.left)) ||
+                (t.isExpression(expression.right) &&
+                    isStringLikeExpression(expression.right)));
+        }
+        if (t.isCallExpression(expression)) {
+            const { callee } = expression;
+            if (!t.isMemberExpression(callee)) {
+                return false;
+            }
+            const propertyName = (0, getMemberExpressionPropertyName_1.getMemberExpressionPropertyName)(callee);
+            if (propertyName !== 'concat') {
+                return false;
+            }
+            if (!t.isExpression(callee.object)) {
+                return false;
+            }
+            return isStringLikeExpression(callee.object);
+        }
+        return false;
+    };
     return {
         name: '@wyw-in-js/transform/dynamic-import',
         visitor: {
             CallExpression(path) {
                 if (path.get('callee').isImport()) {
                     const moduleName = path.get('arguments.0');
-                    if (moduleName.isStringLiteral()) {
+                    const argument = moduleName.isExpression() ? moduleName.node : null;
+                    if (argument) {
+                        const unwrappedArgument = (0, unwrapExpression_1.unwrapExpression)(argument);
+                        const nextArgument = isStringLikeExpression(argument)
+                            ? t.cloneNode(unwrappedArgument, true, true)
+                            : t.cloneNode(argument, true, true);
                         path.replaceWith(t.callExpression(t.identifier('__wyw_dynamic_import'), [
-                            t.stringLiteral(moduleName.node.value),
+                            nextArgument,
                         ]));
                         return;
                     }
-                    if (moduleName.isTemplateLiteral()) {
-                        path.replaceWith(t.callExpression(t.identifier('__wyw_dynamic_import'), [
-                            t.cloneNode(moduleName.node, true, true),
-                        ]));
-                        return;
-                    }
-                    // Throw an error if this import will be reached during evaluation
-                    // throw new Error(
-                    //   'Dynamic import argument must be a string or a template literal'
-                    // );
-                    path.replaceWith(t.callExpression(t.arrowFunctionExpression([], t.blockStatement([
-                        t.throwStatement(t.newExpression(t.identifier('Error'), [
-                            t.stringLiteral('Dynamic import argument must be a string or a template literal'),
-                        ])),
-                    ])), []));
+                    path.replaceWith(t.callExpression(t.identifier('__wyw_dynamic_import'), []));
                 }
             },
         },
     };
 }
-exports.default = dynamicImport;

package/types/plugins/preeval.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.preeval = void 0;
+exports.preeval = preeval;
 const shared_1 = require("@wyw-in-js/shared");
 const getTagProcessor_1 = require("../utils/getTagProcessor");
 const EventEmitter_1 = require("../utils/EventEmitter");
 const addIdentifierToWywPreval_1 = require("../utils/addIdentifierToWywPreval");
 const getFileIdx_1 = require("../utils/getFileIdx");
 const removeDangerousCode_1 = require("../utils/removeDangerousCode");
+const replaceImportMetaEnv_1 = require("../utils/replaceImportMetaEnv");
 const traversalCache_1 = require("../utils/traversalCache");
 function preeval(babel, options) {
     const { types: t } = babel;
@@ -30,6 +31,9 @@ function preeval(babel, options) {
                     this.processors.push(processor);
                 });
             });
+            eventEmitter.perf('transform:preeval:importMetaEnv', () => {
+                (0, replaceImportMetaEnv_1.replaceImportMetaEnv)(file.path, t);
+            });
             if ((0, shared_1.isFeatureEnabled)(options.features, 'dangerousCodeRemover', filename)) {
                 log('start', 'Strip all JSX and browser related stuff');
                 eventEmitter.perf('transform:preeval:removeDangerousCode', () => (0, removeDangerousCode_1.removeDangerousCode)(file.path, options.codeRemover));
@@ -62,5 +66,4 @@ function preeval(babel, options) {
         },
     };
 }
-exports.preeval = preeval;
 exports.default = preeval;

package/types/plugins/shaker.d.ts

@@ -1,11 +1,14 @@
 import type { PluginObj } from '@babel/core';
+import type { ImportOverrides } from '@wyw-in-js/shared';
 import type { Core } from '../babel';
 import type { IState } from '../utils/collectExportsAndImports';
 export interface IShakerOptions {
     ifUnknownExport?: 'error' | 'ignore' | 'reexport-all' | 'skip-shaking';
+    importOverrides?: ImportOverrides;
     keepSideEffects?: boolean;
     onlyExports: string[];
+    root?: string;
 }
-export default function shakerPlugin(babel: Core, { keepSideEffects, ifUnknownExport, onlyExports, }: IShakerOptions): PluginObj<IState & {
+export default function shakerPlugin(babel: Core, { keepSideEffects, ifUnknownExport, importOverrides, onlyExports, root, }: IShakerOptions): PluginObj<IState & {
     filename: string;
 }>;

package/types/plugins/shaker.js

@@ -1,20 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = shakerPlugin;
+const path_1 = __importDefault(require("path"));
 const shared_1 = require("@wyw-in-js/shared");
 const collectExportsAndImports_1 = require("../utils/collectExportsAndImports");
 const getFileIdx_1 = require("../utils/getFileIdx");
 const isRemoved_1 = require("../utils/isRemoved");
 const scopeHelpers_1 = require("../utils/scopeHelpers");
 const traversalCache_1 = require("../utils/traversalCache");
-const EXT_REGEX = /\.[0-9a-z]+$/;
-const ALLOWED_EXTENSIONS = ['.js', '.cjs', '.mjs'];
-function shouldKeepSideEffect(importPath) {
-    const [ext] = importPath.match(EXT_REGEX) || [''];
-    return ext === '' || ALLOWED_EXTENSIONS.includes(ext);
+const parseRequest_1 = require("../utils/parseRequest");
+const importOverrides_1 = require("../utils/importOverrides");
+function getNonParamBinding(exportPath, name) {
+    const binding = exportPath.scope.getBinding(name);
+    if (binding && binding.kind !== 'param') {
+        return binding;
+    }
+    // When `exportPath` is inside a function scope, a parameter can shadow
+    // the actual export binding (e.g. `export function fallback(fallback) {}`).
+    // In such cases we need the binding from the declaration scope.
+    return exportPath.scope.parent?.getBinding(name) ?? binding;
 }
 function getBindingForExport(exportPath) {
     if (exportPath.isIdentifier()) {
-        return exportPath.scope.getBinding(exportPath.node.name);
+        return getNonParamBinding(exportPath, exportPath.node.name);
     }
     const variableDeclarator = exportPath.findParent((p) => p.isVariableDeclarator());
     if (variableDeclarator) {
@@ -26,11 +37,11 @@ function getBindingForExport(exportPath) {
     if (exportPath.isAssignmentExpression()) {
         const left = exportPath.get('left');
         if (left.isIdentifier()) {
-            return exportPath.scope.getBinding(left.node.name);
+            return getNonParamBinding(exportPath, left.node.name);
         }
     }
     if (exportPath.isFunctionDeclaration() || exportPath.isClassDeclaration()) {
-        return exportPath.scope.getBinding(exportPath.node.id.name);
+        return getNonParamBinding(exportPath, exportPath.node.id.name);
     }
     return undefined;
 }
@@ -88,7 +99,44 @@ function rearrangeExports({ types: t }, root, exportRefs, exports) {
     });
     return rearranged;
 }
-function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-shaking', onlyExports, }) {
+const getPropertyAssignmentStatement = (ref, bindingName) => {
+    const assignment = ref.findParent((parent) => parent.isAssignmentExpression());
+    if (!assignment?.isAssignmentExpression())
+        return null;
+    const left = assignment.get('left');
+    if (!left.isMemberExpression())
+        return null;
+    const object = left.get('object');
+    if (!object.isIdentifier({ name: bindingName }))
+        return null;
+    const statement = assignment.parentPath;
+    return statement?.isExpressionStatement() ? statement : null;
+};
+const isWithinAliveExport = (ref, aliveExports) => [...aliveExports].some((alive) => alive === ref || alive.isAncestor(ref));
+function stripExportKeepDeclaration(path) {
+    const exportDeclaration = path.findParent((p) => p.isExportNamedDeclaration());
+    if (!exportDeclaration)
+        return false;
+    const declaration = exportDeclaration.get('declaration');
+    if (!declaration.node)
+        return false;
+    if (declaration.isFunctionDeclaration() ||
+        declaration.isClassDeclaration() ||
+        declaration.isTSEnumDeclaration()) {
+        exportDeclaration.replaceWith(declaration.node);
+        return true;
+    }
+    if (declaration.isVariableDeclaration()) {
+        const declarators = declaration.get('declarations');
+        if (declarators.length !== 1) {
+            return false;
+        }
+        exportDeclaration.replaceWith(declaration.node);
+        return true;
+    }
+    return false;
+}
+function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-shaking', importOverrides, onlyExports, root, }) {
     const shakerLogger = shared_1.logger.extend('shaker');
     return {
         name: '@wyw-in-js/transform/shaker',
@@ -97,6 +145,51 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
             const log = shakerLogger.extend((0, getFileIdx_1.getFileIdx)(this.filename));
             log('start', `${this.filename}, onlyExports: ${onlyExports.join(',')}`);
             const onlyExportsSet = new Set(onlyExports);
+            const shouldKeepOverride = (override) => !!override && ('mock' in override || 'noShake' in override);
+            const hasImportOverride = (() => {
+                if (!importOverrides || Object.keys(importOverrides).length === 0) {
+                    return () => false;
+                }
+                const cache = new Map();
+                return (source) => {
+                    const cached = cache.get(source);
+                    if (cached !== undefined) {
+                        return cached;
+                    }
+                    const strippedSource = (0, parseRequest_1.stripQueryAndHash)(source);
+                    const direct = importOverrides[source] ??
+                        (strippedSource !== source
+                            ? importOverrides[strippedSource]
+                            : null);
+                    if (direct) {
+                        const result = shouldKeepOverride(direct);
+                        cache.set(source, result);
+                        return result;
+                    }
+                    const isFileImport = strippedSource.startsWith('.') ||
+                        path_1.default.isAbsolute(strippedSource);
+                    if (!isFileImport) {
+                        cache.set(source, false);
+                        return false;
+                    }
+                    try {
+                        const resolved = (0, shared_1.syncResolve)(strippedSource, this.filename, []);
+                        const { key } = (0, importOverrides_1.toImportKey)({
+                            source: strippedSource,
+                            resolved,
+                            root,
+                        });
+                        const override = importOverrides[key];
+                        const result = shouldKeepOverride(override);
+                        cache.set(source, result);
+                        return result;
+                    }
+                    catch {
+                        cache.set(source, false);
+                        return false;
+                    }
+                };
+            })();
             const collected = (0, collectExportsAndImports_1.collectExportsAndImports)(file.path);
             const sideEffectImports = collected.imports.filter(collectExportsAndImports_1.sideEffectImport);
             log('import-and-exports', [
@@ -157,11 +250,18 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
                 Object.entries(exports).forEach(([exported, local]) => {
                     if (onlyExportsSet.has(exported)) {
                         aliveExports.add(local);
+                        return;
                     }
-                    else if (importNames.includes(local.node.name || '')) {
+                    const binding = local.isIdentifier() && local.scope.getBinding(local.node.name);
+                    if (binding &&
+                        (binding.path.isImportSpecifier() ||
+                            binding.path.isImportDefaultSpecifier() ||
+                            binding.path.isImportNamespaceSpecifier()) &&
+                        importNames.includes(local.node.name || '')) {
                         aliveExports.add(local);
+                        return;
                     }
-                    else if ([...aliveExports].some((alive) => alive === local)) {
+                    if ([...aliveExports].some((alive) => alive === local)) {
                         // It's possible to export multiple values from a single variable initializer, e.g
                         // export const { foo, bar } = baz();
                         // We need to treat all of them as used if any of them are used, since otherwise
@@ -211,18 +311,29 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
                     ...Object.values(exports),
                     ...collected.reexports.map((i) => i.local),
                 ].filter((exp) => !aliveExports.has(exp));
+                const forDeletingSet = new Set(forDeleting);
+                const queueForDeleting = (path) => {
+                    if ((0, isRemoved_1.isRemoved)(path) || forDeletingSet.has(path)) {
+                        return false;
+                    }
+                    forDeletingSet.add(path);
+                    forDeleting.push(path);
+                    return true;
+                };
                 if (!keepSideEffects && !importedAsSideEffect) {
-                    // Remove all imports that don't import something explicitly and should not be kept
+                    // Drop side-effect imports for eval-only builds unless they were explicitly requested.
+                    // This prevents evaluating unrelated runtime code (e.g. Radix) during __wywPreval eval.
                     sideEffectImports.forEach((i) => {
-                        if (!shouldKeepSideEffect(i.source)) {
-                            forDeleting.push(i.local);
+                        if (hasImportOverride(i.source)) {
+                            return;
                         }
+                        queueForDeleting(i.local);
                     });
                 }
                 const deleted = new Set();
                 let dereferenced = [];
                 let changed = true;
-                while (changed && deleted.size < forDeleting.length) {
+                while (changed) {
                     changed = false;
                     // eslint-disable-next-line no-restricted-syntax
                     for (const path of forDeleting) {
@@ -233,14 +344,50 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
                         const binding = getBindingForExport(path);
                         const action = (0, scopeHelpers_1.findActionForNode)(path);
                         const parent = action?.[1];
-                        const outerReferences = (binding?.referencePaths || []).filter((ref) => ref !== parent && !parent?.isAncestor(ref));
-                        if (outerReferences.length > 0 && path.isIdentifier()) {
+                        const outerReferences = (binding?.referencePaths || []).filter((ref) => {
+                            if (ref === parent || parent?.isAncestor(ref)) {
+                                return false;
+                            }
+                            return !forDeleting.some((candidate) => candidate !== path &&
+                                !(0, isRemoved_1.isRemoved)(candidate) &&
+                                (candidate === ref || candidate.isAncestor(ref)));
+                        });
+                        const bindingName = binding?.identifier.name;
+                        const removableAssignmentStatements = new Set();
+                        const removableOuterReferences = outerReferences.filter((ref) => {
+                            if (!bindingName)
+                                return false;
+                            const statement = getPropertyAssignmentStatement(ref, bindingName);
+                            if (!statement || isWithinAliveExport(statement, aliveExports)) {
+                                return false;
+                            }
+                            removableAssignmentStatements.add(statement);
+                            return true;
+                        });
+                        const blockingReferences = outerReferences.filter((ref) => !removableOuterReferences.includes(ref));
+                        if (blockingReferences.length > 0 && path.isIdentifier()) {
                             // Temporary deref it in order to simplify further checks.
                             (0, scopeHelpers_1.dereference)(path);
                             dereferenced.push(path);
                         }
                         if (!deleted.has(path) &&
-                            (!binding || outerReferences.length === 0)) {
+                            binding &&
+                            blockingReferences.length > 0 &&
+                            stripExportKeepDeclaration(path)) {
+                            deleted.add(path);
+                            changed = true;
+                            // eslint-disable-next-line no-continue
+                            continue;
+                        }
+                        if (!deleted.has(path) &&
+                            (!binding || blockingReferences.length === 0)) {
+                            if (removableAssignmentStatements.size > 0) {
+                                for (const statement of removableAssignmentStatements) {
+                                    if (queueForDeleting(statement)) {
+                                        changed = true;
+                                    }
+                                }
+                            }
                             if (action) {
                                 (0, scopeHelpers_1.applyAction)(action);
                             }
@@ -261,11 +408,30 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
                     // Find and mark for deleting all unreferenced variables
                     const unreferenced = Object.values(file.scope.getAllBindings()).filter((i) => !i.referenced);
                     for (const binding of unreferenced) {
-                        if (binding.path.isVariableDeclarator() &&
-                            !forDeleting.includes(binding.path.get('id'))) {
-                            forDeleting.push(...binding.constantViolations);
-                            forDeleting.push(binding.path.get('id'));
-                            changed = true;
+                        if (binding.path.isVariableDeclarator()) {
+                            const id = binding.path.get('id');
+                            if (!(0, isRemoved_1.isRemoved)(id) && !forDeletingSet.has(id)) {
+                                // Drop dead variable declarations, e.g. `const foo = make();` when `foo` is no longer referenced.
+                                for (const violation of binding.constantViolations) {
+                                    if (queueForDeleting(violation)) {
+                                        changed = true;
+                                    }
+                                }
+                                if (queueForDeleting(id)) {
+                                    changed = true;
+                                }
+                            }
+                        }
+                        // Drop import specifiers whose bindings lost all references during shaking
+                        // (e.g. when we keep only __wywPreval and the rest of the module is removed).
+                        if ((binding.path.isImportSpecifier() ||
+                            binding.path.isImportDefaultSpecifier() ||
+                            binding.path.isImportNamespaceSpecifier()) &&
+                            !(0, isRemoved_1.isRemoved)(binding.path) &&
+                            !forDeletingSet.has(binding.path)) {
+                            if (queueForDeleting(binding.path)) {
+                                changed = true;
+                            }
                         }
                     }
                 }
@@ -311,4 +477,3 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
         },
     };
 }
-exports.default = shakerPlugin;

package/types/shaker.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shaker = void 0;
+const shaker_1 = __importDefault(require("./plugins/shaker"));
 const ShakerMetadata_1 = require("./utils/ShakerMetadata");
 const getPluginKey_1 = require("./utils/getPluginKey");
 const hasKeyInList = (plugin, list) => {
@@ -22,7 +26,7 @@ const shaker = (evalConfig, ast, code, { highPriorityPlugins, ...config }, babel
         [];
     const plugins = [
         ...preShakePlugins,
-        [require.resolve('./plugins/shaker'), config],
+        [shaker_1.default, config],
         ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, highPriorityPlugins)),
     ];
     const hasCommonjsPlugin = evalConfig.plugins?.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-modules-commonjs');
@@ -30,7 +34,9 @@ const shaker = (evalConfig, ast, code, { highPriorityPlugins, ...config }, babel
         plugins.push(require.resolve('@babel/plugin-transform-modules-commonjs'));
     }
     if (evalConfig.filename?.endsWith('.ts') ||
-        evalConfig.filename?.endsWith('.tsx')) {
+        evalConfig.filename?.endsWith('.tsx') ||
+        evalConfig.filename?.endsWith('.mts') ||
+        evalConfig.filename?.endsWith('.cts')) {
         const hasTypescriptPlugin = evalConfig.plugins?.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-typescript');
         if (!hasTypescriptPlugin) {
             const preset = safeResolve('@babel/preset-typescript', [
@@ -41,7 +47,7 @@ const shaker = (evalConfig, ast, code, { highPriorityPlugins, ...config }, babel
                 preset,
             ]);
             if (plugin) {
-                plugins.push(plugin);
+                plugins.push([plugin, { allowDeclareFields: true }]);
             }
         }
     }