xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/commonjs/CommonJsFullRequireDependency.d.ts

@@ -0,0 +1,13 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class CommonJsFullRequireDependency extends ModuleDependency {
+    names: any;
+    call: boolean;
+    asiSafe: undefined;
+    constructor(request: string, range: any, names: string[]);
+    getReferencedExports(moduleGraph: any, runtime: any): any[];
+    serialize(context: any): void;
+    deserialize(context: any): void;
+    get type(): string;
+    get category(): string;
+}
+export default CommonJsFullRequireDependency;

package/dist/dependencies/commonjs/CommonJsFullRequireDependency.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Template_1 = require("@/template/Template");
+const ArrayHelpers_1 = require("@/base/ArrayHelpers");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class CommonJsFullRequireDependency extends ModuleDependency_1.default {
+    constructor(request, range, names) {
+        super(request);
+        this.range = range;
+        this.names = names;
+        this.call = false;
+        this.asiSafe = undefined;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        if (this.call) {
+            const importedModule = moduleGraph.getModule(this);
+            if (!importedModule || importedModule.getExportsType(moduleGraph, false) !== 'namespace') {
+                return [this.names.slice(0, -1)];
+            }
+        }
+        return [this.names];
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.names);
+        write(this.call);
+        write(this.asiSafe);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.names = read();
+        this.call = read();
+        this.asiSafe = read();
+        super.deserialize(context);
+    }
+    get type() {
+        return 'cjs full require';
+    }
+    get category() {
+        return 'commonjs';
+    }
+}
+CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemplate extends (ModuleDependency_1.default.Template) {
+    apply(dependency, source, { module, runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements, runtime, initFragments, }) {
+        const dep = dependency;
+        if (!dep.range)
+            return;
+        const importedModule = moduleGraph.getModule(dep);
+        let requireExpr = runtimeTemplate.moduleExports({
+            module: importedModule,
+            chunkGraph,
+            request: dep.request,
+            weak: dep.weak,
+            runtimeRequirements,
+        });
+        if (importedModule) {
+            const ids = dep.names;
+            const usedImported = moduleGraph.getExportsInfo(importedModule).getUsedName(ids, runtime);
+            if (usedImported) {
+                const comment = (0, ArrayHelpers_1.equals)(usedImported, ids)
+                    ? ''
+                    : `${Template_1.Template.toNormalComment((0, propertyAccess_1.default)(ids))} `;
+                const access = `${comment}${(0, propertyAccess_1.default)(usedImported)}`;
+                requireExpr = dep.asiSafe === true ? `(${requireExpr}${access})` : `${requireExpr}${access}`;
+            }
+        }
+        source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
+    }
+};
+(0, makeSerializable_1.default)(CommonJsFullRequireDependency, 'mp-compiler/core/dependencies/CommonJsFullRequireDependency');
+exports.default = CommonJsFullRequireDependency;

package/dist/dependencies/commonjs/CommonJsImportsParserPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class CommonJsImportsParserPlugin {
+    options: any;
+    constructor(options: any);
+    apply(parser: any): void;
+}
+export default CommonJsImportsParserPlugin;

package/dist/dependencies/commonjs/CommonJsImportsParserPlugin.js

@@ -0,0 +1,500 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+const CommentCompilationWarning_1 = __importDefault(require("@/base/errors/CommentCompilationWarning"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const UnsupportedFeatureWarning_1 = __importDefault(require("@/base/errors/UnsupportedFeatureWarning"));
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const BasicEvaluatedExpression_1 = __importDefault(require("@/module/javascript/BasicEvaluatedExpression"));
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const ContextDependencyHelpers = __importStar(require("@/dependencies/context/ContextDependencyHelpers"));
+const LocalModuleDependency_1 = __importDefault(require("@/dependencies/LocalModuleDependency"));
+const LocalModulesHelpers_1 = require("@/dependencies/LocalModulesHelpers");
+const RequireHeaderDependency_1 = __importDefault(require("@/dependencies/RequireHeaderDependency"));
+const RequireResolveContextDependency_1 = __importDefault(require("@/dependencies/RequireResolveContextDependency"));
+const RequireResolveDependency_1 = __importDefault(require("@/dependencies/RequireResolveDependency"));
+const RequireResolveHeaderDependency_1 = __importDefault(require("@/dependencies/RequireResolveHeaderDependency"));
+const CommonJsRequireDependency_1 = __importDefault(require("./CommonJsRequireDependency"));
+const CommonJsRequireContextDependency_1 = __importDefault(require("./CommonJsRequireContextDependency"));
+const CommonJsFullRequireDependency_1 = __importDefault(require("./CommonJsFullRequireDependency"));
+const createRequireSpecifierTag = Symbol('createRequire');
+const createdRequireIdentifierTag = Symbol('createRequire()');
+class CommonJsImportsParserPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(parser) {
+        const options = this.options;
+        const getContext = () => {
+            if (parser.currentTagData) {
+                const { context } = parser.currentTagData;
+                return context;
+            }
+        };
+        const tapRequireExpression = (expression, getMembers) => {
+            parser.hooks.typeof
+                .for(expression)
+                .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('function')));
+            parser.hooks.evaluateTypeof
+                .for(expression)
+                .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.evaluateToString)('function'));
+            parser.hooks.evaluateIdentifier
+                .for(expression)
+                .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.evaluateToIdentifier)(expression, 'require', getMembers, true));
+        };
+        const tapRequireExpressionTag = tag => {
+            parser.hooks.typeof
+                .for(tag)
+                .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('function')));
+            parser.hooks.evaluateTypeof
+                .for(tag)
+                .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.evaluateToString)('function'));
+        };
+        tapRequireExpression('require', () => []);
+        tapRequireExpression('require.resolve', () => ['resolve']);
+        tapRequireExpression('require.resolveWeak', () => ['resolveWeak']);
+        // #endregion
+        // Weird stuff //
+        parser.hooks.assign.for('require').tap('CommonJsImportsParserPlugin', expr => {
+            // to not leak to global "require", we need to define a local require here.
+            const dep = new ConstDependency_1.default('var require;', 0);
+            dep.loc = expr.loc;
+            parser.state.module.addPresentationalDependency(dep);
+            return true;
+        });
+        // #region Unsupported
+        parser.hooks.expression
+            .for('require.main')
+            .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.expressionIsUnsupported)(parser, 'require.main is not supported by webpack.'));
+        parser.hooks.call
+            .for('require.main.require')
+            .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.expressionIsUnsupported)(parser, 'require.main.require is not supported by webpack.'));
+        parser.hooks.expression
+            .for('module.parent.require')
+            .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.expressionIsUnsupported)(parser, 'module.parent.require is not supported by webpack.'));
+        parser.hooks.call
+            .for('module.parent.require')
+            .tap('CommonJsImportsParserPlugin', (0, JavascriptParserHelpers_1.expressionIsUnsupported)(parser, 'module.parent.require is not supported by webpack.'));
+        // #endregion
+        // #region Renaming
+        const defineUndefined = expr => {
+            // To avoid "not defined" error, replace the value with undefined
+            const dep = new ConstDependency_1.default('undefined', expr.range);
+            dep.loc = expr.loc;
+            parser.state.module.addPresentationalDependency(dep);
+            return false;
+        };
+        parser.hooks.canRename.for('require').tap('CommonJsImportsParserPlugin', () => true);
+        parser.hooks.rename.for('require').tap('CommonJsImportsParserPlugin', defineUndefined);
+        // #endregion
+        // #region Inspection
+        const requireCache = (0, JavascriptParserHelpers_1.toConstantDependency)(parser, RuntimeGlobals.moduleCache, [
+            RuntimeGlobals.moduleCache,
+            RuntimeGlobals.moduleId,
+            RuntimeGlobals.moduleLoaded,
+        ]);
+        parser.hooks.expression.for('require.cache').tap('CommonJsImportsParserPlugin', requireCache);
+        // #endregion
+        // #region Require as expression
+        const requireAsExpressionHandler = expr => {
+            const dep = new CommonJsRequireContextDependency_1.default({
+                request: options.unknownContextRequest,
+                recursive: options.unknownContextRecursive,
+                regExp: options.unknownContextRegExp,
+                mode: 'sync',
+            }, expr.range, undefined, parser.scope.inShorthand, getContext());
+            dep.critical =
+                options.unknownContextCritical &&
+                    'require function is used in a way in which dependencies cannot be statically extracted';
+            dep.loc = expr.loc;
+            dep.optional = !!parser.scope.inTry;
+            parser.state.current.addDependency(dep);
+            return true;
+        };
+        parser.hooks.expression
+            .for('require')
+            .tap('CommonJsImportsParserPlugin', requireAsExpressionHandler);
+        // #endregion
+        // #region Require
+        const processRequireItem = (expr, param) => {
+            if (param.isString()) {
+                const dep = new CommonJsRequireDependency_1.default(param.string, param.range, getContext());
+                dep.loc = expr.loc;
+                dep.optional = !!parser.scope.inTry;
+                parser.state.current.addDependency(dep);
+                return true;
+            }
+        };
+        const processRequireContext = (expr, param) => {
+            const dep = ContextDependencyHelpers.create(CommonJsRequireContextDependency_1.default, expr.range, param, expr, options, {
+                category: 'commonjs',
+            }, parser, undefined, getContext());
+            if (!dep)
+                return;
+            dep.loc = expr.loc;
+            dep.optional = !!parser.scope.inTry;
+            parser.state.current.addDependency(dep);
+            return true;
+        };
+        const createRequireHandler = (callNew) => expr => {
+            if (options.commonjsMagicComments) {
+                const { options: requireOptions, errors: commentErrors } = parser.parseCommentOptions(expr.range);
+                if (commentErrors) {
+                    for (const e of commentErrors) {
+                        const { comment } = e;
+                        parser.state.module.addWarning(new CommentCompilationWarning_1.default(`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`, comment.loc));
+                    }
+                }
+                if (requireOptions) {
+                    if (requireOptions.webpackIgnore !== undefined) {
+                        if (typeof requireOptions.webpackIgnore !== 'boolean') {
+                            parser.state.module.addWarning(new UnsupportedFeatureWarning_1.default(`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`, expr.loc));
+                        }
+                        else {
+                            // Do not instrument `require()` if `webpackIgnore` is `true`
+                            // eslint-disable-next-line no-lonely-if
+                            if (requireOptions.webpackIgnore) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            if (expr.arguments.length !== 1)
+                return;
+            let localModule;
+            const param = parser.evaluateExpression(expr.arguments[0]);
+            if (param.isConditional()) {
+                let isExpression = false;
+                for (const p of param.options) {
+                    const result = processRequireItem(expr, p);
+                    if (result === undefined) {
+                        isExpression = true;
+                    }
+                }
+                if (!isExpression) {
+                    const dep = new RequireHeaderDependency_1.default(expr.callee.range);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                }
+            }
+            if (param.isString() && (localModule = (0, LocalModulesHelpers_1.getLocalModule)(parser.state, param.string))) {
+                localModule.flagUsed();
+                const dep = new LocalModuleDependency_1.default(localModule, expr.range, callNew);
+                dep.loc = expr.loc;
+                parser.state.module.addPresentationalDependency(dep);
+                return true;
+            }
+            const result = processRequireItem(expr, param);
+            if (result === undefined) {
+                processRequireContext(expr, param);
+            }
+            else {
+                const dep = new RequireHeaderDependency_1.default(expr.callee.range);
+                dep.loc = expr.loc;
+                parser.state.module.addPresentationalDependency(dep);
+            }
+            return true;
+        };
+        parser.hooks.call.for('require').tap('CommonJsImportsParserPlugin', createRequireHandler(false));
+        parser.hooks.new.for('require').tap('CommonJsImportsParserPlugin', createRequireHandler(true));
+        parser.hooks.call
+            .for('module.require')
+            .tap('CommonJsImportsParserPlugin', createRequireHandler(false));
+        parser.hooks.new
+            .for('module.require')
+            .tap('CommonJsImportsParserPlugin', createRequireHandler(true));
+        // #endregion
+        // #region Require with property access
+        const chainHandler = (expr, calleeMembers, callExpr, members) => {
+            if (callExpr.arguments.length !== 1)
+                return;
+            const param = parser.evaluateExpression(callExpr.arguments[0]);
+            if (param.isString() && !(0, LocalModulesHelpers_1.getLocalModule)(parser.state, param.string)) {
+                const dep = new CommonJsFullRequireDependency_1.default(param.string, expr.range, members);
+                dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+                dep.optional = !!parser.scope.inTry;
+                dep.loc = expr.loc;
+                parser.state.current.addDependency(dep);
+                return true;
+            }
+        };
+        const callChainHandler = (expr, calleeMembers, callExpr, members) => {
+            if (callExpr.arguments.length !== 1)
+                return;
+            const param = parser.evaluateExpression(callExpr.arguments[0]);
+            if (param.isString() && !(0, LocalModulesHelpers_1.getLocalModule)(parser.state, param.string)) {
+                const dep = new CommonJsFullRequireDependency_1.default(param.string, expr.callee.range, members);
+                dep.call = true;
+                dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+                dep.optional = !!parser.scope.inTry;
+                dep.loc = expr.callee.loc;
+                parser.state.current.addDependency(dep);
+                parser.walkExpressions(expr.arguments);
+                return true;
+            }
+        };
+        parser.hooks.memberChainOfCallMemberChain
+            .for('require')
+            .tap('CommonJsImportsParserPlugin', chainHandler);
+        parser.hooks.memberChainOfCallMemberChain
+            .for('module.require')
+            .tap('CommonJsImportsParserPlugin', chainHandler);
+        parser.hooks.callMemberChainOfCallMemberChain
+            .for('require')
+            .tap('CommonJsImportsParserPlugin', callChainHandler);
+        parser.hooks.callMemberChainOfCallMemberChain
+            .for('module.require')
+            .tap('CommonJsImportsParserPlugin', callChainHandler);
+        // #endregion
+        // #region Require.resolve
+        const processResolve = (expr, weak) => {
+            if (expr.arguments.length !== 1)
+                return;
+            const param = parser.evaluateExpression(expr.arguments[0]);
+            if (param.isConditional()) {
+                for (const option of param.options) {
+                    const result = processResolveItem(expr, option, weak);
+                    if (result === undefined) {
+                        processResolveContext(expr, option, weak);
+                    }
+                }
+                const dep = new RequireResolveHeaderDependency_1.default(expr.callee.range);
+                dep.loc = expr.loc;
+                parser.state.module.addPresentationalDependency(dep);
+                return true;
+            }
+            const result = processResolveItem(expr, param, weak);
+            if (result === undefined) {
+                processResolveContext(expr, param, weak);
+            }
+            const dep = new RequireResolveHeaderDependency_1.default(expr.callee.range);
+            dep.loc = expr.loc;
+            parser.state.module.addPresentationalDependency(dep);
+            return true;
+        };
+        const processResolveItem = (expr, param, weak) => {
+            if (param.isString()) {
+                const dep = new RequireResolveDependency_1.default(param.string, param.range, getContext());
+                dep.loc = expr.loc;
+                dep.optional = !!parser.scope.inTry;
+                dep.weak = weak;
+                parser.state.current.addDependency(dep);
+                return true;
+            }
+        };
+        const processResolveContext = (expr, param, weak) => {
+            const dep = ContextDependencyHelpers.create(RequireResolveContextDependency_1.default, param.range, param, expr, options, {
+                category: 'commonjs',
+                mode: weak ? 'weak' : 'sync',
+            }, parser, getContext());
+            if (!dep)
+                return;
+            dep.loc = expr.loc;
+            dep.optional = !!parser.scope.inTry;
+            parser.state.current.addDependency(dep);
+            return true;
+        };
+        parser.hooks.call.for('require.resolve').tap('CommonJsImportsParserPlugin', expr => processResolve(expr, false));
+        parser.hooks.call.for('require.resolveWeak').tap('CommonJsImportsParserPlugin', expr => processResolve(expr, true));
+        // #endregion
+        // #region Create require
+        if (!options.createRequire)
+            return;
+        let moduleName = [];
+        let specifierName;
+        if (options.createRequire === true) {
+            moduleName = ['module', 'node:module'];
+            specifierName = 'createRequire';
+        }
+        else {
+            let moduleName;
+            const match = /^(.*) from (.*)$/.exec(options.createRequire);
+            if (match) {
+                ;
+                [, specifierName, moduleName] = match;
+            }
+            if (!specifierName || !moduleName) {
+                const err = new BaseError_1.default(`Parsing javascript parser option "createRequire" failed, got ${JSON.stringify(options.createRequire)}`);
+                err.details =
+                    'Expected string in format "createRequire from module", where "createRequire" is specifier name and "module" name of the module';
+                throw err;
+            }
+        }
+        tapRequireExpressionTag(createdRequireIdentifierTag);
+        tapRequireExpressionTag(createRequireSpecifierTag);
+        parser.hooks.evaluateCallExpression
+            .for(createRequireSpecifierTag)
+            .tap('CommonJsImportsParserPlugin', expr => {
+            const context = parseCreateRequireArguments(expr);
+            if (context === undefined)
+                return;
+            const ident = parser.evaluatedVariable({
+                tag: createdRequireIdentifierTag,
+                data: { context },
+                next: undefined,
+            });
+            return new BasicEvaluatedExpression_1.default()
+                .setIdentifier(ident, () => [])
+                .setSideEffects(false)
+                .setRange(expr.range);
+        });
+        parser.hooks.unhandledExpressionMemberChain
+            .for(createdRequireIdentifierTag)
+            .tap('CommonJsImportsParserPlugin', (expr, members) => (0, JavascriptParserHelpers_1.expressionIsUnsupported)(parser, `createRequire().${members.join('.')} is not supported by webpack.`)(expr));
+        parser.hooks.canRename
+            .for(createdRequireIdentifierTag)
+            .tap('CommonJsImportsParserPlugin', () => true);
+        parser.hooks.canRename
+            .for(createRequireSpecifierTag)
+            .tap('CommonJsImportsParserPlugin', () => true);
+        parser.hooks.rename
+            .for(createRequireSpecifierTag)
+            .tap('CommonJsImportsParserPlugin', defineUndefined);
+        parser.hooks.expression
+            .for(createdRequireIdentifierTag)
+            .tap('CommonJsImportsParserPlugin', requireAsExpressionHandler);
+        parser.hooks.call
+            .for(createdRequireIdentifierTag)
+            .tap('CommonJsImportsParserPlugin', createRequireHandler(false));
+        const parseCreateRequireArguments = expr => {
+            const args = expr.arguments;
+            if (args.length !== 1) {
+                const err = new BaseError_1.default('module.createRequire supports only one argument.');
+                err.loc = expr.loc;
+                parser.state.module.addWarning(err);
+                return;
+            }
+            const arg = args[0];
+            const evaluated = parser.evaluateExpression(arg);
+            if (!evaluated.isString()) {
+                const err = new BaseError_1.default('module.createRequire failed parsing argument.');
+                err.loc = arg.loc;
+                parser.state.module.addWarning(err);
+                return;
+            }
+            const ctx = evaluated.string.startsWith('file://')
+                ? (0, url_1.fileURLToPath)(evaluated.string)
+                : evaluated.string;
+            // argument always should be a filename
+            return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith('/') ? '/' : '\\'));
+        };
+        parser.hooks.import.tap({
+            name: 'CommonJsImportsParserPlugin',
+            stage: -10,
+        }, (statement, source) => {
+            if (!moduleName.includes(source) ||
+                statement.specifiers.length !== 1 ||
+                statement.specifiers[0].type !== 'ImportSpecifier' ||
+                statement.specifiers[0].imported.type !== 'Identifier' ||
+                statement.specifiers[0].imported.name !== specifierName)
+                return;
+            // clear for 'import { createRequire as x } from "module"'
+            // if any other specifier was used import module
+            const clearDep = new ConstDependency_1.default(parser.isAsiPosition(statement.range[0]) ? ';' : '', statement.range);
+            clearDep.loc = statement.loc;
+            parser.state.module.addPresentationalDependency(clearDep);
+            parser.unsetAsiPosition(statement.range[1]);
+            return true;
+        });
+        parser.hooks.importSpecifier.tap({
+            name: 'CommonJsImportsParserPlugin',
+            stage: -10,
+        }, (statement, source, id, name) => {
+            if (!moduleName.includes(source) || id !== specifierName)
+                return;
+            parser.tagVariable(name, createRequireSpecifierTag);
+            return true;
+        });
+        parser.hooks.preDeclarator.tap('CommonJsImportsParserPlugin', declarator => {
+            if (declarator.id.type !== 'Identifier' ||
+                !declarator.init ||
+                declarator.init.type !== 'CallExpression' ||
+                declarator.init.callee.type !== 'Identifier')
+                return;
+            const variableInfo = parser.getVariableInfo(declarator.init.callee.name);
+            if ((variableInfo === null || variableInfo === void 0 ? void 0 : variableInfo.tagInfo) &&
+                variableInfo.tagInfo.tag === createRequireSpecifierTag) {
+                const context = parseCreateRequireArguments(declarator.init);
+                if (context === undefined)
+                    return;
+                parser.tagVariable(declarator.id.name, createdRequireIdentifierTag, {
+                    name: declarator.id.name,
+                    context,
+                });
+                return true;
+            }
+        });
+        parser.hooks.memberChainOfCallMemberChain
+            .for(createRequireSpecifierTag)
+            .tap('CommonJsImportsParserPlugin', (expr, calleeMembers, callExpr, members) => {
+            if (calleeMembers.length !== 0 || members.length !== 1 || members[0] !== 'cache')
+                return;
+            // createRequire().cache
+            const context = parseCreateRequireArguments(callExpr);
+            if (context === undefined)
+                return;
+            return requireCache(expr);
+        });
+        parser.hooks.callMemberChainOfCallMemberChain
+            .for(createRequireSpecifierTag)
+            .tap('CommonJsImportsParserPlugin', (expr, calleeMembers, innerCallExpression, members) => {
+            if (calleeMembers.length !== 0 || members.length !== 1 || members[0] !== 'resolve')
+                return;
+            // createRequire().resolve()
+            return processResolve(expr, false);
+        });
+        parser.hooks.expressionMemberChain
+            .for(createdRequireIdentifierTag)
+            .tap('CommonJsImportsParserPlugin', (expr, members) => {
+            // require.cache
+            if (members.length === 1 && members[0] === 'cache') {
+                return requireCache(expr);
+            }
+        });
+        parser.hooks.callMemberChain
+            .for(createdRequireIdentifierTag)
+            .tap('CommonJsImportsParserPlugin', (expr, members) => {
+            // require.resolve()
+            if (members.length === 1 && members[0] === 'resolve') {
+                return processResolve(expr, false);
+            }
+        });
+        parser.hooks.call.for(createRequireSpecifierTag).tap('CommonJsImportsParserPlugin', expr => {
+            const clearDep = new ConstDependency_1.default('/* createRequire() */ undefined', expr.range);
+            clearDep.loc = expr.loc;
+            parser.state.module.addPresentationalDependency(clearDep);
+            return true;
+        });
+        // #endregion
+    }
+}
+exports.default = CommonJsImportsParserPlugin;

package/dist/dependencies/commonjs/CommonJsPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class CommonJsPlugin {
+    apply(compiler: any): void;
+}
+export default CommonJsPlugin;