xhs-mp-pack 1.1.0-beta.0

package/dist/module/javascript/JavascriptModulesPlugin.js

@@ -0,0 +1,821 @@
+"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 });
+exports.JavascriptModulesPlugin = exports.chunkHasJs = void 0;
+const tapable_1 = require("tapable");
+const vm_1 = __importDefault(require("vm"));
+const webpack_sources_1 = require("webpack-sources");
+const Compilation_1 = __importDefault(require("@/Compilation"));
+const HookBaseError_1 = require("@/base/errors/HookBaseError");
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const IterableHelpers_1 = require("@/base/IterableHelpers");
+const StringXor_1 = __importDefault(require("@/base/StringXor"));
+const comparators_1 = require("@/base/comparators");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const nonNumericOnlyHash_1 = __importDefault(require("@/base/nonNumericOnlyHash"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const JavascriptGenerator_1 = __importDefault(require("@/module/javascript/JavascriptGenerator"));
+const JavascriptParser_1 = require("@/module/javascript/JavascriptParser");
+const chunkHasJs = (chunk, chunkGraph) => {
+    if (chunkGraph.getNumberOfEntryModules(chunk) > 0)
+        return true;
+    return !!chunkGraph.getChunkModulesIterableBySourceType(chunk, 'javascript');
+};
+exports.chunkHasJs = chunkHasJs;
+const printGeneratedCodeForStack = (module, code) => {
+    const lines = code.split('\n');
+    const n = `${lines.length}`.length;
+    return `\n\nGenerated code for ${module.identifier()}\n${lines
+        .map((line, i, lines) => {
+        const iStr = `${i + 1}`;
+        return `${' '.repeat(n - iStr.length)}${iStr} | ${line}`;
+    })
+        .join('\n')}`;
+};
+const compilationHooksMap = new WeakMap();
+const PLUGIN_NAME = 'JavascriptModulesPlugin';
+class JavascriptModulesPlugin {
+    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 = {
+                renderModuleContent: new tapable_1.SyncWaterfallHook(['source', 'module', 'renderContext']),
+                renderModuleContainer: new tapable_1.SyncWaterfallHook([
+                    'source',
+                    'module',
+                    'renderContext',
+                ]),
+                renderModulePackage: new tapable_1.SyncWaterfallHook(['source', 'module', 'renderContext']),
+                render: new tapable_1.SyncWaterfallHook(['source', 'renderContext']),
+                renderContent: new tapable_1.SyncWaterfallHook(['source', 'renderContext']),
+                renderStartup: new tapable_1.SyncWaterfallHook([
+                    'source',
+                    'module',
+                    'startupRenderContext',
+                ]),
+                renderChunk: new tapable_1.SyncWaterfallHook(['source', 'renderContext']),
+                renderMain: new tapable_1.SyncWaterfallHook(['source', 'renderContext']),
+                renderRequire: new tapable_1.SyncWaterfallHook(['code', 'renderContext']),
+                inlineInRuntimeBailout: new tapable_1.SyncBailHook(['module', 'renderContext']),
+                embedInRuntimeBailout: new tapable_1.SyncBailHook(['module', 'renderContext']),
+                strictRuntimeBailout: new tapable_1.SyncBailHook(['renderContext']),
+                chunkHash: new tapable_1.SyncHook(['chunk', 'hash', 'context']),
+                useSourceMap: new tapable_1.SyncBailHook(['chunk', 'renderContext']),
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+    constructor(options = {}) {
+        this.options = options;
+        this._moduleFactoryCache = new WeakMap();
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO)
+                .tap(PLUGIN_NAME, options => new JavascriptParser_1.JavascriptParser('auto'));
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+                .tap(PLUGIN_NAME, options => new JavascriptParser_1.JavascriptParser('script'));
+            normalModuleFactory.hooks.createParser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM)
+                .tap(PLUGIN_NAME, options => new JavascriptParser_1.JavascriptParser('module'));
+            normalModuleFactory.hooks.createGenerator
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO)
+                .tap(PLUGIN_NAME, () => new JavascriptGenerator_1.default());
+            normalModuleFactory.hooks.createGenerator
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+                .tap(PLUGIN_NAME, () => new JavascriptGenerator_1.default());
+            normalModuleFactory.hooks.createGenerator
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM)
+                .tap(PLUGIN_NAME, () => new JavascriptGenerator_1.default());
+            compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+                const { hash, chunk, chunkGraph, moduleGraph, runtimeTemplate, dependencyTemplates, outputOptions, codeGenerationResults, } = options;
+                let render;
+                const filenameTemplate = JavascriptModulesPlugin.getChunkFilenameTemplate(chunk, outputOptions);
+                if (chunk.hasRuntime()) {
+                    render = () => this.renderMain({
+                        hash,
+                        chunk,
+                        dependencyTemplates,
+                        runtimeTemplate,
+                        moduleGraph,
+                        chunkGraph,
+                        codeGenerationResults,
+                        strictMode: runtimeTemplate.isModule(),
+                    }, hooks, compilation);
+                }
+                else {
+                    if (!chunkHasJs(chunk, chunkGraph)) {
+                        return result;
+                    }
+                    render = () => this.renderChunk({
+                        chunk,
+                        dependencyTemplates,
+                        runtimeTemplate,
+                        moduleGraph,
+                        chunkGraph,
+                        codeGenerationResults,
+                        strictMode: runtimeTemplate.isModule(),
+                    }, hooks);
+                }
+                result.push({
+                    render,
+                    filenameTemplate,
+                    pathOptions: {
+                        hash,
+                        runtime: chunk.runtime,
+                        chunk,
+                        contentHashType: 'javascript',
+                    },
+                    info: {
+                        javascriptModule: compilation.runtimeTemplate.isModule(),
+                    },
+                    identifier: `chunk${chunk.id}`,
+                    hash: chunk.contentHash.javascript,
+                });
+                return result;
+            });
+            compilation.hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, context) => {
+                hooks.chunkHash.call(chunk, hash, context);
+                if (chunk.hasRuntime()) {
+                    this.updateHashWithBootstrap(hash, {
+                        hash: '0000',
+                        chunk,
+                        codeGenerationResults: context.codeGenerationResults,
+                        chunkGraph: context.chunkGraph,
+                        moduleGraph: context.moduleGraph,
+                        runtimeTemplate: context.runtimeTemplate,
+                    }, hooks);
+                }
+            });
+            compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
+                const { chunkGraph, codeGenerationResults, moduleGraph, runtimeTemplate, outputOptions: { hashSalt, hashDigest, hashDigestLength, hashFunction }, } = compilation;
+                const hash = (0, createHash_1.default)(hashFunction);
+                if (hashSalt)
+                    hash.update(hashSalt);
+                if (chunk.hasRuntime()) {
+                    this.updateHashWithBootstrap(hash, {
+                        hash: '0000',
+                        chunk,
+                        codeGenerationResults,
+                        chunkGraph: compilation.chunkGraph,
+                        moduleGraph: compilation.moduleGraph,
+                        runtimeTemplate: compilation.runtimeTemplate,
+                    }, hooks);
+                }
+                else {
+                    hash.update(`${chunk.id} `);
+                    hash.update(chunk.ids ? chunk.ids.join(',') : '');
+                }
+                hooks.chunkHash.call(chunk, hash, {
+                    chunkGraph,
+                    codeGenerationResults,
+                    moduleGraph,
+                    runtimeTemplate,
+                });
+                const modules = chunkGraph.getChunkModulesIterableBySourceType(chunk, 'javascript');
+                if (modules) {
+                    const xor = new StringXor_1.default();
+                    for (const m of modules) {
+                        xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+                    }
+                    xor.updateHash(hash);
+                }
+                const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(chunk, ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME);
+                if (runtimeModules) {
+                    const xor = new StringXor_1.default();
+                    for (const m of runtimeModules) {
+                        xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+                    }
+                    xor.updateHash(hash);
+                }
+                const digest = hash.digest(hashDigest);
+                chunk.contentHash.javascript = (0, nonNumericOnlyHash_1.default)(digest, hashDigestLength);
+            });
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+                if (!set.has(RuntimeGlobals.startupNoDefault) &&
+                    chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+                    set.add(RuntimeGlobals.onChunksLoaded);
+                    set.add(RuntimeGlobals.require);
+                }
+            });
+            compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+                const source = options.codeGenerationResult.sources.get('javascript');
+                if (source === undefined)
+                    return;
+                const { module, moduleObject } = options;
+                const code = source.source();
+                const fn = vm_1.default.runInThisContext(`(function(${module.moduleArgument}, ${module.exportsArgument}, ${RuntimeGlobals.require}) {\n${code}\n/**/})`, {
+                    filename: module.identifier(),
+                    lineOffset: -1,
+                });
+                try {
+                    fn.call(moduleObject.exports, moduleObject, moduleObject.exports, context.__webpack_require__);
+                }
+                catch (e) {
+                    e.stack += printGeneratedCodeForStack(options.module, code);
+                    throw e;
+                }
+            });
+            compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+                const source = options.codeGenerationResult.sources.get('runtime');
+                if (source === undefined)
+                    return;
+                let code = source.source();
+                if (typeof code !== 'string')
+                    code = code.toString();
+                const fn = vm_1.default.runInThisContext(`(function(${RuntimeGlobals.require}) {\n${code}\n/**/})`, {
+                    filename: options.module.identifier(),
+                    lineOffset: -1,
+                });
+                try {
+                    fn.call(null, context.__webpack_require__);
+                }
+                catch (e) {
+                    e.stack += printGeneratedCodeForStack(options.module, code);
+                    throw e;
+                }
+            });
+        });
+    }
+    static getChunkFilenameTemplate(chunk, outputOptions) {
+        if (chunk.filenameTemplate) {
+            return chunk.filenameTemplate;
+        }
+        if (chunk.canBeInitial()) {
+            return outputOptions.filename;
+        }
+        return outputOptions.chunkFilename;
+    }
+    renderModule(module, renderContext, hooks, factory) {
+        const { chunk, chunkGraph, runtimeTemplate, codeGenerationResults, strictMode } = renderContext;
+        try {
+            const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+            const moduleSource = codeGenResult.sources.get('javascript');
+            if (!moduleSource)
+                return null;
+            if (codeGenResult.data !== undefined) {
+                const chunkInitFragments = codeGenResult.data.get('chunkInitFragments');
+                if (chunkInitFragments) {
+                    for (const i of chunkInitFragments)
+                        renderContext.chunkInitFragments.push(i);
+                }
+            }
+            const moduleSourcePostContent = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderModuleContent.call(moduleSource, module, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderModuleContent');
+            let moduleSourcePostContainer;
+            if (factory) {
+                const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime);
+                const needModule = runtimeRequirements.has(RuntimeGlobals.module);
+                const needExports = runtimeRequirements.has(RuntimeGlobals.exports);
+                const needRequire = runtimeRequirements.has(RuntimeGlobals.require) ||
+                    runtimeRequirements.has(RuntimeGlobals.requireScope);
+                const needThisAsExports = runtimeRequirements.has(RuntimeGlobals.thisAsExports);
+                const needStrict = module.buildInfo.strict && !strictMode;
+                const cacheEntry = this._moduleFactoryCache.get(moduleSourcePostContent);
+                let source;
+                if (cacheEntry &&
+                    cacheEntry.needModule === needModule &&
+                    cacheEntry.needExports === needExports &&
+                    cacheEntry.needRequire === needRequire &&
+                    cacheEntry.needThisAsExports === needThisAsExports &&
+                    cacheEntry.needStrict === needStrict) {
+                    source = cacheEntry.source;
+                }
+                else {
+                    const factorySource = new webpack_sources_1.ConcatSource();
+                    const args = [];
+                    if (needExports || needRequire || needModule)
+                        args.push(needModule ? module.moduleArgument : `__unused_webpack_${module.moduleArgument}`);
+                    if (needExports || needRequire)
+                        args.push(needExports ? module.exportsArgument : `__unused_webpack_${module.exportsArgument}`);
+                    if (needRequire)
+                        args.push(RuntimeGlobals.require);
+                    if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
+                        factorySource.add(`/***/ ((${args.join(', ')}) => {\n\n`);
+                    }
+                    else {
+                        factorySource.add(`/***/ (function(${args.join(', ')}) {\n\n`);
+                    }
+                    if (needStrict) {
+                        factorySource.add('"use strict";\n');
+                    }
+                    factorySource.add(moduleSourcePostContent);
+                    factorySource.add('\n\n/***/ })');
+                    source = new webpack_sources_1.CachedSource(factorySource);
+                    this._moduleFactoryCache.set(moduleSourcePostContent, {
+                        source,
+                        needModule,
+                        needExports,
+                        needRequire,
+                        needThisAsExports,
+                        needStrict,
+                    });
+                }
+                moduleSourcePostContainer = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderModuleContainer.call(source, module, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer');
+            }
+            else {
+                moduleSourcePostContainer = moduleSourcePostContent;
+            }
+            return (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderModulePackage.call(moduleSourcePostContainer, module, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderModulePackage');
+        }
+        catch (e) {
+            e.module = module;
+            throw e;
+        }
+    }
+    renderChunk(renderContext, hooks) {
+        const { chunk, chunkGraph } = renderContext;
+        const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(chunk, 'javascript', comparators_1.compareModulesByIdentifier);
+        const allModules = modules ? Array.from(modules) : [];
+        let strictHeader;
+        let allStrict = renderContext.strictMode;
+        if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+            const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+            strictHeader = strictBailout
+                ? `// runtime can't be in strict mode because ${strictBailout}.\n`
+                : '"use strict";\n';
+            if (!strictBailout)
+                allStrict = true;
+        }
+        const chunkRenderContext = Object.assign(Object.assign({}, renderContext), { chunkInitFragments: [], strictMode: allStrict });
+        const moduleSources = Template_1.Template.renderChunkModules(chunkRenderContext, allModules, module => this.renderModule(module, chunkRenderContext, hooks, true)) || new webpack_sources_1.RawSource('{}');
+        let source = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderChunk.call(moduleSources, chunkRenderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderChunk');
+        source = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderContent.call(source, chunkRenderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderContent');
+        if (!source) {
+            throw new Error('JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something');
+        }
+        source = InitFragment_1.default.addToSource(source, chunkRenderContext.chunkInitFragments, chunkRenderContext);
+        source = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.render.call(source, chunkRenderContext), 'JavascriptModulesPlugin.getCompilationHooks().render');
+        if (!source) {
+            throw new Error('JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something');
+        }
+        chunk.rendered = true;
+        return strictHeader
+            ? new webpack_sources_1.ConcatSource(strictHeader, source, ';')
+            : renderContext.runtimeTemplate.isModule()
+                ? source
+                : new webpack_sources_1.ConcatSource(source, ';');
+    }
+    renderMain(renderContext, hooks, compilation) {
+        const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+        const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+        const iife = runtimeTemplate.isIIFE();
+        const bootstrap = this.renderBootstrap(renderContext, hooks);
+        const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
+        const allModules = Array.from(chunkGraph.getOrderedChunkModulesIterableBySourceType(chunk, 'javascript', comparators_1.compareModulesByIdentifier) || []);
+        const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
+        let inlinedModules;
+        if (bootstrap.allowInlineStartup && hasEntryModules) {
+            inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
+        }
+        const source = new webpack_sources_1.ConcatSource();
+        let prefix;
+        if (iife) {
+            if (runtimeTemplate.supportsArrowFunction()) {
+                source.add('/******/ (() => { // webpackBootstrap\n');
+            }
+            else {
+                source.add('/******/ (function() { // webpackBootstrap\n');
+            }
+            prefix = '/******/ \t';
+        }
+        else {
+            prefix = '/******/ ';
+        }
+        let allStrict = renderContext.strictMode;
+        if (!allStrict && allModules.every((m) => m.buildInfo.strict)) {
+            const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+            if (strictBailout) {
+                source.add(`${prefix}// runtime can't be in strict mode because ${strictBailout}.\n`);
+            }
+            else {
+                allStrict = true;
+                source.add(`${prefix}"use strict";\n`);
+            }
+        }
+        const chunkRenderContext = Object.assign(Object.assign({}, renderContext), { chunkInitFragments: [], strictMode: allStrict });
+        const chunkModules = Template_1.Template.renderChunkModules(chunkRenderContext, (inlinedModules ? allModules.filter(m => !inlinedModules.has(m)) : allModules), module => this.renderModule(module, chunkRenderContext, hooks, true), prefix);
+        if (chunkModules ||
+            runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
+            runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
+            runtimeRequirements.has(RuntimeGlobals.require)) {
+            source.add(`${prefix}var __webpack_modules__ = (`);
+            source.add(chunkModules || '{}');
+            source.add(');\n');
+            source.add('/************************************************************************/\n');
+        }
+        if (bootstrap.header.length > 0) {
+            const header = `${Template_1.Template.asString(bootstrap.header)}\n`;
+            source.add(new webpack_sources_1.PrefixSource(prefix, useSourceMap ? new webpack_sources_1.OriginalSource(header, 'webpack/bootstrap') : new webpack_sources_1.RawSource(header)));
+            source.add('/************************************************************************/\n');
+        }
+        const runtimeModules = renderContext.chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+        if (runtimeModules.length > 0) {
+            source.add(new webpack_sources_1.PrefixSource(prefix, Template_1.Template.renderRuntimeModules(runtimeModules, chunkRenderContext)));
+            source.add('/************************************************************************/\n');
+            // runtimeRuntimeModules calls codeGeneration
+            for (const module of runtimeModules) {
+                compilation.codeGeneratedModules.add(module);
+            }
+        }
+        if (inlinedModules) {
+            if (bootstrap.beforeStartup.length > 0) {
+                const beforeStartup = `${Template_1.Template.asString(bootstrap.beforeStartup)}\n`;
+                source.add(new webpack_sources_1.PrefixSource(prefix, useSourceMap
+                    ? new webpack_sources_1.OriginalSource(beforeStartup, 'webpack/before-startup')
+                    : new webpack_sources_1.RawSource(beforeStartup)));
+            }
+            const lastInlinedModule = (0, IterableHelpers_1.last)(inlinedModules);
+            const startupSource = new webpack_sources_1.ConcatSource();
+            startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
+            for (const m of inlinedModules) {
+                const renderedModule = this.renderModule(m, chunkRenderContext, hooks, false);
+                if (renderedModule) {
+                    const innerStrict = !allStrict && m.buildInfo.strict;
+                    const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(m, chunk.runtime);
+                    const exports = runtimeRequirements.has(RuntimeGlobals.exports);
+                    const webpackExports = exports && m.exportsArgument === RuntimeGlobals.exports;
+                    const iife = innerStrict
+                        ? 'it need to be in strict mode.'
+                        : inlinedModules.size > 1
+                            ? // TODO check globals and top-level declarations of other entries and chunk modules
+                                // to make a better decision
+                                'it need to be isolated against other entry modules.'
+                            : chunkModules
+                                ? 'it need to be isolated against other modules in the chunk.'
+                                : exports && !webpackExports
+                                    ? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+                                    : hooks.embedInRuntimeBailout.call(m, renderContext);
+                    let footer;
+                    if (iife !== undefined) {
+                        startupSource.add(`// This entry need to be wrapped in an IIFE because ${iife}\n`);
+                        const arrow = runtimeTemplate.supportsArrowFunction();
+                        if (arrow) {
+                            startupSource.add('(() => {\n');
+                            footer = '\n})();\n\n';
+                        }
+                        else {
+                            startupSource.add('!function() {\n');
+                            footer = '\n}();\n';
+                        }
+                        if (innerStrict)
+                            startupSource.add('"use strict";\n');
+                    }
+                    else {
+                        footer = '\n';
+                    }
+                    if (exports) {
+                        if (m !== lastInlinedModule)
+                            startupSource.add(`var ${m.exportsArgument} = {};\n`);
+                        else if (m.exportsArgument !== RuntimeGlobals.exports)
+                            startupSource.add(`var ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`);
+                    }
+                    startupSource.add(renderedModule);
+                    startupSource.add(footer);
+                }
+            }
+            if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+                startupSource.add(`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});\n`);
+            }
+            source.add(hooks.renderStartup.call(startupSource, lastInlinedModule, Object.assign(Object.assign({}, renderContext), { inlined: true })));
+            if (bootstrap.afterStartup.length > 0) {
+                const afterStartup = `${Template_1.Template.asString(bootstrap.afterStartup)}\n`;
+                source.add(new webpack_sources_1.PrefixSource(prefix, useSourceMap
+                    ? new webpack_sources_1.OriginalSource(afterStartup, 'webpack/after-startup')
+                    : new webpack_sources_1.RawSource(afterStartup)));
+            }
+        }
+        else {
+            const lastEntryModule = (0, IterableHelpers_1.last)(chunkGraph.getChunkEntryModulesIterable(chunk));
+            const toSource = useSourceMap
+                ? (content, name) => new webpack_sources_1.OriginalSource(Template_1.Template.asString(content), name)
+                : content => new webpack_sources_1.RawSource(Template_1.Template.asString(content));
+            source.add(new webpack_sources_1.PrefixSource(prefix, new webpack_sources_1.ConcatSource(toSource(bootstrap.beforeStartup, 'webpack/before-startup'), '\n', hooks.renderStartup.call(toSource(bootstrap.startup.concat(''), 'webpack/startup'), lastEntryModule, Object.assign(Object.assign({}, renderContext), { inlined: false })), toSource(bootstrap.afterStartup, 'webpack/after-startup'), '\n')));
+        }
+        if (hasEntryModules && runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)) {
+            source.add(`${prefix}return ${RuntimeGlobals.exports};\n`);
+        }
+        if (iife) {
+            source.add('/******/ })()\n');
+        }
+        let finalSource = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderMain.call(source, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderMain');
+        if (!finalSource) {
+            throw new Error('JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something');
+        }
+        finalSource = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderContent.call(finalSource, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderContent');
+        if (!finalSource) {
+            throw new Error('JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something');
+        }
+        finalSource = InitFragment_1.default.addToSource(finalSource, chunkRenderContext.chunkInitFragments, chunkRenderContext);
+        finalSource = (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.render.call(finalSource, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().render');
+        if (!finalSource) {
+            throw new Error('JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something');
+        }
+        chunk.rendered = true;
+        return iife ? new webpack_sources_1.ConcatSource(finalSource, ';') : finalSource;
+    }
+    updateHashWithBootstrap(hash, renderContext, hooks) {
+        const bootstrap = this.renderBootstrap(renderContext, hooks);
+        for (const key of Object.keys(bootstrap)) {
+            hash.update(key);
+            if (Array.isArray(bootstrap[key])) {
+                for (const line of bootstrap[key]) {
+                    hash.update(line);
+                }
+            }
+            else {
+                hash.update(JSON.stringify(bootstrap[key]));
+            }
+        }
+    }
+    renderBootstrap(renderContext, hooks) {
+        const { chunkGraph, codeGenerationResults, moduleGraph, chunk, runtimeTemplate } = renderContext;
+        const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+        const requireFunction = runtimeRequirements.has(RuntimeGlobals.require);
+        const moduleCache = runtimeRequirements.has(RuntimeGlobals.moduleCache);
+        const moduleFactories = runtimeRequirements.has(RuntimeGlobals.moduleFactories);
+        const moduleUsed = runtimeRequirements.has(RuntimeGlobals.module);
+        const requireScopeUsed = runtimeRequirements.has(RuntimeGlobals.requireScope);
+        const interceptModuleExecution = runtimeRequirements.has(RuntimeGlobals.interceptModuleExecution);
+        const useRequire = requireFunction || interceptModuleExecution || moduleUsed;
+        const result = {
+            header: [],
+            beforeStartup: [],
+            startup: [],
+            afterStartup: [],
+            allowInlineStartup: true,
+        };
+        const { header: buf, startup, beforeStartup, afterStartup } = result;
+        if (result.allowInlineStartup && moduleFactories) {
+            startup.push('// module factories are used so entry inlining is disabled');
+            result.allowInlineStartup = false;
+        }
+        if (result.allowInlineStartup && moduleCache) {
+            startup.push('// module cache are used so entry inlining is disabled');
+            result.allowInlineStartup = false;
+        }
+        if (result.allowInlineStartup && interceptModuleExecution) {
+            startup.push('// module execution is intercepted so entry inlining is disabled');
+            result.allowInlineStartup = false;
+        }
+        if (useRequire || moduleCache) {
+            buf.push('// The module cache');
+            buf.push('var __webpack_module_cache__ = {};');
+            buf.push('');
+        }
+        if (useRequire) {
+            buf.push('// The require function');
+            buf.push(`function ${RuntimeGlobals.require}(moduleId) {`);
+            buf.push(Template_1.Template.indent(this.renderRequire(renderContext, hooks)));
+            buf.push('}');
+            buf.push('');
+        }
+        else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
+            buf.push('// The require scope');
+            buf.push(`var ${RuntimeGlobals.require} = {};`);
+            buf.push('');
+        }
+        if (moduleFactories || runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)) {
+            buf.push('// expose the modules object (__webpack_modules__)');
+            buf.push(`${RuntimeGlobals.moduleFactories} = __webpack_modules__;`);
+            buf.push('');
+        }
+        if (moduleCache) {
+            buf.push('// expose the module cache');
+            buf.push(`${RuntimeGlobals.moduleCache} = __webpack_module_cache__;`);
+            buf.push('');
+        }
+        if (interceptModuleExecution) {
+            buf.push('// expose the module execution interceptor');
+            buf.push(`${RuntimeGlobals.interceptModuleExecution} = [];`);
+            buf.push('');
+        }
+        if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
+            if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+                const buf2 = [];
+                const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+                buf2.push('// Load entry module and return exports');
+                let i = chunkGraph.getNumberOfEntryModules(chunk);
+                for (const [entryModule, entrypoint,] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+                    const chunks = entrypoint.chunks.filter(c => c !== chunk);
+                    if (result.allowInlineStartup && chunks.length > 0) {
+                        buf2.push('// This entry module depends on other loaded chunks and execution need to be delayed');
+                        result.allowInlineStartup = false;
+                    }
+                    if (result.allowInlineStartup &&
+                        (0, IterableHelpers_1.someInIterable)(moduleGraph.getIncomingConnectionsByOriginModule(entryModule), ([originModule, connections]) => originModule &&
+                            connections.some(c => c.isTargetActive(chunk.runtime)) &&
+                            (0, IterableHelpers_1.someInIterable)(chunkGraph.getModuleRuntimes(originModule), runtime => (0, RuntimeHelpers_1.intersectRuntime)(runtime, chunk.runtime) !== undefined))) {
+                        buf2.push("// This entry module is referenced by other modules so it can't be inlined");
+                        result.allowInlineStartup = false;
+                    }
+                    let data;
+                    if (codeGenerationResults.has(entryModule, chunk.runtime)) {
+                        const result = codeGenerationResults.get(entryModule, chunk.runtime);
+                        data = result.data;
+                    }
+                    if (result.allowInlineStartup &&
+                        (!data || !data.get('topLevelDeclarations')) &&
+                        (!entryModule.buildInfo || !entryModule.buildInfo.topLevelDeclarations)) {
+                        buf2.push("// This entry module doesn't tell about it's top-level declarations so it can't be inlined");
+                        result.allowInlineStartup = false;
+                    }
+                    if (result.allowInlineStartup) {
+                        const bailout = hooks.inlineInRuntimeBailout.call(entryModule, renderContext);
+                        if (bailout !== undefined) {
+                            buf2.push(`// This entry module can't be inlined because ${bailout}`);
+                            result.allowInlineStartup = false;
+                        }
+                    }
+                    i--;
+                    const moduleId = chunkGraph.getModuleId(entryModule);
+                    const entryRuntimeRequirements = chunkGraph.getModuleRuntimeRequirements(entryModule, chunk.runtime);
+                    let moduleIdExpr = JSON.stringify(moduleId);
+                    if (runtimeRequirements.has(RuntimeGlobals.entryModuleId)) {
+                        moduleIdExpr = `${RuntimeGlobals.entryModuleId} = ${moduleIdExpr}`;
+                    }
+                    if (result.allowInlineStartup && entryRuntimeRequirements.has(RuntimeGlobals.module)) {
+                        result.allowInlineStartup = false;
+                        buf2.push("// This entry module used 'module' so it can't be inlined");
+                    }
+                    if (chunks.length > 0) {
+                        buf2.push(`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ''}${RuntimeGlobals.onChunksLoaded}(undefined, ${JSON.stringify(chunks.map(c => c.id))}, ${runtimeTemplate.returningFunction(`${RuntimeGlobals.require}(${moduleIdExpr})`)})`);
+                    }
+                    else if (useRequire) {
+                        buf2.push(`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ''}${RuntimeGlobals.require}(${moduleIdExpr});`);
+                    }
+                    else {
+                        if (i === 0)
+                            buf2.push(`var ${RuntimeGlobals.exports} = {};`);
+                        if (requireScopeUsed) {
+                            buf2.push(`__webpack_modules__[${moduleIdExpr}](0, ${i === 0 ? RuntimeGlobals.exports : '{}'}, ${RuntimeGlobals.require});`);
+                        }
+                        else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
+                            buf2.push(`__webpack_modules__[${moduleIdExpr}](0, ${i === 0 ? RuntimeGlobals.exports : '{}'});`);
+                        }
+                        else {
+                            buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+                        }
+                    }
+                }
+                if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+                    buf2.push(`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});`);
+                }
+                if (runtimeRequirements.has(RuntimeGlobals.startup) ||
+                    (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
+                        runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))) {
+                    result.allowInlineStartup = false;
+                    buf.push('// the startup function');
+                    buf.push(`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction('', [
+                        ...buf2,
+                        `return ${RuntimeGlobals.exports};`,
+                    ])};`);
+                    buf.push('');
+                    startup.push('// run startup');
+                    startup.push(`var ${RuntimeGlobals.exports} = ${RuntimeGlobals.startup}();`);
+                }
+                else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
+                    buf.push('// the startup function');
+                    buf.push(`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`);
+                    beforeStartup.push('// run runtime startup');
+                    beforeStartup.push(`${RuntimeGlobals.startup}();`);
+                    startup.push('// startup');
+                    startup.push(Template_1.Template.asString(buf2));
+                }
+                else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
+                    buf.push('// the startup function');
+                    buf.push(`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`);
+                    startup.push('// startup');
+                    startup.push(Template_1.Template.asString(buf2));
+                    afterStartup.push('// run runtime startup');
+                    afterStartup.push(`${RuntimeGlobals.startup}();`);
+                }
+                else {
+                    startup.push('// startup');
+                    startup.push(Template_1.Template.asString(buf2));
+                }
+            }
+            else if (runtimeRequirements.has(RuntimeGlobals.startup) ||
+                runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+                runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
+                buf.push('// the startup function', "// It's empty as no entry modules are in this chunk", `${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`, '');
+            }
+        }
+        else if (runtimeRequirements.has(RuntimeGlobals.startup) ||
+            runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+            runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
+            result.allowInlineStartup = false;
+            buf.push('// the startup function', "// It's empty as some runtime module handles the default behavior", `${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`);
+            startup.push('// run startup');
+            startup.push(`var ${RuntimeGlobals.exports} = ${RuntimeGlobals.startup}();`);
+        }
+        return result;
+    }
+    renderRequire(renderContext, hooks) {
+        const { chunk, chunkGraph, runtimeTemplate: { outputOptions }, } = renderContext;
+        const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+        const moduleExecution = runtimeRequirements.has(RuntimeGlobals.interceptModuleExecution)
+            ? Template_1.Template.asString([
+                `var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
+                `${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
+                'module = execOptions.module;',
+                'execOptions.factory.call(module.exports, module, module.exports, execOptions.require);',
+            ])
+            : runtimeRequirements.has(RuntimeGlobals.thisAsExports)
+                ? Template_1.Template.asString([
+                    `__webpack_modules__[moduleId].call(module.exports, module, module.exports, ${RuntimeGlobals.require});`,
+                ])
+                : Template_1.Template.asString([
+                    `__webpack_modules__[moduleId](module, module.exports, ${RuntimeGlobals.require});`,
+                ]);
+        const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
+        const needModuleLoaded = runtimeRequirements.has(RuntimeGlobals.moduleLoaded);
+        const content = Template_1.Template.asString([
+            '// Check if module is in cache',
+            'var cachedModule = __webpack_module_cache__[moduleId];',
+            'if (cachedModule !== undefined) {',
+            outputOptions.strictModuleErrorHandling
+                ? Template_1.Template.indent([
+                    'if (cachedModule.error !== undefined) throw cachedModule.error;',
+                    'return cachedModule.exports;',
+                ])
+                : Template_1.Template.indent('return cachedModule.exports;'),
+            '}',
+            '// Create a new module (and put it into the cache)',
+            'var module = __webpack_module_cache__[moduleId] = {',
+            Template_1.Template.indent([
+                needModuleId ? 'id: moduleId,' : '// no module.id needed',
+                needModuleLoaded ? 'loaded: false,' : '// no module.loaded needed',
+                'exports: {}',
+            ]),
+            '};',
+            '',
+            outputOptions.strictModuleExceptionHandling
+                ? Template_1.Template.asString([
+                    '// Execute the module function',
+                    'var threw = true;',
+                    'try {',
+                    Template_1.Template.indent([moduleExecution, 'threw = false;']),
+                    '} finally {',
+                    Template_1.Template.indent(['if(threw) delete __webpack_module_cache__[moduleId];']),
+                    '}',
+                ])
+                : outputOptions.strictModuleErrorHandling
+                    ? Template_1.Template.asString([
+                        '// Execute the module function',
+                        'try {',
+                        Template_1.Template.indent(moduleExecution),
+                        '} catch(e) {',
+                        Template_1.Template.indent(['module.error = e;', 'throw e;']),
+                        '}',
+                    ])
+                    : Template_1.Template.asString(['// Execute the module function', moduleExecution]),
+            needModuleLoaded
+                ? Template_1.Template.asString([
+                    '',
+                    '// Flag the module as loaded',
+                    `${RuntimeGlobals.moduleLoaded} = true;`,
+                    '',
+                ])
+                : '',
+            '// Return the exports of the module',
+            'return module.exports;',
+        ]);
+        return (0, HookBaseError_1.tryRunOrBaseError)(() => hooks.renderRequire.call(content, renderContext), 'JavascriptModulesPlugin.getCompilationHooks().renderRequire');
+    }
+}
+exports.JavascriptModulesPlugin = JavascriptModulesPlugin;