@wyw-in-js/transform 0.8.0 → 1.0.0

package/types/utils/collectExportsAndImports.js

@@ -2,13 +2,15 @@
 /* eslint @typescript-eslint/no-use-before-define: ["error", { "functions": false }] */
 /* eslint-disable no-restricted-syntax,no-continue */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectExportsAndImports = exports.explicitImport = exports.sideEffectImport = void 0;
+exports.explicitImport = exports.sideEffectImport = void 0;
+exports.collectExportsAndImports = collectExportsAndImports;
 const shared_1 = require("@wyw-in-js/shared");
 const getScope_1 = require("./getScope");
 const isExports_1 = require("./isExports");
 const isNotNull_1 = require("./isNotNull");
 const isRequire_1 = require("./isRequire");
 const isTypedNode_1 = require("./isTypedNode");
+const getConstantStringValue_1 = require("./getConstantStringValue");
 const traversalCache_1 = require("./traversalCache");
 const sideEffectImport = (item) => item.imported === 'side-effect';
 exports.sideEffectImport = sideEffectImport;
@@ -173,6 +175,25 @@ function exportFromVariableDeclarator(path) {
             [destructed.as.node.name]: init,
         }), {});
     }
+    if (id.isArrayPattern()) {
+        // It is `export const [a, , b, ...rest] = arr;`
+        const exported = new Set();
+        id.traverse({
+            Identifier(identifier) {
+                if (identifier.isBindingIdentifier()) {
+                    exported.add(identifier.node.name);
+                }
+            },
+        });
+        if (exported.size === 0) {
+            return {};
+        }
+        const result = {};
+        exported.forEach((name) => {
+            result[name] = init;
+        });
+        return result;
+    }
     // What else it can be?
     debug('exportFromVariableDeclarator: unknown type of id %o', id.node.type);
     return {};
@@ -184,11 +205,14 @@ function collectFromDynamicImport(path, state) {
         return;
     }
     const [sourcePath] = callExpression.get('arguments');
-    if (!sourcePath || !sourcePath.isStringLiteral()) {
-        // Import should have at least one argument, and it should be StringLiteral
+    if (!sourcePath || !sourcePath.isExpression()) {
+        // Import should have at least one argument
+        return;
+    }
+    const source = (0, getConstantStringValue_1.getConstantStringValue)(sourcePath.node);
+    if (source === null) {
         return;
     }
-    const source = sourcePath.node.value;
     let { parentPath: container, key } = callExpression;
     let isAwaited = false;
     if (container.isAwaitExpression()) {
@@ -245,28 +269,28 @@ function getImportExportTypeByInteropFunction(path, argPath) {
         return 're-export:*';
     }
     if (matchCall(path, [
-        ['_interopRequireDefault', argPath],
-        ['_interop_require_default', argPath],
+        ['_interopRequireDefault', argPath], // babel and swc <1.3.50
+        ['_interop_require_default', argPath], // swc >=1.3.50
         ['__importDefault', argPath], // ?
     ])) {
         return 'default';
     }
     if (matchCall(path, [
-        ['_interopRequireWildcard', argPath],
-        ['_interop_require_wildcard', argPath],
-        ['__importStar', argPath],
-        ['__toESM', argPath],
+        ['_interopRequireWildcard', argPath], // babel and swc <1.3.50
+        ['_interop_require_wildcard', argPath], // swc >=1.3.50
+        ['__importStar', argPath], // ?
+        ['__toESM', argPath], // esbuild >=0.14.7
         ['__toModule', argPath], // esbuild <0.14.7
     ])) {
         return 'import:*';
     }
     if (matchCall(path, [
-        ['_extends', isEmptyObject, argPath],
-        ['__rest', argPath, isArrayExpression],
-        ['__objRest', argPath, isArrayExpression],
-        ['_objectWithoutProperties', argPath, isArrayExpression],
-        ['_object_without_properties', argPath, isArrayExpression],
-        ['_objectDestructuringEmpty', argPath],
+        ['_extends', isEmptyObject, argPath], // babel and swc
+        ['__rest', argPath, isArrayExpression], // tsc and esbuild <=0.11.3
+        ['__objRest', argPath, isArrayExpression], // esbuild >0.11.3
+        ['_objectWithoutProperties', argPath, isArrayExpression], // babel and swc <1.3.50
+        ['_object_without_properties', argPath, isArrayExpression], // swc >=1.3.50
+        ['_objectDestructuringEmpty', argPath], // swc <1.3.50
         ['_object_destructuring_empty', argPath], // swc >=1.3.50
     ])) {
         return 'import:*';
@@ -317,11 +341,14 @@ function collectFromRequire(path, state) {
         return;
     }
     const [sourcePath] = callExpression.get('arguments');
-    if (!sourcePath || !sourcePath.isStringLiteral()) {
-        // Import should have at least one argument, and it should be StringLiteral
+    if (!sourcePath || !sourcePath.isExpression()) {
+        // Import should have at least one argument
+        return;
+    }
+    const source = (0, getConstantStringValue_1.getConstantStringValue)(sourcePath.node);
+    if (source === null) {
         return;
     }
-    const source = sourcePath.node.value;
     const { parentPath: container, key } = callExpression;
     if (container.isCallExpression()) {
         // It may be transpiled import such as
@@ -442,6 +469,59 @@ function collectFromRequire(path, state) {
         });
     }
 }
+function collectFromWywDynamicImport(path, state) {
+    if (!path.isIdentifier({ name: '__wyw_dynamic_import' })) {
+        return;
+    }
+    const { parentPath: callExpression } = path;
+    if (!callExpression.isCallExpression()) {
+        return;
+    }
+    const [sourcePath] = callExpression.get('arguments');
+    if (!sourcePath || !sourcePath.isExpression()) {
+        return;
+    }
+    const source = (0, getConstantStringValue_1.getConstantStringValue)(sourcePath.node);
+    if (source === null) {
+        return;
+    }
+    let { parentPath: container, key } = callExpression;
+    let isAwaited = false;
+    if (container.isAwaitExpression()) {
+        // If it's not awaited import, it imports the full namespace
+        isAwaited = true;
+        key = container.key;
+        container = container.parentPath;
+    }
+    // Is it `const something = await __wyw_dynamic_import("something")`?
+    if (key === 'init' && container.isVariableDeclarator()) {
+        importFromVariableDeclarator(container, isAwaited).forEach((prop) => {
+            if (prop.what === '*') {
+                const unfolded = unfoldNamespaceImport({
+                    imported: '*',
+                    local: prop.as,
+                    source,
+                    type: 'dynamic',
+                });
+                state.imports.push(...unfolded);
+                return;
+            }
+            state.imports.push({
+                imported: prop.what,
+                local: prop.as,
+                source,
+                type: 'dynamic',
+            });
+        });
+        return;
+    }
+    state.imports.push({
+        imported: '*',
+        local: path,
+        source,
+        type: 'dynamic',
+    });
+}
 function collectFromVariableDeclarator(path, state) {
     let found = false;
     path.traverse({
@@ -635,6 +715,9 @@ function collectFromRequireOrExports(path, state) {
     if ((0, isRequire_1.isRequire)(path)) {
         collectFromRequire(path, state);
     }
+    else if (path.isIdentifier({ name: '__wyw_dynamic_import' })) {
+        collectFromWywDynamicImport(path, state);
+    }
     else if ((0, isExports_1.isExports)(path)) {
         collectFromExports(path, state);
     }
@@ -1062,4 +1145,3 @@ function collectExportsAndImports(path, cacheMode = 'enabled') {
     cache?.set(path, state);
     return state;
 }
-exports.collectExportsAndImports = collectExportsAndImports;

package/types/utils/collectTemplateDependencies.js

@@ -1,7 +1,8 @@
 "use strict";
 /* eslint @typescript-eslint/no-use-before-define: ["error", { "functions": false }] */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectTemplateDependencies = exports.extractExpression = void 0;
+exports.extractExpression = extractExpression;
+exports.collectTemplateDependencies = collectTemplateDependencies;
 /**
  * This file is a visitor that checks TaggedTemplateExpressions and look for WYW template literals.
  * For each template it makes a list of dependencies, try to evaluate expressions, and if it is not possible, mark them as lazy dependencies.
@@ -23,7 +24,7 @@ function staticEval(ex, evaluate = false) {
     }
     return undefined;
 }
-const expressionDeclarationTpl = (0, template_1.statement)('const %%expId%% = /*#__PURE__*/ () => %%expression%%', {
+const expressionDeclarationTpl = (0, template_1.statement)('const %%expId%% = () => %%expression%%', {
     preserveComments: true,
 });
 const unsupported = (ex, reason) => ex.buildCodeFrameError(`This ${ex.isIdentifier() ? 'identifier' : 'expression'} cannot be used in the template${reason ? `, because it ${reason}` : ''}.`);
@@ -183,7 +184,6 @@ function extractExpression(ex, evaluate = false, imports = []) {
     };
     return result;
 }
-exports.extractExpression = extractExpression;
 const debug = shared_1.logger.extend('template-parse:identify-expressions');
 /**
  * Collects, hoists, and makes lazy all expressions in the given template
@@ -209,4 +209,3 @@ function collectTemplateDependencies(path, evaluate = false) {
     });
     return [quasis.map((p) => p.node), expressionValues];
 }
-exports.collectTemplateDependencies = collectTemplateDependencies;

package/types/utils/findIdentifiers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIdentifiers = exports.nonType = void 0;
+exports.nonType = nonType;
+exports.findIdentifiers = findIdentifiers;
 const getScope_1 = require("./getScope");
 function isInUnary(path) {
     return path.parentPath?.isUnaryExpression() ?? false;
@@ -30,7 +31,6 @@ function nonType(path) {
         p.isFlowDeclaration() ||
         p.isTSInterfaceDeclaration());
 }
-exports.nonType = nonType;
 function findIdentifiers(expressions, type = 'reference') {
     const identifiers = [];
     expressions.forEach((ex) => {
@@ -65,4 +65,3 @@ function findIdentifiers(expressions, type = 'reference') {
     });
     return identifiers;
 }
-exports.findIdentifiers = findIdentifiers;

package/types/utils/getConstantStringValue.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from '@babel/types';
+export declare function getConstantStringValue(node: Expression): string | null;

package/types/utils/getConstantStringValue.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConstantStringValue = getConstantStringValue;
+const t = __importStar(require("@babel/types"));
+const getMemberExpressionPropertyName_1 = require("./getMemberExpressionPropertyName");
+const unwrapExpression_1 = require("./unwrapExpression");
+function getConstantStringValue(node) {
+    const fromExpression = (value) => {
+        const expression = (0, unwrapExpression_1.unwrapExpression)(value);
+        if (t.isStringLiteral(expression)) {
+            return expression.value;
+        }
+        if (t.isTemplateLiteral(expression)) {
+            if (expression.expressions.length !== 0) {
+                return null;
+            }
+            const [quasi] = expression.quasis;
+            return quasi?.value.cooked ?? null;
+        }
+        if (t.isBinaryExpression(expression) && expression.operator === '+') {
+            if (!t.isExpression(expression.left) || !t.isExpression(expression.right))
+                return null;
+            const left = fromExpression(expression.left);
+            const right = fromExpression(expression.right);
+            if (left === null || right === null) {
+                return null;
+            }
+            return left + right;
+        }
+        if (t.isCallExpression(expression)) {
+            const concatProperty = t.isMemberExpression(expression.callee)
+                ? (0, getMemberExpressionPropertyName_1.getMemberExpressionPropertyName)(expression.callee)
+                : null;
+            if (concatProperty !== 'concat') {
+                return null;
+            }
+            const { callee } = expression;
+            if (!t.isMemberExpression(callee) || !t.isExpression(callee.object)) {
+                return null;
+            }
+            const base = fromExpression(callee.object);
+            if (base === null) {
+                return null;
+            }
+            const parts = [base];
+            for (const arg of expression.arguments) {
+                if (!t.isExpression(arg)) {
+                    return null;
+                }
+                const part = fromExpression(arg);
+                if (part === null) {
+                    return null;
+                }
+                parts.push(part);
+            }
+            return parts.join('');
+        }
+        return null;
+    };
+    return fromExpression(node);
+}

package/types/utils/getFileIdx.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileIdx = void 0;
+exports.getFileIdx = getFileIdx;
 let nextIdx = 1;
 const processed = new Map();
 function getFileIdx(name) {
@@ -10,4 +10,3 @@ function getFileIdx(name) {
     }
     return processed.get(name).toString().padStart(5, '0');
 }
-exports.getFileIdx = getFileIdx;

package/types/utils/getMemberExpressionPropertyName.d.ts

@@ -0,0 +1,2 @@
+import type { MemberExpression } from '@babel/types';
+export declare function getMemberExpressionPropertyName(node: MemberExpression): string | null;

package/types/utils/getMemberExpressionPropertyName.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemberExpressionPropertyName = getMemberExpressionPropertyName;
+const t = __importStar(require("@babel/types"));
+function getMemberExpressionPropertyName(node) {
+    if (!node.computed && t.isIdentifier(node.property)) {
+        return node.property.name;
+    }
+    if (node.computed && t.isStringLiteral(node.property)) {
+        return node.property.value;
+    }
+    return null;
+}

package/types/utils/getScope.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScope = void 0;
+exports.getScope = getScope;
 function getScope(path) {
     // In some nodes (like FunctionDeclaration) `scope` for `id` returns
     // local function scope instead of a scope where function is declared.
@@ -8,4 +8,3 @@ function getScope(path) {
         ? path.scope.parent
         : path.scope;
 }
-exports.getScope = getScope;

package/types/utils/getTagProcessor.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyProcessors = exports.getDefinedProcessors = exports.getProcessorForImport = void 0;
+exports.getProcessorForImport = getProcessorForImport;
+exports.getDefinedProcessors = getDefinedProcessors;
+exports.applyProcessors = applyProcessors;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const core_1 = require("@babel/core");
@@ -32,6 +34,25 @@ function buildCodeFrameError(path, message) {
     }
 }
 const definedTagsCache = new Map();
+const resolvedTagResolverSourceCache = new Map();
+const getResolvedTagResolverSource = (source, sourceFile) => {
+    if (!sourceFile) {
+        return undefined;
+    }
+    const key = `${sourceFile}\0${source}`;
+    if (resolvedTagResolverSourceCache.has(key)) {
+        return resolvedTagResolverSourceCache.get(key);
+    }
+    try {
+        const resolved = (0, shared_1.syncResolve)(source, sourceFile, []);
+        resolvedTagResolverSourceCache.set(key, resolved);
+        return resolved;
+    }
+    catch {
+        resolvedTagResolverSourceCache.set(key, undefined);
+        return undefined;
+    }
+};
 const getDefinedTagsFromPackage = (pkgName, filename) => {
     if (definedTagsCache.has(pkgName)) {
         return definedTagsCache.get(pkgName);
@@ -77,14 +98,20 @@ function getProcessorFromFile(processorPath) {
     return Processor;
 }
 function getProcessorForImport({ imported, source }, filename, options) {
-    const tagResolver = options.tagResolver ?? (() => null);
-    const customFile = tagResolver(source, imported);
+    const { tagResolver } = options;
+    let customFile = null;
+    if (tagResolver) {
+        const tagResolverMeta = {
+            sourceFile: filename,
+            resolvedSource: getResolvedTagResolverSource(source, filename),
+        };
+        customFile = tagResolver(source, imported, tagResolverMeta);
+    }
     const processor = customFile
         ? getProcessorFromFile(customFile)
         : getProcessorFromPackage(source, imported, filename);
     return [processor, { imported, source }];
 }
-exports.getProcessorForImport = getProcessorForImport;
 function getBuilderForIdentifier(definedProcessor, path, imports, options) {
     const [Processor, tagSource] = definedProcessor;
     let tagPath = path;
@@ -156,8 +183,9 @@ function getBuilderForIdentifier(definedProcessor, path, imports, options) {
     }
     const replacer = (replacement, isPure) => {
         (0, scopeHelpers_1.mutate)(prev, (p) => {
-            p.replaceWith(typeof replacement === 'function' ? replacement(p) : replacement);
-            if (isPure) {
+            const next = typeof replacement === 'function' ? replacement(p) : replacement;
+            p.replaceWith(next);
+            if (isPure && (p.isCallExpression() || p.isNewExpression())) {
                 p.addComment('leading', '#__PURE__');
             }
         });
@@ -240,7 +268,7 @@ function isTagReferenced(path) {
             const id = parent.get('id');
             // FIXME: replace with id.isReferencedIdentifier()
             if (id.isIdentifier()) {
-                const { referencePaths } = path.scope.getBinding(id.node.name) || {
+                const { referencePaths } = id.scope.getBinding(id.node.name) || {
                     referencePaths: [],
                 };
                 isReferenced = referencePaths.length !== 0;
@@ -285,7 +313,6 @@ function getDefinedProcessors(imports, path, filename, options) {
     }
     return cache.get(path);
 }
-exports.getDefinedProcessors = getDefinedProcessors;
 function createProcessorInstance(definedProcessor, imports, path, fileContext, options) {
     const cache = (0, traversalCache_1.getTraversalCache)(path, 'createProcessorInstance');
     if (!cache.has(path.node)) {
@@ -367,4 +394,3 @@ function applyProcessors(path, fileContext, options, callback) {
         callback(instance);
     });
 }
-exports.applyProcessors = applyProcessors;

package/types/utils/getVisitorKeys.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVisitorKeys = void 0;
+exports.getVisitorKeys = getVisitorKeys;
 const core_1 = require("@babel/core");
 function getVisitorKeys(node) {
     return core_1.types.VISITOR_KEYS[node.type];
 }
-exports.getVisitorKeys = getVisitorKeys;

package/types/utils/hasWywPreval.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = hasWywPreval;
 function hasWywPreval(exports) {
     if (!exports || typeof exports !== 'object') {
         return false;
     }
     return '__wywPreval' in exports;
 }
-exports.default = hasWywPreval;

package/types/utils/importOverrides.d.ts

@@ -0,0 +1,19 @@
+import { type ImportOverride } from '@wyw-in-js/shared';
+export type ImportKeyKind = 'file' | 'package';
+export type ImportKey = {
+    key: string;
+    kind: ImportKeyKind;
+};
+export declare function toCanonicalFileKey(resolved: string, root: string | undefined): string;
+export declare function toImportKey({ source, resolved, root, }: {
+    resolved: string | null;
+    root: string | undefined;
+    source: string;
+}): ImportKey;
+export declare function resolveMockSpecifier({ importer, mock, root, stack, }: {
+    importer: string;
+    mock: string;
+    root: string | undefined;
+    stack: string[];
+}): string;
+export declare function applyImportOverrideToOnly(only: string[], override: ImportOverride | undefined): string[];

package/types/utils/importOverrides.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCanonicalFileKey = toCanonicalFileKey;
+exports.toImportKey = toImportKey;
+exports.resolveMockSpecifier = resolveMockSpecifier;
+exports.applyImportOverrideToOnly = applyImportOverrideToOnly;
+const path_1 = __importDefault(require("path"));
+const shared_1 = require("@wyw-in-js/shared");
+function toCanonicalFileKey(resolved, root) {
+    const rootDir = root ? path_1.default.resolve(root) : process.cwd();
+    const normalizedResolved = path_1.default.resolve(resolved);
+    let relative = path_1.default.relative(rootDir, normalizedResolved);
+    if (path_1.default.sep !== path_1.default.posix.sep) {
+        relative = relative.split(path_1.default.sep).join(path_1.default.posix.sep);
+    }
+    if (!relative.startsWith('.')) {
+        relative = `./${relative}`;
+    }
+    return relative;
+}
+function toImportKey({ source, resolved, root, }) {
+    const isFileImport = source.startsWith('.') || path_1.default.isAbsolute(source);
+    if (isFileImport && resolved) {
+        return { key: toCanonicalFileKey(resolved, root), kind: 'file' };
+    }
+    return { key: source, kind: 'package' };
+}
+function resolveMockSpecifier({ importer, mock, root, stack, }) {
+    const specifier = mock.startsWith('.') && root ? path_1.default.resolve(root, mock) : mock;
+    return (0, shared_1.syncResolve)(specifier, importer, stack);
+}
+function applyImportOverrideToOnly(only, override) {
+    if (override?.noShake) {
+        return ['*'];
+    }
+    return only;
+}

package/types/utils/isExports.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExports = void 0;
+exports.isExports = isExports;
 const isGlobal_1 = require("./isGlobal");
 /**
  * Checks that specified Identifier is a global `exports` or `module.exports`
@@ -17,4 +17,3 @@ function isExports(node) {
     }
     return false;
 }
-exports.isExports = isExports;

package/types/utils/isNodePath.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNodePath = void 0;
+exports.isNodePath = isNodePath;
 function isNodePath(obj) {
     return 'node' in obj && obj?.node !== undefined;
 }
-exports.isNodePath = isNodePath;

package/types/utils/isNotNull.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotNull = void 0;
+exports.isNotNull = isNotNull;
 function isNotNull(x) {
     return x !== null;
 }
-exports.isNotNull = isNotNull;

package/types/utils/isRemoved.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRemoved = void 0;
+exports.isRemoved = isRemoved;
 /**
  * Checks if a given path has been removed from the AST.
  */
@@ -39,4 +39,3 @@ function isRemoved(path) {
     // If the function has not returned true by this point, return false
     return false;
 }
-exports.isRemoved = isRemoved;

package/types/utils/isRequire.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRequire = void 0;
+exports.isRequire = isRequire;
 const isGlobal_1 = require("./isGlobal");
 /**
  * Checks that specified Identifier is a global `require`
@@ -12,4 +12,3 @@ function isRequire(id) {
     }
     return (0, isGlobal_1.isGlobal)(id, 'require');
 }
-exports.isRequire = isRequire;