xhs-mp-pack 1.1.0-beta.0

package/dist/template/RuntimeTemplate.js

@@ -0,0 +1,663 @@
+"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 InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const ArrayHelpers_1 = require("@/base/ArrayHelpers");
+const compileBooleanMatcher_1 = __importDefault(require("@/base/compileBooleanMatcher"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const Template_1 = require("./Template");
+const noModuleIdErrorMessage = (module, chunkGraph) => `Module ${module.identifier()} has no id assigned.
+This should not happen.
+It's in these chunks: ${Array.from(chunkGraph.getModuleChunksIterable(module), (c) => c.name || c.id || c.debugId).join(', ') || 'none'} (If module is in no chunk this indicates a bug in some chunk/module optimization logic)
+Module has these incoming connections: ${Array.from(chunkGraph.moduleGraph.getIncomingConnections(module), (connection) => {
+    var _a, _b;
+    return `\n - ${(_a = connection.originModule) === null || _a === void 0 ? void 0 : _a.identifier()} ${(_b = connection.dependency) === null || _b === void 0 ? void 0 : _b.type} ${(connection.explanations && Array.from(connection.explanations).join(', ')) || ''}`;
+}).join('')}`;
+function getGlobalObject(definition) {
+    if (!definition)
+        return definition;
+    const trimmed = definition.trim();
+    if (
+    // identifier, we do not need real identifier regarding ECMAScript/Unicode
+    trimmed.match(/^[_\p{L}][_0-9\p{L}]*$/iu) ||
+        // iife
+        // call expression
+        // expression in parentheses
+        trimmed.match(/^([_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu))
+        return trimmed;
+    return `Object(${trimmed})`;
+}
+class RuntimeTemplate {
+    constructor(compilation, outputOptions, requestShortener) {
+        this.compilation = compilation;
+        this.outputOptions = outputOptions || {};
+        this.requestShortener = requestShortener;
+        this.globalObject = getGlobalObject(outputOptions.globalObject);
+        this.contentHashReplacement = 'X'.repeat(outputOptions.hashDigestLength);
+    }
+    isIIFE() {
+        return this.outputOptions.iife;
+    }
+    isModule() {
+        return this.outputOptions.module;
+    }
+    supportsConst() {
+        return this.outputOptions.environment.const;
+    }
+    supportsArrowFunction() {
+        return this.outputOptions.environment.arrowFunction;
+    }
+    supportsOptionalChaining() {
+        return this.outputOptions.environment.optionalChaining;
+    }
+    supportsForOf() {
+        return this.outputOptions.environment.forOf;
+    }
+    supportsDestructuring() {
+        return this.outputOptions.environment.destructuring;
+    }
+    supportsBigIntLiteral() {
+        return this.outputOptions.environment.bigIntLiteral;
+    }
+    supportsDynamicImport() {
+        return this.outputOptions.environment.dynamicImport;
+    }
+    supportsEcmaScriptModuleSyntax() {
+        return this.outputOptions.environment.module;
+    }
+    supportTemplateLiteral() {
+        return this.outputOptions.environment.templateLiteral;
+    }
+    returningFunction(returnValue, args = '') {
+        return this.supportsArrowFunction()
+            ? `(${args}) => (${returnValue})`
+            : `function(${args}) { return ${returnValue}; }`;
+    }
+    basicFunction(args, body) {
+        return this.supportsArrowFunction()
+            ? `(${args}) => {\n${Template_1.Template.indent(body)}\n}`
+            : `function(${args}) {\n${Template_1.Template.indent(body)}\n}`;
+    }
+    concatenation(...args) {
+        const len = args.length;
+        if (len === 2)
+            return this._es5Concatenation(args);
+        if (len === 0)
+            return '""';
+        if (len === 1) {
+            return typeof args[0] === 'string' ? JSON.stringify(args[0]) : `"" + ${args[0].expr}`;
+        }
+        if (!this.supportTemplateLiteral())
+            return this._es5Concatenation(args);
+        // cost comparison between template literal and concatenation:
+        // both need equal surroundings: `xxx` vs "xxx"
+        // template literal has constant cost of 3 chars for each expression
+        // es5 concatenation has cost of 3 + n chars for n expressions in row
+        // when a es5 concatenation ends with an expression it reduces cost by 3
+        // when a es5 concatenation starts with an single expression it reduces cost by 3
+        // e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
+        // e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
+        let templateCost = 0;
+        let concatenationCost = 0;
+        let lastWasExpr = false;
+        for (const arg of args) {
+            const isExpr = typeof arg !== 'string';
+            if (isExpr) {
+                templateCost += 3;
+                concatenationCost += lastWasExpr ? 1 : 4;
+            }
+            lastWasExpr = isExpr;
+        }
+        if (lastWasExpr)
+            concatenationCost -= 3;
+        if (typeof args[0] !== 'string' && typeof args[1] === 'string')
+            concatenationCost -= 3;
+        if (concatenationCost <= templateCost)
+            return this._es5Concatenation(args);
+        return `\`${args.map(arg => (typeof arg === 'string' ? arg : `\${${arg.expr}}`)).join('')}\``;
+    }
+    _es5Concatenation(args) {
+        const str = args
+            .map(arg => (typeof arg === 'string' ? JSON.stringify(arg) : arg.expr))
+            .join(' + ');
+        // when the first two args are expression, we need to prepend "" + to force string
+        // concatenation instead of number addition.
+        return typeof args[0] !== 'string' && typeof args[1] !== 'string' ? `"" + ${str}` : str;
+    }
+    expressionFunction(expression, args = '') {
+        return this.supportsArrowFunction()
+            ? `(${args}) => (${expression})`
+            : `function(${args}) { ${expression}; }`;
+    }
+    emptyFunction() {
+        return this.supportsArrowFunction() ? 'x => {}' : 'function() {}';
+    }
+    destructureArray(items, value) {
+        return this.supportsDestructuring()
+            ? `var [${items.join(', ')}] = ${value};`
+            : Template_1.Template.asString(items.map((item, i) => `var ${item} = ${value}[${i}];`));
+    }
+    destructureObject(items, value) {
+        return this.supportsDestructuring()
+            ? `var {${items.join(', ')}} = ${value};`
+            : Template_1.Template.asString(items.map(item => `var ${item} = ${value}${(0, propertyAccess_1.default)([item])};`));
+    }
+    iife(args, body) {
+        return `(${this.basicFunction(args, body)})()`;
+    }
+    forEach(variable, array, body) {
+        return this.supportsForOf()
+            ? `for(const ${variable} of ${array}) {\n${Template_1.Template.indent(body)}\n}`
+            : `${array}.forEach(function(${variable}) {\n${Template_1.Template.indent(body)}\n});`;
+    }
+    /**
+     * Add a comment
+     */
+    comment({ request, chunkName, chunkReason, message, exportName }) {
+        let content;
+        if (this.outputOptions.pathinfo) {
+            content = [message, request, chunkName, chunkReason]
+                .filter(Boolean)
+                .map(item => this.requestShortener.shorten(item))
+                .join(' | ');
+        }
+        else {
+            content = [message, chunkName, chunkReason]
+                .filter(Boolean)
+                .map(item => this.requestShortener.shorten(item))
+                .join(' | ');
+        }
+        if (!content)
+            return '';
+        if (this.outputOptions.pathinfo) {
+            return `${Template_1.Template.toComment(content)} `;
+        }
+        return `${Template_1.Template.toNormalComment(content)} `;
+    }
+    throwMissingModuleErrorBlock({ request }) {
+        const err = `Cannot find module '${request}'`;
+        return `var e = new Error(${JSON.stringify(err)}); e.code = 'MODULE_NOT_FOUND'; throw e;`;
+    }
+    throwMissingModuleErrorFunction({ request }) {
+        return `function webpackMissingModule() { ${this.throwMissingModuleErrorBlock({ request })} }`;
+    }
+    missingModule({ request }) {
+        return `Object(${this.throwMissingModuleErrorFunction({ request })}())`;
+    }
+    missingModuleStatement({ request }) {
+        return `${this.missingModule({ request })};\n`;
+    }
+    missingModulePromise({ request }) {
+        return `Promise.resolve().then(${this.throwMissingModuleErrorFunction({
+            request,
+        })})`;
+    }
+    weakError({ module, chunkGraph, request, idExpr, type }) {
+        const moduleId = chunkGraph.getModuleId(module);
+        const errorMessage = moduleId === null
+            ? JSON.stringify('Module is not available (weak dependency)')
+            : idExpr
+                ? `"Module '" + ${idExpr} + "' is not available (weak dependency)"`
+                : JSON.stringify(`Module '${moduleId}' is not available (weak dependency)`);
+        const comment = request ? `${Template_1.Template.toNormalComment(request)} ` : '';
+        const errorStatements = `var e = new Error(${errorMessage}); ${comment}e.code = 'MODULE_NOT_FOUND'; throw e;`;
+        switch (type) {
+            case 'statements':
+                return errorStatements;
+            case 'promise':
+                return `Promise.resolve().then(${this.basicFunction('', errorStatements)})`;
+            case 'expression':
+                return this.iife('', errorStatements);
+            default:
+                break;
+        }
+    }
+    moduleId({ module, chunkGraph, request, weak }) {
+        if (!module) {
+            return this.missingModule({
+                request,
+            });
+        }
+        const moduleId = chunkGraph.getModuleId(module);
+        if (moduleId === null) {
+            if (weak) {
+                return 'null /* weak dependency, without id */';
+            }
+            throw new Error(`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(module, chunkGraph)}`);
+        }
+        return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
+    }
+    moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }) {
+        if (!module) {
+            return this.missingModule({
+                request,
+            });
+        }
+        const moduleId = chunkGraph.getModuleId(module);
+        if (moduleId === null) {
+            if (weak) {
+                // only weak referenced modules don't get an id
+                // we can always emit an error emitting code here
+                return this.weakError({
+                    module,
+                    chunkGraph,
+                    request,
+                    type: 'expression',
+                });
+            }
+            throw new Error(`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(module, chunkGraph)}`);
+        }
+        runtimeRequirements.add(RuntimeGlobals.require);
+        return `${RuntimeGlobals.require}(${this.moduleId({
+            module,
+            chunkGraph,
+            request,
+            weak,
+        })})`;
+    }
+    moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }) {
+        return this.moduleRaw({
+            module,
+            chunkGraph,
+            request,
+            weak,
+            runtimeRequirements,
+        });
+    }
+    moduleNamespace({ module, chunkGraph, request, strict, weak, runtimeRequirements }) {
+        if (!module) {
+            return this.missingModule({
+                request,
+            });
+        }
+        if (chunkGraph.getModuleId(module) === null) {
+            if (weak) {
+                // only weak referenced modules don't get an id
+                // we can always emit an error emitting code here
+                return this.weakError({
+                    module,
+                    chunkGraph,
+                    request,
+                    type: 'expression',
+                });
+            }
+            throw new Error(`RuntimeTemplate.moduleNamespace(): ${noModuleIdErrorMessage(module, chunkGraph)}`);
+        }
+        const moduleId = this.moduleId({
+            module,
+            chunkGraph,
+            request,
+            weak,
+        });
+        const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
+        switch (exportsType) {
+            case 'namespace':
+                return this.moduleRaw({
+                    module,
+                    chunkGraph,
+                    request,
+                    weak,
+                    runtimeRequirements,
+                });
+            case 'default-with-named':
+                runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+                return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`;
+            case 'default-only':
+                runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+                return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 1)`;
+            case 'dynamic':
+                runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+                return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 7)`;
+            default:
+                break;
+        }
+    }
+    moduleNamespacePromise({ chunkGraph, block, module, request, message, strict, weak, runtimeRequirements, }) {
+        if (!module) {
+            return this.missingModulePromise({
+                request,
+            });
+        }
+        const moduleId = chunkGraph.getModuleId(module);
+        if (moduleId === null) {
+            if (weak) {
+                // only weak referenced modules don't get an id
+                // we can always emit an error emitting code here
+                return this.weakError({
+                    module,
+                    chunkGraph,
+                    request,
+                    type: 'promise',
+                });
+            }
+            throw new Error(`RuntimeTemplate.moduleNamespacePromise(): ${noModuleIdErrorMessage(module, chunkGraph)}`);
+        }
+        const promise = this.blockPromise({
+            chunkGraph,
+            block,
+            message,
+            runtimeRequirements,
+        });
+        let appending;
+        let idExpr = JSON.stringify(chunkGraph.getModuleId(module));
+        const comment = this.comment({
+            request,
+        });
+        let header = '';
+        if (weak) {
+            if (idExpr.length > 8) {
+                // 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"'
+                header += `var id = ${idExpr}; `;
+                idExpr = 'id';
+            }
+            runtimeRequirements.add(RuntimeGlobals.moduleFactories);
+            header += `if(!${RuntimeGlobals.moduleFactories}[${idExpr}]) { ${this.weakError({
+                module,
+                chunkGraph,
+                request,
+                idExpr,
+                type: 'statements',
+            })} } `;
+        }
+        const moduleIdExpr = this.moduleId({
+            module,
+            chunkGraph,
+            request,
+            weak,
+        });
+        const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
+        let fakeType = 16;
+        switch (exportsType) {
+            case 'namespace':
+                if (header) {
+                    const rawModule = this.moduleRaw({
+                        module,
+                        chunkGraph,
+                        request,
+                        weak,
+                        runtimeRequirements,
+                    });
+                    appending = `.then(${this.basicFunction('', `${header}return ${rawModule};`)})`;
+                }
+                else {
+                    runtimeRequirements.add(RuntimeGlobals.require);
+                    appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+                }
+                break;
+            case 'dynamic':
+                fakeType |= 4;
+            /* fall through */
+            case 'default-with-named':
+                fakeType |= 2;
+            /* fall through */
+            case 'default-only':
+                runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+                if (chunkGraph.moduleGraph.isAsync(module)) {
+                    if (header) {
+                        const rawModule = this.moduleRaw({
+                            module,
+                            chunkGraph,
+                            request,
+                            weak,
+                            runtimeRequirements,
+                        });
+                        appending = `.then(${this.basicFunction('', `${header}return ${rawModule};`)})`;
+                    }
+                    else {
+                        runtimeRequirements.add(RuntimeGlobals.require);
+                        appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+                    }
+                    appending += `.then(${this.returningFunction(`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`, 'm')})`;
+                }
+                else {
+                    fakeType |= 1;
+                    if (header) {
+                        const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
+                        appending = `.then(${this.basicFunction('', `${header}return ${returnExpression};`)})`;
+                    }
+                    else {
+                        appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        return `${promise || 'Promise.resolve()'}${appending}`;
+    }
+    runtimeConditionExpression({ chunkGraph, runtimeCondition, runtime, runtimeRequirements }) {
+        if (runtimeCondition === undefined)
+            return 'true';
+        if (typeof runtimeCondition === 'boolean')
+            return `${runtimeCondition}`;
+        const positiveRuntimeIds = new Set();
+        (0, RuntimeHelpers_1.forEachRuntime)(runtimeCondition, runtime => positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`));
+        const negativeRuntimeIds = new Set();
+        (0, RuntimeHelpers_1.forEachRuntime)((0, RuntimeHelpers_1.subtractRuntime)(runtime, runtimeCondition), runtime => negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`));
+        runtimeRequirements.add(RuntimeGlobals.runtimeId);
+        return compileBooleanMatcher_1.default.fromLists(Array.from(positiveRuntimeIds), Array.from(negativeRuntimeIds))(RuntimeGlobals.runtimeId);
+    }
+    importStatement({ update, module, chunkGraph, request, importVar, originModule, weak, runtimeRequirements, }) {
+        if (!module) {
+            return [
+                this.missingModuleStatement({
+                    request,
+                }),
+                '',
+            ];
+        }
+        if (chunkGraph.getModuleId(module) === null) {
+            if (weak) {
+                // only weak referenced modules don't get an id
+                // we can always emit an error emitting code here
+                return [
+                    this.weakError({
+                        module,
+                        chunkGraph,
+                        request,
+                        type: 'statements',
+                    }),
+                    '',
+                ];
+            }
+            throw new Error(`RuntimeTemplate.importStatement(): ${noModuleIdErrorMessage(module, chunkGraph)}`);
+        }
+        const moduleId = this.moduleId({
+            module,
+            chunkGraph,
+            request,
+            weak,
+        });
+        const optDeclaration = update ? '' : 'var ';
+        const exportsType = module.getExportsType(chunkGraph.moduleGraph, originModule.buildMeta.strictHarmonyModule);
+        runtimeRequirements.add(RuntimeGlobals.require);
+        const importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
+        if (exportsType === 'dynamic') {
+            runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+            return [
+                importContent,
+                `/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${importVar});\n`,
+            ];
+        }
+        return [importContent, ''];
+    }
+    exportFromImport({ moduleGraph, module, request, exportName, originModule, asiSafe, isCall, callContext, defaultInterop, importVar, initFragments, runtime, runtimeRequirements, }) {
+        if (!module) {
+            return this.missingModule({
+                request,
+            });
+        }
+        if (!Array.isArray(exportName)) {
+            exportName = exportName ? [exportName] : [];
+        }
+        const exportsType = module.getExportsType(moduleGraph, originModule.buildMeta.strictHarmonyModule);
+        if (defaultInterop) {
+            if (exportName.length > 0 && exportName[0] === 'default') {
+                switch (exportsType) {
+                    case 'dynamic':
+                        if (isCall) {
+                            return `${importVar}_default()${(0, propertyAccess_1.default)(exportName, 1)}`;
+                        }
+                        return asiSafe
+                            ? `(${importVar}_default()${(0, propertyAccess_1.default)(exportName, 1)})`
+                            : asiSafe === false
+                                ? `;(${importVar}_default()${(0, propertyAccess_1.default)(exportName, 1)})`
+                                : `${importVar}_default.a${(0, propertyAccess_1.default)(exportName, 1)}`;
+                    case 'default-only':
+                    case 'default-with-named':
+                        exportName = exportName.slice(1);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            else if (exportName.length > 0) {
+                if (exportsType === 'default-only') {
+                    return (`/* non-default import from non-esm module */undefined${(0, propertyAccess_1.default)(exportName, 1)}`);
+                }
+                if (exportsType !== 'namespace' && exportName[0] === '__esModule') {
+                    return '/* __esModule */true';
+                }
+            }
+            else if (exportsType === 'default-only' || exportsType === 'default-with-named') {
+                runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+                initFragments.push(new InitFragment_1.default(`var ${importVar}_namespace_cache;\n`, InitFragment_1.default.STAGE_CONSTANTS, -1, `${importVar}_namespace_cache`));
+                return `/*#__PURE__*/ ${asiSafe ? '' : asiSafe === false ? ';' : 'Object'}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${RuntimeGlobals.createFakeNamespaceObject}(${importVar}${exportsType === 'default-only' ? '' : ', 2'})))`;
+            }
+        }
+        if (exportName.length > 0) {
+            const exportsInfo = moduleGraph.getExportsInfo(module);
+            const used = exportsInfo.getUsedName(exportName, runtime);
+            if (!used) {
+                const comment = Template_1.Template.toNormalComment(`unused export ${(0, propertyAccess_1.default)(exportName)}`);
+                return `${comment} undefined`;
+            }
+            const comment = (0, ArrayHelpers_1.equals)(used, exportName)
+                ? ''
+                : `${Template_1.Template.toNormalComment((0, propertyAccess_1.default)(exportName))} `;
+            const access = `${importVar}${comment}${(0, propertyAccess_1.default)(used)}`;
+            if (isCall && callContext === false) {
+                return asiSafe
+                    ? `(0,${access})`
+                    : asiSafe === false
+                        ? `;(0,${access})`
+                        : `/*#__PURE__*/Object(${access})`;
+            }
+            return access;
+        }
+        return importVar;
+    }
+    blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
+        if (!block) {
+            const comment = this.comment({
+                message,
+            });
+            return `Promise.resolve(${comment.trim()})`;
+        }
+        const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+        if (!chunkGroup || chunkGroup.chunks.length === 0) {
+            const comment = this.comment({
+                message,
+            });
+            return `Promise.resolve(${comment.trim()})`;
+        }
+        const chunks = chunkGroup.chunks.filter(chunk => !chunk.hasRuntime() && chunk.id !== null);
+        const comment = this.comment({
+            message,
+            chunkName: block.chunkName,
+        });
+        if (chunks.length === 1) {
+            const chunkId = JSON.stringify(chunks[0].id);
+            runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+            const fetchPriority = chunkGroup.options.fetchPriority;
+            if (fetchPriority) {
+                runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
+            }
+            return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId}${fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ''})`;
+        }
+        if (chunks.length > 0) {
+            runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+            const fetchPriority = chunkGroup.options.fetchPriority;
+            if (fetchPriority) {
+                runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
+            }
+            const requireChunkId = chunk => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ''})`;
+            return `Promise.all(${comment.trim()}[${chunks.map(requireChunkId).join(', ')}])`;
+        }
+        return `Promise.resolve(${comment.trim()})`;
+    }
+    asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) {
+        const dep = block.dependencies[0];
+        const module = chunkGraph.moduleGraph.getModule(dep);
+        const ensureChunk = this.blockPromise({
+            block,
+            message: '',
+            chunkGraph,
+            runtimeRequirements,
+        });
+        const factory = this.returningFunction(this.moduleRaw({
+            module,
+            chunkGraph,
+            request,
+            runtimeRequirements,
+        }));
+        return this.returningFunction(ensureChunk.startsWith('Promise.resolve(')
+            ? `${factory}`
+            : `${ensureChunk}.then(${this.returningFunction(factory)})`);
+    }
+    syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }) {
+        const module = chunkGraph.moduleGraph.getModule(dependency);
+        const factory = this.returningFunction(this.moduleRaw({
+            module,
+            chunkGraph,
+            request,
+            runtimeRequirements,
+        }));
+        return this.returningFunction(factory);
+    }
+    defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }) {
+        runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+        runtimeRequirements.add(RuntimeGlobals.exports);
+        return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
+    }
+    assetUrl({ publicPath, runtime, module, codeGenerationResults }) {
+        if (!module) {
+            return 'data:,';
+        }
+        const codeGen = codeGenerationResults.get(module, runtime);
+        const { data } = codeGen;
+        const url = data.get('url');
+        if (url)
+            return url.toString();
+        const filename = data.get('filename');
+        return publicPath + filename;
+    }
+}
+exports.default = RuntimeTemplate;

package/dist/template/Template.d.ts

@@ -0,0 +1,25 @@
+import { ConcatSource, PrefixSource } from 'webpack-sources';
+import Module from '../module/Module';
+import RuntimeModule from '../module/RuntimeModule';
+declare const NUMBER_OF_IDENTIFIER_START_CHARS: number;
+declare const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS: number;
+interface WithId {
+    id: string | number;
+}
+declare class Template {
+    static getFunctionContent(fn: any): any;
+    static toIdentifier(str: any): string;
+    static toComment(str: any): string;
+    static toNormalComment(str: any): string;
+    static toPath(str: any): string;
+    static numberToIdentifier(n: number): any;
+    static numberToIdentifierContinuation(n: number): any;
+    static indent(s: string | string[]): any;
+    static prefix(s: string | string[], prefix: string): string;
+    static asString(str: string | string[]): string;
+    static getModulesArrayBounds(modules: WithId[]): false | number[];
+    static renderChunkModules(renderContext: any, modules: Module[], renderModule: any, prefix?: string): ConcatSource | null;
+    static renderRuntimeModules(runtimeModules: RuntimeModule[], renderContext: any): ConcatSource;
+    static renderChunkRuntimeModules(runtimeModules: RuntimeModule[], renderContext: any): PrefixSource;
+}
+export { NUMBER_OF_IDENTIFIER_START_CHARS, NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS, Template };