xhs-mp-pack 1.1.0-beta.0

package/dist/module/ContextModule.js

@@ -0,0 +1,844 @@
+"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 HookBaseError_1 = require("@/base/errors/HookBaseError");
+const Template_1 = require("@/template/Template");
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const comparators_1 = require("@/base/comparators");
+const identifier_1 = require("@/base/identifier");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const RuntimeGlobals = __importStar(require("./RuntimeGlobals"));
+const ModuleTypeConstants_1 = require("./ModuleTypeConstants");
+const Module_1 = __importDefault(require("./Module"));
+const AsyncDependenciesBlock_1 = __importDefault(require("../dependencies/AsyncDependenciesBlock"));
+const SNAPSHOT_OPTIONS = { timestamp: true };
+const TYPES = new Set(['javascript']);
+class ContextModule extends Module_1.default {
+    constructor(resolveDependencies, options) {
+        if (!options || typeof options.resource === 'string') {
+            const parsed = (0, identifier_1.parseResource)(options ? options.resource : '');
+            const resource = parsed.path;
+            const resourceQuery = (options === null || options === void 0 ? void 0 : options.resourceQuery) || parsed.query;
+            const resourceFragment = (options === null || options === void 0 ? void 0 : options.resourceFragment) || parsed.fragment;
+            const layer = options === null || options === void 0 ? void 0 : options.layer;
+            super(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC, resource, layer);
+            this.options = Object.assign(Object.assign({}, options), { resource,
+                resourceQuery,
+                resourceFragment });
+        }
+        else {
+            super(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC, undefined, options.layer);
+            this.options = Object.assign(Object.assign({}, options), { resource: options.resource, resourceQuery: options.resourceQuery || '', resourceFragment: options.resourceFragment || '' });
+        }
+        // Info from Factory
+        this.resolveDependencies = resolveDependencies;
+        if ((options === null || options === void 0 ? void 0 : options.resolveOptions) !== undefined) {
+            this.resolveOptions = options.resolveOptions;
+        }
+        if (options && typeof options.mode !== 'string') {
+            throw new Error('options.mode is a required option');
+        }
+        this._identifier = this._createIdentifier();
+        this._forceBuild = true;
+    }
+    getSourceTypes() {
+        return TYPES;
+    }
+    updateCacheModule(module) {
+        const m = module;
+        this.resolveDependencies = m.resolveDependencies;
+        this.options = m.options;
+    }
+    /**
+     * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+     */
+    cleanupForCache() {
+        super.cleanupForCache();
+        this.resolveDependencies = undefined;
+    }
+    _prettyRegExp(regexString, stripSlash = true) {
+        const str = (`${regexString}`).replace(/!/g, '%21').replace(/\|/g, '%7C');
+        return stripSlash ? str.substring(1, str.length - 1) : str;
+    }
+    _createIdentifier() {
+        let identifier = this.context ||
+            (typeof this.options.resource === 'string' || this.options.resource === false
+                ? `${this.options.resource}`
+                : this.options.resource.join('|'));
+        if (this.options.resourceQuery) {
+            identifier += `|${this.options.resourceQuery}`;
+        }
+        if (this.options.resourceFragment) {
+            identifier += `|${this.options.resourceFragment}`;
+        }
+        if (this.options.mode) {
+            identifier += `|${this.options.mode}`;
+        }
+        if (!this.options.recursive) {
+            identifier += '|nonrecursive';
+        }
+        if (this.options.addon) {
+            identifier += `|${this.options.addon}`;
+        }
+        if (this.options.regExp) {
+            identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
+        }
+        if (this.options.include) {
+            identifier += `|include: ${this._prettyRegExp(this.options.include, false)}`;
+        }
+        if (this.options.exclude) {
+            identifier += `|exclude: ${this._prettyRegExp(this.options.exclude, false)}`;
+        }
+        if (this.options.referencedExports) {
+            identifier += `|referencedExports: ${JSON.stringify(this.options.referencedExports)}`;
+        }
+        if (this.options.chunkName) {
+            identifier += `|chunkName: ${this.options.chunkName}`;
+        }
+        if (this.options.groupOptions) {
+            identifier += `|groupOptions: ${JSON.stringify(this.options.groupOptions)}`;
+        }
+        if (this.options.namespaceObject === 'strict') {
+            identifier += '|strict namespace object';
+        }
+        else if (this.options.namespaceObject) {
+            identifier += '|namespace object';
+        }
+        if (this.layer) {
+            identifier += `|layer: ${this.layer}`;
+        }
+        return identifier;
+    }
+    /**
+     * @returns {string} a unique identifier of the module
+     */
+    identifier() {
+        return this._identifier;
+    }
+    readableIdentifier(requestShortener) {
+        let identifier;
+        if (this.context) {
+            identifier = `${requestShortener.shorten(this.context)}/`;
+        }
+        else if (typeof this.options.resource === 'string' || this.options.resource === false) {
+            identifier = `${requestShortener.shorten(`${this.options.resource}`)}/`;
+        }
+        else {
+            identifier = this.options.resource.map(r => `${requestShortener.shorten(r)}/`).join(' ');
+        }
+        if (this.options.resourceQuery) {
+            identifier += ` ${this.options.resourceQuery}`;
+        }
+        if (this.options.mode) {
+            identifier += ` ${this.options.mode}`;
+        }
+        if (!this.options.recursive) {
+            identifier += ' nonrecursive';
+        }
+        if (this.options.addon) {
+            identifier += ` ${requestShortener.shorten(this.options.addon)}`;
+        }
+        if (this.options.regExp) {
+            identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+        }
+        if (this.options.include) {
+            identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
+        }
+        if (this.options.exclude) {
+            identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+        }
+        if (this.options.referencedExports) {
+            identifier += ` referencedExports: ${this.options.referencedExports
+                .map(e => e.join('.'))
+                .join(', ')}`;
+        }
+        if (this.options.chunkName) {
+            identifier += ` chunkName: ${this.options.chunkName}`;
+        }
+        if (this.options.groupOptions) {
+            const groupOptions = this.options.groupOptions;
+            for (const key of Object.keys(groupOptions)) {
+                identifier += ` ${key}: ${groupOptions[key]}`;
+            }
+        }
+        if (this.options.namespaceObject === 'strict') {
+            identifier += ' strict namespace object';
+        }
+        else if (this.options.namespaceObject) {
+            identifier += ' namespace object';
+        }
+        return identifier;
+    }
+    libIdent(options) {
+        let identifier;
+        if (this.context) {
+            identifier = (0, identifier_1.contextify)(options.context, this.context, options.associatedObjectForCache);
+        }
+        else if (typeof this.options.resource === 'string') {
+            identifier = (0, identifier_1.contextify)(options.context, this.options.resource, options.associatedObjectForCache);
+        }
+        else if (this.options.resource === false) {
+            identifier = 'false';
+        }
+        else {
+            identifier = this.options.resource
+                .map(res => (0, identifier_1.contextify)(options.context, res, options.associatedObjectForCache))
+                .join(' ');
+        }
+        if (this.layer)
+            identifier = `(${this.layer})/${identifier}`;
+        if (this.options.mode) {
+            identifier += ` ${this.options.mode}`;
+        }
+        if (this.options.recursive) {
+            identifier += ' recursive';
+        }
+        if (this.options.addon) {
+            identifier += ` ${(0, identifier_1.contextify)(options.context, this.options.addon, options.associatedObjectForCache)}`;
+        }
+        if (this.options.regExp) {
+            identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+        }
+        if (this.options.include) {
+            identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
+        }
+        if (this.options.exclude) {
+            identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+        }
+        if (this.options.referencedExports) {
+            identifier += ` referencedExports: ${this.options.referencedExports
+                .map(e => e.join('.'))
+                .join(', ')}`;
+        }
+        return identifier;
+    }
+    invalidateBuild() {
+        this._forceBuild = true;
+    }
+    needBuild({ fileSystemInfo }, callback) {
+        // build if enforced
+        if (this._forceBuild)
+            return callback(null, true);
+        // always build when we have no snapshot and context
+        if (!this.buildInfo.snapshot)
+            return callback(null, Boolean(this.context || this.options.resource));
+        fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+            callback(err, !valid);
+        });
+    }
+    build(options, compilation, resolver, fs, callback) {
+        this._forceBuild = false;
+        this.buildMeta = {
+            exportsType: 'default',
+            defaultObject: 'redirect-warn',
+        };
+        this.buildInfo = {
+            snapshot: undefined,
+        };
+        this.dependencies.length = 0;
+        this.blocks.length = 0;
+        const startTime = Date.now();
+        this.resolveDependencies(fs, this.options, (err, dependencies) => {
+            if (err) {
+                return callback((0, HookBaseError_1.makeBaseError)(err, 'ContextModule.resolveDependencies'));
+            }
+            // abort if something failed
+            // this will create an empty context
+            if (!dependencies) {
+                callback();
+                return;
+            }
+            // enhance dependencies with meta info
+            for (const dep of dependencies) {
+                dep.loc = {
+                    name: dep.userRequest,
+                };
+                dep.request = this.options.addon + dep.request;
+            }
+            dependencies.sort((0, comparators_1.concatComparators)((0, comparators_1.compareSelect)(a => a.loc, comparators_1.compareLocations), (0, comparators_1.keepOriginalOrder)(this.dependencies)));
+            if (this.options.mode === 'sync' || this.options.mode === 'eager') {
+                // if we have an sync or eager context
+                // just add all dependencies and continue
+                this.dependencies = dependencies;
+            }
+            else if (this.options.mode === 'lazy-once') {
+                // for the lazy-once mode create a new async dependency block
+                // and add that block to this context
+                if (dependencies.length > 0) {
+                    const block = new AsyncDependenciesBlock_1.default(Object.assign(Object.assign({}, this.options.groupOptions), { name: this.options.chunkName }));
+                    for (const dep of dependencies) {
+                        block.addDependency(dep);
+                    }
+                    this.addBlock(block);
+                }
+            }
+            else if (this.options.mode === 'weak' || this.options.mode === 'async-weak') {
+                // we mark all dependencies as weak
+                for (const dep of dependencies) {
+                    dep.weak = true;
+                }
+                this.dependencies = dependencies;
+            }
+            else if (this.options.mode === 'lazy') {
+                // if we are lazy create a new async dependency block per dependency
+                // and add all blocks to this context
+                let index = 0;
+                for (const dep of dependencies) {
+                    let chunkName = this.options.chunkName;
+                    if (chunkName) {
+                        if (!/\[(index|request)\]/.test(chunkName)) {
+                            chunkName += '[index]';
+                        }
+                        chunkName = chunkName.replace(/\[index\]/g, `${index++}`);
+                        chunkName = chunkName.replace(/\[request\]/g, Template_1.Template.toPath(dep.userRequest));
+                    }
+                    const block = new AsyncDependenciesBlock_1.default(Object.assign(Object.assign({}, this.options.groupOptions), { name: chunkName }), dep.loc, dep.userRequest);
+                    block.addDependency(dep);
+                    this.addBlock(block);
+                }
+            }
+            else {
+                callback(new BaseError_1.default(`Unsupported mode "${this.options.mode}" in context`));
+                return;
+            }
+            if (!this.context && !this.options.resource)
+                return callback();
+            compilation.fileSystemInfo.createSnapshot(startTime, null, this.context
+                ? [this.context]
+                : typeof this.options.resource === 'string'
+                    ? [this.options.resource]
+                    : this.options.resource, null, SNAPSHOT_OPTIONS, (err, snapshot) => {
+                if (err)
+                    return callback(err);
+                this.buildInfo.snapshot = snapshot;
+                callback();
+            });
+        });
+    }
+    addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies) {
+        if (this.context) {
+            contextDependencies.add(this.context);
+        }
+        else if (typeof this.options.resource === 'string') {
+            contextDependencies.add(this.options.resource);
+        }
+        else if (this.options.resource === false) {
+            // eslint-disable-next-line no-useless-return
+            return;
+        }
+        else {
+            for (const res of this.options.resource)
+                contextDependencies.add(res);
+        }
+    }
+    getUserRequestMap(dependencies, chunkGraph) {
+        const moduleGraph = chunkGraph.moduleGraph;
+        // if we filter first we get a new array
+        // therefore we don't need to create a clone of dependencies explicitly
+        // therefore the order of this is !important!
+        const sortedDependencies = dependencies
+            .filter(dependency => moduleGraph.getModule(dependency))
+            .sort((a, b) => {
+            if (a.userRequest === b.userRequest) {
+                return 0;
+            }
+            return a.userRequest < b.userRequest ? -1 : 1;
+        });
+        const map = Object.create(null);
+        for (const dep of sortedDependencies) {
+            const module = moduleGraph.getModule(dep);
+            map[dep.userRequest] = chunkGraph.getModuleId(module);
+        }
+        return map;
+    }
+    getFakeMap(dependencies, chunkGraph) {
+        if (!this.options.namespaceObject) {
+            return 9;
+        }
+        const moduleGraph = chunkGraph.moduleGraph;
+        // bitfield
+        let hasType = 0;
+        const comparator = (0, comparators_1.compareModulesById)(chunkGraph);
+        // if we filter first we get a new array
+        // therefore we don't need to create a clone of dependencies explicitly
+        // therefore the order of this is !important!
+        const sortedModules = dependencies
+            .map(dependency => moduleGraph.getModule(dependency))
+            .filter(Boolean)
+            .sort(comparator);
+        const fakeMap = Object.create(null);
+        for (const module of sortedModules) {
+            const exportsType = module.getExportsType(moduleGraph, this.options.namespaceObject === 'strict');
+            const id = chunkGraph.getModuleId(module);
+            switch (exportsType) {
+                case 'namespace':
+                    fakeMap[id] = 9;
+                    hasType |= 1;
+                    break;
+                case 'dynamic':
+                    fakeMap[id] = 7;
+                    hasType |= 2;
+                    break;
+                case 'default-only':
+                    fakeMap[id] = 1;
+                    hasType |= 4;
+                    break;
+                case 'default-with-named':
+                    fakeMap[id] = 3;
+                    hasType |= 8;
+                    break;
+                default:
+                    throw new Error(`Unexpected exports type ${exportsType}`);
+            }
+        }
+        if (hasType === 1) {
+            return 9;
+        }
+        if (hasType === 2) {
+            return 7;
+        }
+        if (hasType === 4) {
+            return 1;
+        }
+        if (hasType === 8) {
+            return 3;
+        }
+        if (hasType === 0) {
+            return 9;
+        }
+        return fakeMap;
+    }
+    getFakeMapInitStatement(fakeMap) {
+        return typeof fakeMap === 'object'
+            ? `var fakeMap = ${JSON.stringify(fakeMap, null, '\t')};`
+            : '';
+    }
+    getReturn(type, asyncModule) {
+        if (type === 9) {
+            return `${RuntimeGlobals.require}(id)`;
+        }
+        return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${asyncModule ? ' | 16' : ''})`;
+    }
+    getReturnModuleObjectSource(fakeMap, asyncModule, fakeMapDataExpression = 'fakeMap[id]') {
+        if (typeof fakeMap === 'number') {
+            return `return ${this.getReturn(fakeMap, asyncModule)};`;
+        }
+        return `return ${RuntimeGlobals.createFakeNamespaceObject}(id, ${fakeMapDataExpression}${asyncModule ? ' | 16' : ''})`;
+    }
+    getSyncSource(dependencies, id, chunkGraph) {
+        const map = this.getUserRequestMap(dependencies, chunkGraph);
+        const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+        const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+        return `var map = ${JSON.stringify(map, null, '\t')};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	${returnModuleObject}
+}
+function webpackContextResolve(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+module.exports = webpackContext;
+webpackContext.id = ${JSON.stringify(id)};`;
+    }
+    getWeakSyncSource(dependencies, id, chunkGraph) {
+        const map = this.getUserRequestMap(dependencies, chunkGraph);
+        const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+        const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+        return `var map = ${JSON.stringify(map, null, '\t')};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	if(!${RuntimeGlobals.moduleFactories}[id]) {
+		var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	${returnModuleObject}
+}
+function webpackContextResolve(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+webpackContext.id = ${JSON.stringify(id)};
+module.exports = webpackContext;`;
+    }
+    getAsyncWeakSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
+        const arrow = runtimeTemplate.supportsArrowFunction();
+        const map = this.getUserRequestMap(dependencies, chunkGraph);
+        const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+        const returnModuleObject = this.getReturnModuleObjectSource(fakeMap, true);
+        return `var map = ${JSON.stringify(map, null, '\t')};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${arrow ? 'id =>' : 'function(id)'} {
+		if(!${RuntimeGlobals.moduleFactories}[id]) {
+			var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		${returnModuleObject}
+	});
+}
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? '() =>' : 'function()'} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction('Object.keys(map)')};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+    }
+    getEagerSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
+        const arrow = runtimeTemplate.supportsArrowFunction();
+        const map = this.getUserRequestMap(dependencies, chunkGraph);
+        const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+        const thenFunction = fakeMap !== 9
+            ? `${arrow ? 'id =>' : 'function(id)'} {
+		${this.getReturnModuleObjectSource(fakeMap)}
+	}`
+            : RuntimeGlobals.require;
+        return `var map = ${JSON.stringify(map, null, '\t')};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${thenFunction});
+}
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? '() =>' : 'function()'} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction('Object.keys(map)')};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+    }
+    getLazyOnceSource(block, dependencies, id, { runtimeTemplate, chunkGraph }) {
+        const promise = runtimeTemplate.blockPromise({
+            chunkGraph,
+            block,
+            message: 'lazy-once context',
+            runtimeRequirements: new Set(),
+        });
+        const arrow = runtimeTemplate.supportsArrowFunction();
+        const map = this.getUserRequestMap(dependencies, chunkGraph);
+        const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+        const thenFunction = fakeMap !== 9
+            ? `${arrow ? 'id =>' : 'function(id)'} {
+		${this.getReturnModuleObjectSource(fakeMap, true)};
+	}`
+            : RuntimeGlobals.require;
+        return `var map = ${JSON.stringify(map, null, '\t')};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${thenFunction});
+}
+function webpackAsyncContextResolve(req) {
+	return ${promise}.then(${arrow ? '() =>' : 'function()'} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction('Object.keys(map)')};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+    }
+    getLazySource(blocks, id, { chunkGraph, runtimeTemplate }) {
+        const moduleGraph = chunkGraph.moduleGraph;
+        const arrow = runtimeTemplate.supportsArrowFunction();
+        let hasMultipleOrNoChunks = false;
+        let hasNoChunk = true;
+        const fakeMap = this.getFakeMap(blocks.map(b => b.dependencies[0]), chunkGraph);
+        const hasFakeMap = typeof fakeMap === 'object';
+        const items = blocks
+            .map(block => {
+            const dependency = block.dependencies[0];
+            return {
+                dependency,
+                module: moduleGraph.getModule(dependency),
+                block,
+                userRequest: dependency.userRequest,
+                chunks: undefined,
+            };
+        })
+            .filter(item => item.module);
+        for (const item of items) {
+            const chunkGroup = chunkGraph.getBlockChunkGroup(item.block);
+            const chunks = (chunkGroup === null || chunkGroup === void 0 ? void 0 : chunkGroup.chunks) || [];
+            item.chunks = chunks;
+            if (chunks.length > 0) {
+                hasNoChunk = false;
+            }
+            if (chunks.length !== 1) {
+                hasMultipleOrNoChunks = true;
+            }
+        }
+        const shortMode = hasNoChunk && !hasFakeMap;
+        const sortedItems = items.sort((a, b) => {
+            if (a.userRequest === b.userRequest)
+                return 0;
+            return a.userRequest < b.userRequest ? -1 : 1;
+        });
+        const map = Object.create(null);
+        for (const item of sortedItems) {
+            const moduleId = chunkGraph.getModuleId(item.module);
+            if (shortMode) {
+                map[item.userRequest] = moduleId;
+            }
+            else {
+                const arrayStart = [moduleId];
+                if (hasFakeMap) {
+                    arrayStart.push(fakeMap[moduleId]);
+                }
+                map[item.userRequest] = arrayStart.concat(item.chunks.map(chunk => chunk.id));
+            }
+        }
+        const chunksStartPosition = hasFakeMap ? 2 : 1;
+        const requestPrefix = hasNoChunk
+            ? 'Promise.resolve()'
+            : hasMultipleOrNoChunks
+                ? `Promise.all(ids.slice(${chunksStartPosition}).map(${RuntimeGlobals.ensureChunk}))`
+                : `${RuntimeGlobals.ensureChunk}(ids[${chunksStartPosition}])`;
+        const returnModuleObject = this.getReturnModuleObjectSource(fakeMap, true, shortMode ? 'invalid' : 'ids[1]');
+        const webpackAsyncContext = requestPrefix === 'Promise.resolve()'
+            ? `
+function webpackAsyncContext(req) {
+	return Promise.resolve().then(${arrow ? '() =>' : 'function()'} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+
+		${shortMode ? 'var id = map[req];' : 'var ids = map[req], id = ids[0];'}
+		${returnModuleObject}
+	});
+}`
+            : `function webpackAsyncContext(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		return Promise.resolve().then(${arrow ? '() =>' : 'function()'} {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		});
+	}
+
+	var ids = map[req], id = ids[0];
+	return ${requestPrefix}.then(${arrow ? '() =>' : 'function()'} {
+		${returnModuleObject}
+	});
+}`;
+        return `var map = ${JSON.stringify(map, null, '\t')};
+${webpackAsyncContext}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction('Object.keys(map)')};
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+    }
+    getSourceForEmptyContext(id, runtimeTemplate) {
+        return `function webpackEmptyContext(req) {
+	var e = new Error("Cannot find module '" + req + "'");
+	e.code = 'MODULE_NOT_FOUND';
+	throw e;
+}
+webpackEmptyContext.keys = ${runtimeTemplate.returningFunction('[]')};
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = ${JSON.stringify(id)};
+module.exports = webpackEmptyContext;`;
+    }
+    getSourceForEmptyAsyncContext(id, runtimeTemplate) {
+        const arrow = runtimeTemplate.supportsArrowFunction();
+        return `function webpackEmptyAsyncContext(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? '() =>' : 'function()'} {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	});
+}
+webpackEmptyAsyncContext.keys = ${runtimeTemplate.returningFunction('[]')};
+webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
+webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackEmptyAsyncContext;`;
+    }
+    getSourceString(asyncMode, { runtimeTemplate, chunkGraph }) {
+        const id = chunkGraph.getModuleId(this);
+        if (asyncMode === 'lazy') {
+            if (this.blocks && this.blocks.length > 0) {
+                return this.getLazySource(this.blocks, id, {
+                    runtimeTemplate,
+                    chunkGraph,
+                });
+            }
+            return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+        }
+        if (asyncMode === 'eager') {
+            if (this.dependencies && this.dependencies.length > 0) {
+                return this.getEagerSource(this.dependencies, id, {
+                    chunkGraph,
+                    runtimeTemplate,
+                });
+            }
+            return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+        }
+        if (asyncMode === 'lazy-once') {
+            const block = this.blocks[0];
+            if (block) {
+                return this.getLazyOnceSource(block, block.dependencies, id, {
+                    runtimeTemplate,
+                    chunkGraph,
+                });
+            }
+            return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+        }
+        if (asyncMode === 'async-weak') {
+            if (this.dependencies && this.dependencies.length > 0) {
+                return this.getAsyncWeakSource(this.dependencies, id, {
+                    chunkGraph,
+                    runtimeTemplate,
+                });
+            }
+            return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+        }
+        if (asyncMode === 'weak') {
+            if (this.dependencies && this.dependencies.length > 0) {
+                return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
+            }
+        }
+        if (this.dependencies && this.dependencies.length > 0) {
+            return this.getSyncSource(this.dependencies, id, chunkGraph);
+        }
+        return this.getSourceForEmptyContext(id, runtimeTemplate);
+    }
+    getSource(sourceString, compilation) {
+        if (this.useSourceMap || this.useSimpleSourceMap) {
+            return new webpack_sources_1.OriginalSource(sourceString, `webpack://${(0, identifier_1.makePathsRelative)((compilation === null || compilation === void 0 ? void 0 : compilation.compiler.context) || '', this.identifier(), compilation === null || compilation === void 0 ? void 0 : compilation.compiler.root)}`);
+        }
+        return new webpack_sources_1.RawSource(sourceString);
+    }
+    codeGeneration(context) {
+        const { chunkGraph, compilation } = context;
+        const sources = new Map();
+        sources.set('javascript', this.getSource(this.getSourceString(this.options.mode, context), compilation));
+        const set = new Set();
+        const allDeps = this.dependencies.length > 0 ? this.dependencies.slice() : [];
+        for (const block of this.blocks)
+            for (const dep of block.dependencies)
+                allDeps.push(dep);
+        set.add(RuntimeGlobals.module);
+        set.add(RuntimeGlobals.hasOwnProperty);
+        if (allDeps.length > 0) {
+            const asyncMode = this.options.mode;
+            set.add(RuntimeGlobals.require);
+            if (asyncMode === 'weak') {
+                set.add(RuntimeGlobals.moduleFactories);
+            }
+            else if (asyncMode === 'async-weak') {
+                set.add(RuntimeGlobals.moduleFactories);
+                set.add(RuntimeGlobals.ensureChunk);
+            }
+            else if (asyncMode === 'lazy' || asyncMode === 'lazy-once') {
+                set.add(RuntimeGlobals.ensureChunk);
+            }
+            if (this.getFakeMap(allDeps, chunkGraph) !== 9) {
+                set.add(RuntimeGlobals.createFakeNamespaceObject);
+            }
+        }
+        return {
+            sources,
+            runtimeRequirements: set,
+        };
+    }
+    size(type) {
+        // base penalty
+        let size = 160;
+        // if we don't have dependencies we stop here.
+        for (const dependency of this.dependencies) {
+            const element = dependency;
+            size += 5 + element.userRequest.length;
+        }
+        return size;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this._identifier);
+        write(this._forceBuild);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this._identifier = read();
+        this._forceBuild = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ContextModule, 'mp-compiler/core/module/ContextModule');
+exports.default = ContextModule;