xhs-mp-pack 1.1.0-beta.0

package/dist/module/runtime/ChunkNameRuntimeModule.js

@@ -0,0 +1,40 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class ChunkNameRuntimeModule extends RuntimeModule_1.default {
+    constructor(chunkName) {
+        super('chunkName');
+        this.chunkName = chunkName;
+    }
+    generate() {
+        return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;
+    }
+}
+exports.default = ChunkNameRuntimeModule;

package/dist/module/runtime/CompatGetDefaultExportRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default CompatGetDefaultExportRuntimeModule;

package/dist/module/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -0,0 +1,54 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('compat get default export');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        const fn = RuntimeGlobals.compatGetDefaultExport;
+        return Template_1.Template.asString([
+            '// getDefaultExport function for compatibility with non-harmony modules',
+            `${fn} = ${runtimeTemplate.basicFunction('module', [
+                'var getter = module && module.__esModule ?',
+                Template_1.Template.indent([
+                    `${runtimeTemplate.returningFunction("module['default']")} :`,
+                    `${runtimeTemplate.returningFunction('module')};`,
+                ]),
+                `${RuntimeGlobals.definePropertyGetters}(getter, { a: getter });`,
+                'return getter;',
+            ])};`,
+        ]);
+    }
+}
+exports.default = CompatGetDefaultExportRuntimeModule;

package/dist/module/runtime/CompatRuntimeModule.d.ts

@@ -0,0 +1,7 @@
+import RuntimeModule from '../RuntimeModule';
+declare class CompatRuntimeModule extends RuntimeModule {
+    constructor();
+    generate(): string;
+    shouldIsolate(): boolean;
+}
+export default CompatRuntimeModule;

package/dist/module/runtime/CompatRuntimeModule.js

@@ -0,0 +1,59 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class CompatRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('compat', RuntimeModule_1.default.STAGE_ATTACH);
+        this.fullHash = true;
+    }
+    generate() {
+        const compilation = this.compilation;
+        const chunkGraph = this.chunkGraph;
+        const chunk = this.chunk;
+        const { runtimeTemplate, mainTemplate, moduleTemplates, dependencyTemplates } = compilation;
+        const bootstrap = mainTemplate.hooks.bootstrap.call('', chunk, compilation.hash || 'XXXX', moduleTemplates.javascript, dependencyTemplates);
+        const localVars = mainTemplate.hooks.localVars.call('', chunk, compilation.hash || 'XXXX');
+        const requireExtensions = mainTemplate.hooks.requireExtensions.call('', chunk, compilation.hash || 'XXXX');
+        const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+        let requireEnsure = '';
+        if (runtimeRequirements.has(RuntimeGlobals.ensureChunk)) {
+            const requireEnsureHandler = mainTemplate.hooks.requireEnsure.call('', chunk, compilation.hash || 'XXXX', 'chunkId');
+            if (requireEnsureHandler) {
+                requireEnsure = `${RuntimeGlobals.ensureChunkHandlers}.compat = ${runtimeTemplate.basicFunction('chunkId, promises', requireEnsureHandler)};`;
+            }
+        }
+        return [bootstrap, localVars, requireEnsure, requireExtensions].filter(Boolean).join('\n');
+    }
+    shouldIsolate() {
+        // We avoid isolating this to have better backward-compat
+        return false;
+    }
+}
+exports.default = CompatRuntimeModule;

package/dist/module/runtime/CreateFakeNamespaceObjectRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default CreateFakeNamespaceObjectRuntimeModule;

package/dist/module/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -0,0 +1,77 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('create fake namespace object');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        const fn = RuntimeGlobals.createFakeNamespaceObject;
+        return Template_1.Template.asString([
+            `var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction('Object.getPrototypeOf(obj)', 'obj')} : ${runtimeTemplate.returningFunction('obj.__proto__', 'obj')};`,
+            'var leafPrototypes;',
+            '// create a fake namespace object',
+            '// mode & 1: value is a module id, require it',
+            '// mode & 2: merge all properties of value into the ns',
+            '// mode & 4: return value when already ns object',
+            "// mode & 16: return value when it's Promise-like",
+            '// mode & 8|1: behave like require',
+            // Note: must be a function (not arrow), because this is used in body!
+            `${fn} = function(value, mode) {`,
+            Template_1.Template.indent([
+                `if(mode & 1) value = this(value);`,
+                `if(mode & 8) return value;`,
+                "if(typeof value === 'object' && value) {",
+                Template_1.Template.indent([
+                    'if((mode & 4) && value.__esModule) return value;',
+                    "if((mode & 16) && typeof value.then === 'function') return value;",
+                ]),
+                '}',
+                'var ns = Object.create(null);',
+                `${RuntimeGlobals.makeNamespaceObject}(ns);`,
+                'var def = {};',
+                'leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];',
+                "for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
+                Template_1.Template.indent([
+                    `Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(`def[key] = ${runtimeTemplate.returningFunction('value[key]', '')}`, 'key')});`,
+                ]),
+                '}',
+                `def['default'] = ${runtimeTemplate.returningFunction('value', '')};`,
+                `${RuntimeGlobals.definePropertyGetters}(ns, def);`,
+                'return ns;',
+            ]),
+            '};',
+        ]);
+    }
+}
+exports.default = CreateFakeNamespaceObjectRuntimeModule;

package/dist/module/runtime/CreateScriptRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class CreateScriptRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default CreateScriptRuntimeModule;

package/dist/module/runtime/CreateScriptRuntimeModule.js

@@ -0,0 +1,44 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class CreateScriptRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('trusted types script');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate, outputOptions } = compilation;
+        const { trustedTypes } = outputOptions;
+        const fn = RuntimeGlobals.createScript;
+        return Template_1.Template.asString(`${fn} = ${runtimeTemplate.returningFunction(trustedTypes ? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)` : 'script', 'script')};`);
+    }
+}
+exports.default = CreateScriptRuntimeModule;

package/dist/module/runtime/CreateScriptUrlRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default CreateScriptUrlRuntimeModule;

package/dist/module/runtime/CreateScriptUrlRuntimeModule.js

@@ -0,0 +1,44 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class CreateScriptUrlRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('trusted types script url');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate, outputOptions } = compilation;
+        const { trustedTypes } = outputOptions;
+        const fn = RuntimeGlobals.createScriptUrl;
+        return Template_1.Template.asString(`${fn} = ${runtimeTemplate.returningFunction(trustedTypes ? `${RuntimeGlobals.getTrustedTypesPolicy}().createScriptURL(url)` : 'url', 'url')};`);
+    }
+}
+exports.default = CreateScriptUrlRuntimeModule;

package/dist/module/runtime/DefinePropertyGettersRuntimeModule.d.ts

@@ -0,0 +1,6 @@
+import HelperRuntimeModule from './HelperRuntimeModule';
+declare class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
+    constructor();
+    generate(): string;
+}
+export default DefinePropertyGettersRuntimeModule;

package/dist/module/runtime/DefinePropertyGettersRuntimeModule.js

@@ -0,0 +1,56 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const HelperRuntimeModule_1 = __importDefault(require("./HelperRuntimeModule"));
+class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule_1.default {
+    constructor() {
+        super('define property getters');
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        const fn = RuntimeGlobals.definePropertyGetters;
+        return Template_1.Template.asString([
+            '// define getter functions for harmony exports',
+            `${fn} = ${runtimeTemplate.basicFunction('exports, definition', [
+                `for(var key in definition) {`,
+                Template_1.Template.indent([
+                    `if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+                    Template_1.Template.indent([
+                        'Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });',
+                    ]),
+                    '}',
+                ]),
+                '}',
+            ])};`,
+        ]);
+    }
+}
+exports.default = DefinePropertyGettersRuntimeModule;

package/dist/module/runtime/EnsureChunkRuntimeModule.d.ts

@@ -0,0 +1,7 @@
+import RuntimeModule from '../RuntimeModule';
+declare class EnsureChunkRuntimeModule extends RuntimeModule {
+    runtimeRequirements: any;
+    constructor(runtimeRequirements: any);
+    generate(): string;
+}
+export default EnsureChunkRuntimeModule;

package/dist/module/runtime/EnsureChunkRuntimeModule.js

@@ -0,0 +1,66 @@
+"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 RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const RuntimeModule_1 = __importDefault(require("../RuntimeModule"));
+class EnsureChunkRuntimeModule extends RuntimeModule_1.default {
+    constructor(runtimeRequirements) {
+        super('ensure chunk');
+        this.runtimeRequirements = runtimeRequirements;
+    }
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate } = compilation;
+        // Check if there are non initial chunks which need to be imported using require-ensure
+        if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+            const withFetchPriority = this.runtimeRequirements.has(RuntimeGlobals.hasFetchPriority);
+            const handlers = RuntimeGlobals.ensureChunkHandlers;
+            return Template_1.Template.asString([
+                `${handlers} = {};`,
+                '// This file contains only the entry chunk.',
+                '// The chunk loading function for additional chunks',
+                `${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(`chunkId${withFetchPriority ? ', fetchPriority' : ''}`, [
+                    `return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction('promises, key', [
+                        `${handlers}[key](chunkId, promises${withFetchPriority ? ', fetchPriority' : ''});`,
+                        'return promises;',
+                    ])}, []));`,
+                ])};`,
+            ]);
+        }
+        // There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
+        // function. This can happen with multiple entrypoints.
+        return Template_1.Template.asString([
+            '// The chunk loading function for additional chunks',
+            '// Since all referenced chunks are already included',
+            '// in this file, this function is empty here.',
+            `${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction('Promise.resolve()')};`,
+        ]);
+    }
+}
+exports.default = EnsureChunkRuntimeModule;

package/dist/module/runtime/GetChunkFilenameRuntimeModule.d.ts

@@ -0,0 +1,10 @@
+import RuntimeModule from '../RuntimeModule';
+declare class GetChunkFilenameRuntimeModule extends RuntimeModule {
+    contentType: string;
+    global: string;
+    getFilenameForChunk: any;
+    allChunks: boolean;
+    constructor(contentType: string, name: string, global: string, getFilenameForChunk: any, allChunks: boolean);
+    generate(): string;
+}
+export default GetChunkFilenameRuntimeModule;