xhs-mp-pack 1.1.0-beta.0

package/dist/chunk/chunkFormat/ArrayPushCallbackChunkFormatPlugin.d.ts

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

package/dist/chunk/chunkFormat/ArrayPushCallbackChunkFormatPlugin.js

@@ -0,0 +1,101 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+const StartupHelpers_1 = require("@/base/StartupHelpers");
+class ArrayPushCallbackChunkFormatPlugin {
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('ArrayPushCallbackChunkFormatPlugin', compilation => {
+            compilation.hooks.additionalChunkRuntimeRequirements.tap('ArrayPushCallbackChunkFormatPlugin', (chunk, set, { chunkGraph }) => {
+                if (chunk.hasRuntime())
+                    return;
+                if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+                    set.add(RuntimeGlobals.onChunksLoaded);
+                    set.add(RuntimeGlobals.require);
+                }
+                set.add(RuntimeGlobals.chunkCallback);
+            });
+            const hooks = JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            hooks.renderChunk.tap('ArrayPushCallbackChunkFormatPlugin', (modules, renderContext) => {
+                const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+                // const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null
+                const globalObject = runtimeTemplate.globalObject;
+                const source = new webpack_sources_1.ConcatSource();
+                const runtimeModules = chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+                // if (hotUpdateChunk) {
+                //   const hotUpdateGlobal = runtimeTemplate.outputOptions.hotUpdateGlobal
+                //   source.add(`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`)
+                //   source.add(`${JSON.stringify(chunk.id)},`)
+                //   source.add(modules)
+                //   if (runtimeModules.length > 0) {
+                //     source.add(',\n')
+                //     const runtimePart = Template.renderChunkRuntimeModules(runtimeModules, renderContext)
+                //     source.add(runtimePart)
+                //   }
+                //   source.add(')')
+                // } else {
+                const chunkLoadingGlobal = runtimeTemplate.outputOptions.chunkLoadingGlobal;
+                source.add(`(${globalObject}[${JSON.stringify(chunkLoadingGlobal)}] = ${globalObject}[${JSON.stringify(chunkLoadingGlobal)}] || []).push([`);
+                source.add(`${JSON.stringify(chunk.ids)},`);
+                source.add(modules);
+                const entries = Array.from(chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk));
+                if (runtimeModules.length > 0 || entries.length > 0) {
+                    const runtime = new webpack_sources_1.ConcatSource(`${runtimeTemplate.supportsArrowFunction()
+                        ? `${RuntimeGlobals.require} =>`
+                        : `function(${RuntimeGlobals.require})`} { // webpackRuntimeModules\n`);
+                    if (runtimeModules.length > 0) {
+                        runtime.add(Template_1.Template.renderRuntimeModules(runtimeModules, Object.assign(Object.assign({}, renderContext), { codeGenerationResults: compilation.codeGenerationResults })));
+                    }
+                    if (entries.length > 0) {
+                        const startupSource = new webpack_sources_1.RawSource((0, StartupHelpers_1.generateEntryStartup)(chunkGraph, runtimeTemplate, entries, chunk, true));
+                        runtime.add(hooks.renderStartup.call(startupSource, entries[entries.length - 1][0], Object.assign(Object.assign({}, renderContext), { inlined: false })));
+                        if (chunkGraph
+                            .getChunkRuntimeRequirements(chunk)
+                            .has(RuntimeGlobals.returnExportsFromRuntime)) {
+                            runtime.add(`return ${RuntimeGlobals.exports};\n`);
+                        }
+                    }
+                    runtime.add('}\n');
+                    source.add(',\n');
+                    source.add(new webpack_sources_1.PrefixSource('/******/ ', runtime));
+                }
+                source.add('])');
+                // }
+                return source;
+            });
+            hooks.chunkHash.tap('ArrayPushCallbackChunkFormatPlugin', (chunk, hash, { chunkGraph, runtimeTemplate }) => {
+                if (chunk.hasRuntime())
+                    return;
+                hash.update(`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`);
+                const entries = Array.from(chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk));
+                (0, StartupHelpers_1.updateHashForEntryStartup)(hash, chunkGraph, entries, chunk);
+            });
+        });
+    }
+}
+exports.default = ArrayPushCallbackChunkFormatPlugin;

package/dist/chunk/chunkLoading/JsonpChunkLoadingPlugin.d.ts

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

package/dist/chunk/chunkLoading/JsonpChunkLoadingPlugin.js

@@ -0,0 +1,98 @@
+"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 JsonpChunkLoadingRuntimeModule_1 = __importDefault(require("./JsonpChunkLoadingRuntimeModule"));
+class JsonpChunkLoadingPlugin {
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('JsonpChunkLoadingPlugin', compilation => {
+            const globalChunkLoading = compilation.outputOptions.chunkLoading;
+            const isEnabledForChunk = chunk => {
+                const options = chunk.getEntryOptions();
+                const chunkLoading = (options === null || options === void 0 ? void 0 : options.chunkLoading) !== undefined ? options.chunkLoading : globalChunkLoading;
+                return chunkLoading === 'jsonp';
+            };
+            const onceForChunkSet = new WeakSet();
+            const handler = (chunk, set) => {
+                if (onceForChunkSet.has(chunk))
+                    return;
+                onceForChunkSet.add(chunk);
+                if (!isEnabledForChunk(chunk))
+                    return;
+                set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+                set.add(RuntimeGlobals.hasOwnProperty);
+                compilation.addRuntimeModule(chunk, new JsonpChunkLoadingRuntimeModule_1.default(set));
+            };
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.ensureChunkHandlers)
+                .tap('JsonpChunkLoadingPlugin', handler);
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+                .tap('JsonpChunkLoadingPlugin', handler);
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.hmrDownloadManifest)
+                .tap('JsonpChunkLoadingPlugin', handler);
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.baseURI)
+                .tap('JsonpChunkLoadingPlugin', handler);
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.onChunksLoaded)
+                .tap('JsonpChunkLoadingPlugin', handler);
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.ensureChunkHandlers)
+                .tap('JsonpChunkLoadingPlugin', (chunk, set) => {
+                if (!isEnabledForChunk(chunk))
+                    return;
+                set.add(RuntimeGlobals.publicPath);
+                set.add(RuntimeGlobals.loadScript);
+                set.add(RuntimeGlobals.getChunkScriptFilename);
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+                .tap('JsonpChunkLoadingPlugin', (chunk, set) => {
+                if (!isEnabledForChunk(chunk))
+                    return;
+                set.add(RuntimeGlobals.publicPath);
+                set.add(RuntimeGlobals.loadScript);
+                set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+                set.add(RuntimeGlobals.moduleCache);
+                set.add(RuntimeGlobals.hmrModuleData);
+                set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.hmrDownloadManifest)
+                .tap('JsonpChunkLoadingPlugin', (chunk, set) => {
+                if (!isEnabledForChunk(chunk))
+                    return;
+                set.add(RuntimeGlobals.publicPath);
+                set.add(RuntimeGlobals.getUpdateManifestFilename);
+            });
+        });
+    }
+}
+exports.default = JsonpChunkLoadingPlugin;

package/dist/chunk/chunkLoading/JsonpChunkLoadingRuntimeModule.d.ts

@@ -0,0 +1,15 @@
+import RuntimeModule from '@/module/RuntimeModule';
+declare class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
+    _runtimeRequirements: any;
+    compilation: any;
+    chunkGraph: any;
+    chunk: any;
+    static getCompilationHooks(compilation: any): any;
+    constructor(runtimeRequirements: Set<string>);
+    _generateBaseUri(chunk: any): string;
+    /**
+     * @returns {string | null} runtime code
+     */
+    generate(): string;
+}
+export default JsonpChunkLoadingRuntimeModule;

package/dist/chunk/chunkLoading/JsonpChunkLoadingRuntimeModule.js

@@ -0,0 +1,272 @@
+"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 tapable_1 = require("tapable");
+const Compilation_1 = __importDefault(require("@/Compilation"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const RuntimeModule_1 = __importDefault(require("@/module/RuntimeModule"));
+const Template_1 = require("@/template/Template");
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+const StartupHelpers_1 = require("@/base/StartupHelpers");
+const compileBooleanMatcher_1 = __importDefault(require("@/base/compileBooleanMatcher"));
+const compilationHooksMap = new WeakMap();
+class JsonpChunkLoadingRuntimeModule extends RuntimeModule_1.default {
+    static getCompilationHooks(compilation) {
+        if (!(compilation instanceof Compilation_1.default)) {
+            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
+        }
+        let hooks = compilationHooksMap.get(compilation);
+        if (hooks === undefined) {
+            hooks = {
+                linkPreload: new tapable_1.SyncWaterfallHook(['source', 'chunk']),
+                linkPrefetch: new tapable_1.SyncWaterfallHook(['source', 'chunk']),
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+    constructor(runtimeRequirements) {
+        super('jsonp chunk loading', RuntimeModule_1.default.STAGE_ATTACH);
+        this._runtimeRequirements = runtimeRequirements;
+    }
+    _generateBaseUri(chunk) {
+        const options = chunk.getEntryOptions();
+        if (options === null || options === void 0 ? void 0 : options.baseUri) {
+            return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
+        }
+        return `${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`;
+    }
+    /**
+     * @returns {string | null} runtime code
+     */
+    generate() {
+        const compilation = this.compilation;
+        const { runtimeTemplate, outputOptions: { chunkLoadingGlobal, hotUpdateGlobal, crossOriginLoading, scriptType }, } = compilation;
+        const globalObject = runtimeTemplate.globalObject;
+        const { linkPreload, linkPrefetch } = JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
+        const fn = RuntimeGlobals.ensureChunkHandlers;
+        const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+        const withLoading = this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers);
+        const withCallback = this._runtimeRequirements.has(RuntimeGlobals.chunkCallback);
+        const withOnChunkLoad = this._runtimeRequirements.has(RuntimeGlobals.onChunksLoaded);
+        const withHmr = this._runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers);
+        const withHmrManifest = this._runtimeRequirements.has(RuntimeGlobals.hmrDownloadManifest);
+        const withPrefetch = this._runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers);
+        const withPreload = this._runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers);
+        const withFetchPriority = this._runtimeRequirements.has(RuntimeGlobals.hasFetchPriority);
+        const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(chunkLoadingGlobal)}]`;
+        const chunkGraph = this.chunkGraph;
+        const chunk = this.chunk;
+        const conditionMap = chunkGraph.getChunkConditionMap(chunk, JavascriptModulesPlugin_1.chunkHasJs);
+        const hasJsMatcher = (0, compileBooleanMatcher_1.default)(conditionMap);
+        const initialChunkIds = (0, StartupHelpers_1.getInitialChunkIds)(chunk, chunkGraph, JavascriptModulesPlugin_1.chunkHasJs);
+        const stateExpression = withHmr ? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp` : undefined;
+        return Template_1.Template.asString([
+            withBaseURI ? this._generateBaseUri(chunk) : '// no baseURI',
+            '',
+            '// object to store loaded and loading chunks',
+            '// undefined = chunk not loaded, null = chunk preloaded/prefetched',
+            '// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded',
+            `var installedChunks = ${stateExpression ? `${stateExpression} = ${stateExpression} || ` : ''}{`,
+            Template_1.Template.indent(Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(',\n')),
+            '};',
+            '',
+            withLoading
+                ? Template_1.Template.asString([
+                    `${fn}.j = ${runtimeTemplate.basicFunction(`chunkId, promises${withFetchPriority ? ', fetchPriority' : ''}`, hasJsMatcher !== false
+                        ? Template_1.Template.indent([
+                            '// JSONP chunk loading for javascript',
+                            `var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+                            'if(installedChunkData !== 0) { // 0 means "already installed".',
+                            Template_1.Template.indent([
+                                '',
+                                '// a Promise means "currently loading".',
+                                'if(installedChunkData) {',
+                                Template_1.Template.indent(['promises.push(installedChunkData[2]);']),
+                                '} else {',
+                                Template_1.Template.indent([
+                                    hasJsMatcher === true
+                                        ? 'if(true) { // all chunks have JS'
+                                        : `if(${hasJsMatcher('chunkId')}) {`,
+                                    Template_1.Template.indent([
+                                        '// setup Promise in chunk cache',
+                                        `var promise = new Promise(${runtimeTemplate.expressionFunction(`installedChunkData = installedChunks[chunkId] = [resolve, reject]`, 'resolve, reject')});`,
+                                        'promises.push(installedChunkData[2] = promise);',
+                                        '',
+                                        '// start chunk loading',
+                                        `var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+                                        '// create error before stack unwound to get useful stacktrace later',
+                                        'var error = new Error();',
+                                        `var loadingEnded = ${runtimeTemplate.basicFunction('event', [
+                                            `if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
+                                            Template_1.Template.indent([
+                                                'installedChunkData = installedChunks[chunkId];',
+                                                'if(installedChunkData !== 0) installedChunks[chunkId] = undefined;',
+                                                'if(installedChunkData) {',
+                                                Template_1.Template.indent([
+                                                    "var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+                                                    'var realSrc = event && event.target && event.target.src;',
+                                                    "error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+                                                    "error.name = 'ChunkLoadError';",
+                                                    'error.type = errorType;',
+                                                    'error.request = realSrc;',
+                                                    'installedChunkData[1](error);',
+                                                ]),
+                                                '}',
+                                            ]),
+                                            '}',
+                                        ])};`,
+                                        `${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId${withFetchPriority ? ', fetchPriority' : ''});`,
+                                    ]),
+                                    hasJsMatcher === true ? '}' : '} else installedChunks[chunkId] = 0;',
+                                ]),
+                                '}',
+                            ]),
+                            '}',
+                        ])
+                        : Template_1.Template.indent(['installedChunks[chunkId] = 0;']))};`,
+                ])
+                : '// no chunk on demand loading',
+            '',
+            withPrefetch && hasJsMatcher !== false
+                ? `${RuntimeGlobals.prefetchChunkHandlers}.j = ${runtimeTemplate.basicFunction('chunkId', [
+                    `if((!${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${hasJsMatcher === true ? 'true' : hasJsMatcher('chunkId')}) {`,
+                    Template_1.Template.indent([
+                        'installedChunks[chunkId] = null;',
+                        linkPrefetch.call(Template_1.Template.asString([
+                            "var link = document.createElement('link');",
+                            crossOriginLoading
+                                ? `link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+                                : '',
+                            `if (${RuntimeGlobals.scriptNonce}) {`,
+                            Template_1.Template.indent(`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`),
+                            '}',
+                            'link.rel = "prefetch";',
+                            'link.as = "script";',
+                            `link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+                        ]), chunk),
+                        'document.head.appendChild(link);',
+                    ]),
+                    '}',
+                ])};`
+                : '// no prefetching',
+            '',
+            withPreload && hasJsMatcher !== false
+                ? `${RuntimeGlobals.preloadChunkHandlers}.j = ${runtimeTemplate.basicFunction('chunkId', [
+                    `if((!${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${hasJsMatcher === true ? 'true' : hasJsMatcher('chunkId')}) {`,
+                    Template_1.Template.indent([
+                        'installedChunks[chunkId] = null;',
+                        linkPreload.call(Template_1.Template.asString([
+                            "var link = document.createElement('link');",
+                            scriptType && scriptType !== 'module'
+                                ? `link.type = ${JSON.stringify(scriptType)};`
+                                : '',
+                            "link.charset = 'utf-8';",
+                            `if (${RuntimeGlobals.scriptNonce}) {`,
+                            Template_1.Template.indent(`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`),
+                            '}',
+                            scriptType === 'module' ? 'link.rel = "modulepreload";' : 'link.rel = "preload";',
+                            scriptType === 'module' ? '' : 'link.as = "script";',
+                            `link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+                            crossOriginLoading
+                                ? crossOriginLoading === 'use-credentials'
+                                    ? 'link.crossOrigin = "use-credentials";'
+                                    : Template_1.Template.asString([
+                                        "if (link.href.indexOf(window.location.origin + '/') !== 0) {",
+                                        Template_1.Template.indent(`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`),
+                                        '}',
+                                    ])
+                                : '',
+                        ]), chunk),
+                        'document.head.appendChild(link);',
+                    ]),
+                    '}',
+                ])};`
+                : '// no preloaded',
+            '',
+            '// no HMR',
+            '',
+            withHmrManifest
+                ? Template_1.Template.asString([
+                    `${RuntimeGlobals.hmrDownloadManifest} = ${runtimeTemplate.basicFunction('', [
+                        'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
+                        `return fetch(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getUpdateManifestFilename}()).then(${runtimeTemplate.basicFunction('response', [
+                            'if(response.status === 404) return; // no update available',
+                            'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
+                            'return response.json();',
+                        ])});`,
+                    ])};`,
+                ])
+                : '// no HMR manifest',
+            '',
+            withOnChunkLoad
+                ? `${RuntimeGlobals.onChunksLoaded}.j = ${runtimeTemplate.returningFunction('installedChunks[chunkId] === 0', 'chunkId')};`
+                : '// no on chunks loaded',
+            '',
+            withCallback || withLoading
+                ? Template_1.Template.asString([
+                    '// install a JSONP callback for chunk loading',
+                    `var webpackJsonpCallback = ${runtimeTemplate.basicFunction('parentChunkLoadingFunction, data', [
+                        runtimeTemplate.destructureArray(['chunkIds', 'moreModules', 'runtime'], 'data'),
+                        '// add "moreModules" to the modules object,',
+                        '// then flag all "chunkIds" as loaded and fire callback',
+                        'var moduleId, chunkId, i = 0;',
+                        `if(chunkIds.some(${runtimeTemplate.returningFunction('installedChunks[id] !== 0', 'id')})) {`,
+                        Template_1.Template.indent([
+                            'for(moduleId in moreModules) {',
+                            Template_1.Template.indent([
+                                `if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+                                Template_1.Template.indent(`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`),
+                                '}',
+                            ]),
+                            '}',
+                            `if(runtime) var result = runtime(${RuntimeGlobals.require});`,
+                        ]),
+                        '}',
+                        'if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);',
+                        'for(;i < chunkIds.length; i++) {',
+                        Template_1.Template.indent([
+                            'chunkId = chunkIds[i];',
+                            `if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+                            Template_1.Template.indent('installedChunks[chunkId][0]();'),
+                            '}',
+                            'installedChunks[chunkId] = 0;',
+                        ]),
+                        '}',
+                        withOnChunkLoad ? `return ${RuntimeGlobals.onChunksLoaded}(result);` : '',
+                    ])}`,
+                    '',
+                    `var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+                    'chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));',
+                    'chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));',
+                ])
+                : '// no jsonp function',
+        ]);
+    }
+}
+exports.default = JsonpChunkLoadingRuntimeModule;

package/dist/dependencies/AsyncDependenciesBlock.d.ts

@@ -0,0 +1,14 @@
+import DependenciesBlock from './DependenciesBlock';
+declare class AsyncDependenciesBlock extends DependenciesBlock {
+    groupOptions: any;
+    loc: any;
+    request: string | undefined;
+    _stringifiedGroupOptions: any;
+    constructor(groupOptions: any, loc?: any, request?: string);
+    get chunkName(): any;
+    set chunkName(value: any);
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default AsyncDependenciesBlock;

package/dist/dependencies/AsyncDependenciesBlock.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const DependenciesBlock_1 = __importDefault(require("./DependenciesBlock"));
+class AsyncDependenciesBlock extends DependenciesBlock_1.default {
+    constructor(groupOptions, loc, request) {
+        super();
+        if (typeof groupOptions === 'string') {
+            groupOptions = { name: groupOptions };
+        }
+        else if (!groupOptions) {
+            groupOptions = { name: undefined };
+        }
+        this.groupOptions = groupOptions;
+        this.loc = loc;
+        this.request = request;
+        this._stringifiedGroupOptions = undefined;
+    }
+    get chunkName() {
+        return this.groupOptions.name;
+    }
+    set chunkName(value) {
+        if (this.groupOptions.name !== value) {
+            this.groupOptions.name = value;
+            this._stringifiedGroupOptions = undefined;
+        }
+    }
+    updateHash(hash, context) {
+        const { chunkGraph } = context;
+        if (this._stringifiedGroupOptions === undefined) {
+            this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+        }
+        const chunkGroup = chunkGraph.getBlockChunkGroup(this);
+        hash.update(`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ''}`);
+        super.updateHash(hash, context);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.groupOptions);
+        write(this.loc);
+        write(this.request);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.groupOptions = read();
+        this.loc = read();
+        this.request = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(AsyncDependenciesBlock, 'mp-compiler/core/dependencies/AsyncDependenciesBlock');
+Object.defineProperty(AsyncDependenciesBlock.prototype, 'module', {
+    get() {
+        throw new Error("module property was removed from AsyncDependenciesBlock (it's not needed)");
+    },
+    set() {
+        throw new Error("module property was removed from AsyncDependenciesBlock (it's not needed)");
+    },
+});
+exports.default = AsyncDependenciesBlock;

package/dist/dependencies/CreateScriptUrlDependency.d.ts

@@ -0,0 +1,9 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class CreateScriptUrlDependency extends NullDependency {
+    range: any;
+    constructor(range: any);
+    get type(): string;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CreateScriptUrlDependency;

package/dist/dependencies/CreateScriptUrlDependency.js

@@ -0,0 +1,60 @@
+"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 makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const RuntimeGlobals = __importStar(require("../module/RuntimeGlobals"));
+class CreateScriptUrlDependency extends NullDependency_1.default {
+    constructor(range) {
+        super();
+        this.range = range;
+    }
+    get type() {
+        return 'create script url';
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        super.deserialize(context);
+    }
+}
+CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { runtimeRequirements }) {
+        const dep = dependency;
+        runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+        source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
+        source.insert(dep.range[1], ')');
+    }
+};
+(0, makeSerializable_1.default)(CreateScriptUrlDependency, 'mp-compiler/core/dependencies/CreateScriptUrlDependency');
+exports.default = CreateScriptUrlDependency;