xhs-mp-pack 1.1.0-beta.0

package/dist/module/ExportsInfoApiPlugin.d.ts

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

package/dist/module/ExportsInfoApiPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const ExportsInfoDependency_1 = __importDefault(require("../dependencies/ExportsInfoDependency"));
+const PLUGIN_NAME = 'ExportsInfoApiPlugin';
+class ExportsInfoApiPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            compilation.dependencyTemplates.set(ExportsInfoDependency_1.default, new ExportsInfoDependency_1.default.Template());
+            const handler = parser => {
+                parser.hooks.expressionMemberChain
+                    .for('__webpack_exports_info__')
+                    .tap(PLUGIN_NAME, (expr, members) => {
+                    const dep = members.length >= 2
+                        ? new ExportsInfoDependency_1.default(expr.range, members.slice(0, -1), members[members.length - 1])
+                        : new ExportsInfoDependency_1.default(expr.range, null, members[0]);
+                    dep.loc = expr.loc;
+                    parser.state.module.addDependency(dep);
+                    return true;
+                });
+                parser.hooks.expression.for('__webpack_exports_info__').tap(PLUGIN_NAME, expr => {
+                    const dep = new ConstDependency_1.default('true', expr.range);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+exports.default = ExportsInfoApiPlugin;

package/dist/module/ExternalModule.d.ts

@@ -0,0 +1,47 @@
+import Module from './Module';
+declare class ExternalModule extends Module {
+    externalType: string;
+    request: string | string[] | Record<string, string | string[]>;
+    userRequest: any;
+    constructor(request: string | string[] | Record<string, string | string[]>, type: any, userRequest: any);
+    getSourceTypes(): Set<string>;
+    libIdent(options: any): any;
+    chunkCondition(chunk: any, { chunkGraph }: {
+        chunkGraph: any;
+    }): boolean;
+    identifier(): string;
+    readableIdentifier(requestShortener: any): string;
+    needBuild(context: any, callback: any): any;
+    build(options: any, compilation: any, resolver: any, fs: any, callback: any): void;
+    restoreFromUnsafeCache(unsafeCacheData: any, normalModuleFactory: any): void;
+    getConcatenationBailoutReason({ moduleGraph }: {
+        moduleGraph: any;
+    }): string;
+    _getRequestAndExternalType(): {
+        request: string | string[];
+        externalType: string;
+    };
+    _getSourceData(request: any, externalType: any, runtimeTemplate: any, moduleGraph: any, chunkGraph: any, runtime: any): {
+        expression: string;
+    };
+    codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph, runtime, concatenationScope }: {
+        runtimeTemplate: any;
+        moduleGraph: any;
+        chunkGraph: any;
+        runtime: any;
+        concatenationScope: any;
+    }): {
+        sources: Map<any, any>;
+        runtimeRequirements: Set<never>;
+        data?: undefined;
+    } | {
+        sources: Map<any, any>;
+        runtimeRequirements: any;
+        data: any;
+    };
+    size(type: any): number;
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ExternalModule;

package/dist/module/ExternalModule.js

@@ -0,0 +1,458 @@
+"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 webpack_sources_1 = require("webpack-sources");
+const ConcatenationScope_1 = __importDefault(require("@/ConcatenationScope"));
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const StaticExportsDependency_1 = __importDefault(require("@/dependencies/StaticExportsDependency"));
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const extractUrlAndGlobal_1 = __importDefault(require("@/base/extractUrlAndGlobal"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const Serialization_1 = __importDefault(require("@/serialization/Serialization"));
+const ModuleTypeConstants_1 = require("./ModuleTypeConstants");
+const Module_1 = __importDefault(require("./Module"));
+const TYPES = new Set(['javascript']);
+const CSS_TYPES = new Set(['css-import']);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
+const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([RuntimeGlobals.definePropertyGetters]);
+const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
+const getSourceForGlobalVariableExternal = (variableName, type) => {
+    if (!Array.isArray(variableName)) {
+        // make it an array as the look up works the same basically
+        variableName = [variableName];
+    }
+    // needed for e.g. window["some"]["thing"]
+    const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join('');
+    return {
+        iife: type === 'this',
+        expression: `${type}${objectLookup}`,
+    };
+};
+const getSourceForCommonJsExternal = moduleAndSpecifiers => {
+    if (!Array.isArray(moduleAndSpecifiers)) {
+        return {
+            expression: `require(${JSON.stringify(moduleAndSpecifiers)})`,
+        };
+    }
+    const moduleName = moduleAndSpecifiers[0];
+    return {
+        expression: `require(${JSON.stringify(moduleName)})${(0, propertyAccess_1.default)(moduleAndSpecifiers, 1)}`,
+    };
+};
+const getSourceForCommonJsExternalInNodeModule = (moduleAndSpecifiers, importMetaName) => {
+    const chunkInitFragments = [
+        new InitFragment_1.default('import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n', InitFragment_1.default.STAGE_HARMONY_IMPORTS, 0, 'external module node-commonjs'),
+    ];
+    if (!Array.isArray(moduleAndSpecifiers)) {
+        return {
+            chunkInitFragments,
+            expression: `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)(${JSON.stringify(moduleAndSpecifiers)})`,
+        };
+    }
+    const moduleName = moduleAndSpecifiers[0];
+    return {
+        chunkInitFragments,
+        expression: `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)(${JSON.stringify(moduleName)})${(0, propertyAccess_1.default)(moduleAndSpecifiers, 1)}`,
+    };
+};
+const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
+    const importName = runtimeTemplate.outputOptions.importFunctionName;
+    if (!runtimeTemplate.supportsDynamicImport() && importName === 'import') {
+        throw new Error("The target environment doesn't support 'import()' so it's not possible to use external type 'import'");
+    }
+    if (!Array.isArray(moduleAndSpecifiers)) {
+        return {
+            expression: `${importName}(${JSON.stringify(moduleAndSpecifiers)});`,
+        };
+    }
+    if (moduleAndSpecifiers.length === 1) {
+        return {
+            expression: `${importName}(${JSON.stringify(moduleAndSpecifiers[0])});`,
+        };
+    }
+    const moduleName = moduleAndSpecifiers[0];
+    return {
+        expression: `${importName}(${JSON.stringify(moduleName)}).then(${runtimeTemplate.returningFunction(`module${(0, propertyAccess_1.default)(moduleAndSpecifiers, 1)}`, 'module')});`,
+    };
+};
+class ModuleExternalInitFragment extends InitFragment_1.default {
+    constructor(request, ident, hashFunction = 'md4') {
+        if (ident === undefined) {
+            ident = Template_1.Template.toIdentifier(request);
+            if (ident !== request) {
+                ident += `_${(0, createHash_1.default)(hashFunction).update(request).digest('hex').slice(0, 8)}`;
+            }
+        }
+        const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
+        super(`import * as ${identifier} from ${JSON.stringify(request)};\n`, InitFragment_1.default.STAGE_HARMONY_IMPORTS, 0, `external module import ${ident}`);
+        this._ident = ident;
+        this._identifier = identifier;
+        this._request = request;
+    }
+    getNamespaceIdentifier() {
+        return this._identifier;
+    }
+}
+Serialization_1.default.register(ModuleExternalInitFragment, 'mp-compiler/core/module/ExternalModule', 'ModuleExternalInitFragment', {
+    serialize(obj, { write }) {
+        write(obj._request);
+        write(obj._ident);
+    },
+    deserialize({ read }) {
+        return new ModuleExternalInitFragment(read(), read());
+    },
+});
+const generateModuleRemapping = (input, exportsInfo, runtime) => {
+    if (exportsInfo.otherExportsInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused) {
+        const properties = [];
+        for (const exportInfo of exportsInfo.orderedExports) {
+            const used = exportInfo.getUsedName(exportInfo.name, runtime);
+            if (!used)
+                continue;
+            const nestedInfo = exportInfo.getNestedExportsInfo();
+            if (nestedInfo) {
+                const nestedExpr = generateModuleRemapping(`${input}${(0, propertyAccess_1.default)([exportInfo.name])}`, nestedInfo);
+                if (nestedExpr) {
+                    properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
+                    continue;
+                }
+            }
+            properties.push(`[${JSON.stringify(used)}]: () => ${input}${(0, propertyAccess_1.default)([exportInfo.name])}`);
+        }
+        return `x({ ${properties.join(', ')} })`;
+    }
+};
+const getSourceForModuleExternal = (moduleAndSpecifiers, exportsInfo, runtime, hashFunction) => {
+    if (!Array.isArray(moduleAndSpecifiers))
+        moduleAndSpecifiers = [moduleAndSpecifiers];
+    const initFragment = new ModuleExternalInitFragment(moduleAndSpecifiers[0], undefined, hashFunction);
+    const baseAccess = `${initFragment.getNamespaceIdentifier()}${(0, propertyAccess_1.default)(moduleAndSpecifiers, 1)}`;
+    const moduleRemapping = generateModuleRemapping(baseAccess, exportsInfo, runtime);
+    const expression = moduleRemapping || baseAccess;
+    return {
+        expression,
+        init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
+        runtimeRequirements: moduleRemapping ? RUNTIME_REQUIREMENTS_FOR_MODULE : undefined,
+        chunkInitFragments: [initFragment],
+    };
+};
+const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
+    if (typeof urlAndGlobal === 'string') {
+        urlAndGlobal = (0, extractUrlAndGlobal_1.default)(urlAndGlobal);
+    }
+    const url = urlAndGlobal[0];
+    const globalName = urlAndGlobal[1];
+    return {
+        init: 'var __webpack_error__ = new Error();',
+        expression: `new Promise(${runtimeTemplate.basicFunction('resolve, reject', [
+            `if(typeof ${globalName} !== "undefined") return resolve();`,
+            `${RuntimeGlobals.loadScript}(${JSON.stringify(url)}, ${runtimeTemplate.basicFunction('event', [
+                `if(typeof ${globalName} !== "undefined") return resolve();`,
+                "var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+                'var realSrc = event && event.target && event.target.src;',
+                "__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
+                "__webpack_error__.name = 'ScriptExternalLoadError';",
+                '__webpack_error__.type = errorType;',
+                '__webpack_error__.request = realSrc;',
+                'reject(__webpack_error__);',
+            ])}, ${JSON.stringify(globalName)});`,
+        ])}).then(${runtimeTemplate.returningFunction(`${globalName}${(0, propertyAccess_1.default)(urlAndGlobal, 2)}`)})`,
+        runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT,
+    };
+};
+const checkExternalVariable = (variableName, request, runtimeTemplate) => `if(typeof ${variableName} === 'undefined') { ${runtimeTemplate.throwMissingModuleErrorBlock({ request })} }\n`;
+const getSourceForAmdOrUmdExternal = (id, optional, request, runtimeTemplate) => {
+    const externalVariable = `__WEBPACK_EXTERNAL_MODULE_${Template_1.Template.toIdentifier(`${id}`)}__`;
+    return {
+        init: optional
+            ? checkExternalVariable(externalVariable, Array.isArray(request) ? request.join('.') : request, runtimeTemplate)
+            : undefined,
+        expression: externalVariable,
+    };
+};
+const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
+    if (!Array.isArray(request)) {
+        // make it an array as the look up works the same basically
+        request = [request];
+    }
+    const variableName = request[0];
+    const objectLookup = (0, propertyAccess_1.default)(request, 1);
+    return {
+        init: optional
+            ? checkExternalVariable(variableName, request.join('.'), runtimeTemplate)
+            : undefined,
+        expression: `${variableName}${objectLookup}`,
+    };
+};
+class ExternalModule extends Module_1.default {
+    constructor(request, type, userRequest) {
+        super(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
+        // Info from Factory
+        this.request = request;
+        this.externalType = type;
+        this.userRequest = userRequest;
+    }
+    getSourceTypes() {
+        return this.externalType === 'css-import' ? CSS_TYPES : TYPES;
+    }
+    libIdent(options) {
+        return this.userRequest;
+    }
+    chunkCondition(chunk, { chunkGraph }) {
+        return this.externalType === 'css-import' ? true : chunkGraph.getNumberOfEntryModules(chunk) > 0;
+    }
+    identifier() {
+        return `external ${this.externalType} ${JSON.stringify(this.request)}`;
+    }
+    readableIdentifier(requestShortener) {
+        return `external ${JSON.stringify(this.request)}`;
+    }
+    needBuild(context, callback) {
+        return callback(null, !this.buildMeta);
+    }
+    build(options, compilation, resolver, fs, callback) {
+        this.buildMeta = {
+            async: false,
+            exportsType: undefined,
+        };
+        this.buildInfo = {
+            strict: true,
+            topLevelDeclarations: new Set(),
+            module: compilation.outputOptions.module,
+        };
+        const { request, externalType } = this._getRequestAndExternalType();
+        this.buildMeta.exportsType = 'dynamic';
+        let canMangle = false;
+        this.clearDependenciesAndBlocks();
+        switch (externalType) {
+            case 'this':
+                this.buildInfo.strict = false;
+                break;
+            case 'system':
+                if (!Array.isArray(request) || request.length === 1) {
+                    this.buildMeta.exportsType = 'namespace';
+                    canMangle = true;
+                }
+                break;
+            case 'module':
+                if (this.buildInfo.module) {
+                    if (!Array.isArray(request) || request.length === 1) {
+                        this.buildMeta.exportsType = 'namespace';
+                        canMangle = true;
+                    }
+                }
+                else {
+                    this.buildMeta.async = true;
+                    if (!Array.isArray(request) || request.length === 1) {
+                        this.buildMeta.exportsType = 'namespace';
+                        canMangle = false;
+                    }
+                }
+                break;
+            case 'script':
+            case 'promise':
+                this.buildMeta.async = true;
+                break;
+            case 'import':
+                this.buildMeta.async = true;
+                if (!Array.isArray(request) || request.length === 1) {
+                    this.buildMeta.exportsType = 'namespace';
+                    canMangle = false;
+                }
+                break;
+        }
+        this.addDependency(new StaticExportsDependency_1.default(true, canMangle));
+        callback();
+    }
+    restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+        this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+    }
+    getConcatenationBailoutReason({ moduleGraph }) {
+        switch (this.externalType) {
+            case 'amd':
+            case 'amd-require':
+            case 'umd':
+            case 'umd2':
+            case 'system':
+            case 'jsonp':
+                return `${this.externalType} externals can't be concatenated`;
+        }
+        return '';
+    }
+    _getRequestAndExternalType() {
+        let { request, externalType } = this;
+        if (typeof request === 'object' && !Array.isArray(request))
+            request = request[externalType];
+        return { request, externalType };
+    }
+    _getSourceData(request, externalType, runtimeTemplate, moduleGraph, chunkGraph, runtime) {
+        switch (externalType) {
+            case 'this':
+            case 'window':
+            case 'self':
+                return getSourceForGlobalVariableExternal(request, this.externalType);
+            case 'global':
+                return getSourceForGlobalVariableExternal(request, runtimeTemplate.globalObject);
+            case 'commonjs':
+            case 'commonjs2':
+            case 'commonjs-module':
+            case 'commonjs-static':
+                return getSourceForCommonJsExternal(request);
+            case 'node-commonjs':
+                return this.buildInfo.module
+                    ? getSourceForCommonJsExternalInNodeModule(request, runtimeTemplate.outputOptions.importMetaName)
+                    : getSourceForCommonJsExternal(request);
+            case 'amd':
+            case 'amd-require':
+            case 'umd':
+            case 'umd2':
+            case 'system':
+            case 'jsonp': {
+                const id = chunkGraph.getModuleId(this);
+                return getSourceForAmdOrUmdExternal(id !== null ? id : this.identifier(), this.isOptional(moduleGraph), request, runtimeTemplate);
+            }
+            case 'import':
+                return getSourceForImportExternal(request, runtimeTemplate);
+            case 'script':
+                return getSourceForScriptExternal(request, runtimeTemplate);
+            case 'module': {
+                if (!this.buildInfo.module) {
+                    if (!runtimeTemplate.supportsDynamicImport()) {
+                        throw new Error(`The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script${runtimeTemplate.supportsEcmaScriptModuleSyntax()
+                            ? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+                            : ''}`);
+                    }
+                    return getSourceForImportExternal(request, runtimeTemplate);
+                }
+                if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
+                    throw new Error("The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'");
+                }
+                return getSourceForModuleExternal(request, moduleGraph.getExportsInfo(this), runtime, runtimeTemplate.outputOptions.hashFunction);
+            }
+            case 'var':
+            case 'promise':
+            case 'const':
+            case 'let':
+            case 'assign':
+            default:
+                return getSourceForDefaultCase(this.isOptional(moduleGraph), request, runtimeTemplate);
+        }
+    }
+    codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph, runtime, concatenationScope }) {
+        const { request, externalType } = this._getRequestAndExternalType();
+        switch (externalType) {
+            case 'asset': {
+                const sources = new Map();
+                sources.set('javascript', new webpack_sources_1.RawSource(`module.exports = ${JSON.stringify(request)};`));
+                const data = new Map();
+                data.set('url', request);
+                return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
+            }
+            case 'css-import': {
+                const sources = new Map();
+                sources.set('css-import', new webpack_sources_1.RawSource(`@import url(${JSON.stringify(request)});`));
+                return {
+                    sources,
+                    runtimeRequirements: EMPTY_RUNTIME_REQUIREMENTS,
+                };
+            }
+            default: {
+                const sourceData = this._getSourceData(request, externalType, runtimeTemplate, moduleGraph, chunkGraph, runtime);
+                let sourceString = sourceData.expression;
+                if (sourceData.iife)
+                    sourceString = `(function() { return ${sourceString}; }())`;
+                if (concatenationScope) {
+                    sourceString = `${runtimeTemplate.supportsConst() ? 'const' : 'var'} ${ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+                    concatenationScope.registerNamespaceExport(ConcatenationScope_1.default.NAMESPACE_OBJECT_EXPORT);
+                }
+                else {
+                    sourceString = `module.exports = ${sourceString};`;
+                }
+                if (sourceData.init)
+                    sourceString = `${sourceData.init}\n${sourceString}`;
+                let data;
+                if (sourceData.chunkInitFragments) {
+                    data = new Map();
+                    data.set('chunkInitFragments', sourceData.chunkInitFragments);
+                }
+                const sources = new Map();
+                if (this.useSourceMap || this.useSimpleSourceMap) {
+                    sources.set('javascript', new webpack_sources_1.OriginalSource(sourceString, this.identifier()));
+                }
+                else {
+                    sources.set('javascript', new webpack_sources_1.RawSource(sourceString));
+                }
+                let runtimeRequirements = sourceData.runtimeRequirements;
+                if (!concatenationScope) {
+                    if (!runtimeRequirements) {
+                        runtimeRequirements = RUNTIME_REQUIREMENTS;
+                    }
+                    else {
+                        const set = new Set(runtimeRequirements);
+                        set.add(RuntimeGlobals.module);
+                        runtimeRequirements = set;
+                    }
+                }
+                return {
+                    sources,
+                    runtimeRequirements: runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
+                    data,
+                };
+            }
+        }
+    }
+    size(type) {
+        return 42;
+    }
+    updateHash(hash, context) {
+        const { chunkGraph } = context;
+        hash.update(`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(chunkGraph.moduleGraph)}`);
+        super.updateHash(hash, context);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.request);
+        write(this.externalType);
+        write(this.userRequest);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.request = read();
+        this.externalType = read();
+        this.userRequest = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ExternalModule, 'mp-compiler/core/module/ExternalModule');
+exports.default = ExternalModule;

package/dist/module/ExternalModuleFactoryPlugin.d.ts

@@ -0,0 +1,7 @@
+declare class ExternalModuleFactoryPlugin {
+    type: any;
+    externals: any;
+    constructor(type: any, externals: any);
+    apply(normalModuleFactory: any): void;
+}
+export default ExternalModuleFactoryPlugin;