xhs-mp-pack 1.1.0-beta.0

package/dist/sourcemap/EvalSourceMapDevToolPlugin.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const ModuleFilenameHelpers = __importStar(require("@/base/ModuleFilenameHelpers"));
+const NormalModule_1 = __importDefault(require("@/module/NormalModule"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+const ConcatenatedModule_1 = __importDefault(require("@/plugins/optimize/ConcatenatedModule"));
+const identifier_1 = require("@/base/identifier");
+const SourceMapDevToolModuleOptionsPlugin_1 = __importDefault(require("./SourceMapDevToolModuleOptionsPlugin"));
+const cache = new WeakMap();
+const devtoolWarning = new webpack_sources_1.RawSource(`/*
+ * ATTENTION: An "eval-source-map" devtool has been used.
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+`);
+class EvalSourceMapDevToolPlugin {
+    constructor(inputOptions) {
+        let options;
+        if (typeof inputOptions === 'string') {
+            options = {
+                append: inputOptions,
+            };
+        }
+        else {
+            options = inputOptions;
+        }
+        this.sourceMapComment =
+            options.append && typeof options.append !== 'function'
+                ? options.append
+                : '//# sourceURL=[module]\n//# sourceMappingURL=[url]';
+        this.moduleFilenameTemplate =
+            options.moduleFilenameTemplate || 'webpack://[namespace]/[resource-path]?[hash]';
+        this.namespace = options.namespace || '';
+        this.options = options;
+    }
+    apply(compiler) {
+        const options = this.options;
+        compiler.hooks.compilation.tap('EvalSourceMapDevToolPlugin', compilation => {
+            const hooks = JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            new SourceMapDevToolModuleOptionsPlugin_1.default(options).apply(compilation);
+            const matchModule = ModuleFilenameHelpers.matchObject.bind(ModuleFilenameHelpers, options);
+            hooks.renderModuleContent.tap('EvalSourceMapDevToolPlugin', (source, m, { runtimeTemplate, chunkGraph }) => {
+                const cachedSource = cache.get(source);
+                if (cachedSource !== undefined) {
+                    return cachedSource;
+                }
+                const result = r => {
+                    cache.set(source, r);
+                    return r;
+                };
+                if (m instanceof NormalModule_1.default) {
+                    const module = m;
+                    if (!matchModule(module.resource)) {
+                        return result(source);
+                    }
+                }
+                else if (m instanceof ConcatenatedModule_1.default) {
+                    const concatModule = m;
+                    if (concatModule.rootModule instanceof NormalModule_1.default) {
+                        const module = concatModule.rootModule;
+                        if (!matchModule(module.resource)) {
+                            return result(source);
+                        }
+                    }
+                    else {
+                        return result(source);
+                    }
+                }
+                else {
+                    return result(source);
+                }
+                let sourceMap;
+                let content;
+                if (source.sourceAndMap) {
+                    const sourceAndMap = source.sourceAndMap(options);
+                    sourceMap = sourceAndMap.map;
+                    content = sourceAndMap.source;
+                }
+                else {
+                    sourceMap = source.map(options);
+                    content = source.source();
+                }
+                if (!sourceMap) {
+                    return result(source);
+                }
+                // Clone (flat) the sourcemap to ensure that the mutations below do not persist.
+                sourceMap = Object.assign({}, sourceMap);
+                const context = compiler.options.context;
+                const root = compiler.root;
+                const modules = sourceMap.sources.map(source => {
+                    if (!source.startsWith('webpack://'))
+                        return source;
+                    source = (0, identifier_1.makePathsAbsolute)(context, source.slice(10), root);
+                    const module = compilation.findModule(source);
+                    return module || source;
+                });
+                let moduleFilenames = modules.map(module => ModuleFilenameHelpers.createFilename(module, {
+                    moduleFilenameTemplate: this.moduleFilenameTemplate,
+                    namespace: this.namespace,
+                }, {
+                    requestShortener: runtimeTemplate.requestShortener,
+                    chunkGraph,
+                    hashFunction: compilation.outputOptions.hashFunction,
+                }));
+                moduleFilenames = ModuleFilenameHelpers.replaceDuplicates(moduleFilenames, (filename, i, n) => {
+                    for (let j = 0; j < n; j++)
+                        filename += '*';
+                    return filename;
+                });
+                sourceMap.sources = moduleFilenames;
+                if (options.noSources) {
+                    sourceMap.sourcesContent = undefined;
+                }
+                sourceMap.sourceRoot = options.sourceRoot || '';
+                const moduleId = chunkGraph.getModuleId(m);
+                sourceMap.file = typeof moduleId === 'number' ? `${moduleId}.js` : moduleId;
+                const footer = `${this.sourceMapComment.replace(/\[url\]/g, `data:application/json;charset=utf-8;base64,${Buffer.from(JSON.stringify(sourceMap), 'utf8').toString('base64')}`)}\n//# sourceURL=webpack-internal:///${moduleId}\n`; // workaround for chrome bug
+                return result(new webpack_sources_1.RawSource(`eval(${compilation.outputOptions.trustedTypes
+                    ? `${RuntimeGlobals.createScript}(${JSON.stringify(content + footer)})`
+                    : JSON.stringify(content + footer)});`));
+            });
+            hooks.inlineInRuntimeBailout.tap('EvalDevToolModulePlugin', () => 'the eval-source-map devtool is used.');
+            hooks.render.tap('EvalSourceMapDevToolPlugin', source => new webpack_sources_1.ConcatSource(devtoolWarning, source));
+            hooks.chunkHash.tap('EvalSourceMapDevToolPlugin', (chunk, hash) => {
+                hash.update('EvalSourceMapDevToolPlugin');
+                hash.update('2');
+            });
+            if (compilation.outputOptions.trustedTypes) {
+                compilation.hooks.additionalModuleRuntimeRequirements.tap('EvalSourceMapDevToolPlugin', (module, set, context) => {
+                    set.add(RuntimeGlobals.createScript);
+                });
+            }
+        });
+    }
+}
+exports.default = EvalSourceMapDevToolPlugin;

package/dist/sourcemap/SourceMapDevToolModuleOptionsPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class SourceMapDevToolModuleOptionsPlugin {
+    options: any;
+    constructor(options: any);
+    apply(compilation: any): void;
+}
+export default SourceMapDevToolModuleOptionsPlugin;

package/dist/sourcemap/SourceMapDevToolModuleOptionsPlugin.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+class SourceMapDevToolModuleOptionsPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compilation) {
+        const options = this.options;
+        if (options.module !== false) {
+            compilation.hooks.buildModule.tap('SourceMapDevToolModuleOptionsPlugin', module => {
+                module.useSourceMap = true;
+            });
+            compilation.hooks.runtimeModule.tap('SourceMapDevToolModuleOptionsPlugin', module => {
+                module.useSourceMap = true;
+            });
+        }
+        else {
+            compilation.hooks.buildModule.tap('SourceMapDevToolModuleOptionsPlugin', module => {
+                module.useSimpleSourceMap = true;
+            });
+            compilation.hooks.runtimeModule.tap('SourceMapDevToolModuleOptionsPlugin', module => {
+                module.useSimpleSourceMap = true;
+            });
+        }
+        JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).useSourceMap.tap('SourceMapDevToolModuleOptionsPlugin', () => true);
+    }
+}
+exports.default = SourceMapDevToolModuleOptionsPlugin;

package/dist/sourcemap/SourceMapDevToolPlugin.d.ts

@@ -0,0 +1,11 @@
+declare class SourceMapDevToolPlugin {
+    sourceMapFilename: string;
+    sourceMappingURLComment: string | false | Function;
+    moduleFilenameTemplate: string | Function;
+    fallbackModuleFilenameTemplate: string | Function;
+    namespace: string;
+    options: any;
+    constructor(options?: any);
+    apply(compiler: any): void;
+}
+export default SourceMapDevToolPlugin;

package/dist/sourcemap/SourceMapDevToolPlugin.js

@@ -0,0 +1,364 @@
+"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 neo_async_1 = __importDefault(require("neo-async"));
+const webpack_sources_1 = require("webpack-sources");
+const Compilation_1 = __importDefault(require("@/Compilation"));
+const ModuleFilenameHelpers = __importStar(require("@/base/ModuleFilenameHelpers"));
+const ProgressPlugin_1 = __importDefault(require("@/plugins/ProgressPlugin"));
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const fs_1 = require("@/base/fs");
+const identifier_1 = require("@/base/identifier");
+const SourceMapDevToolModuleOptionsPlugin_1 = __importDefault(require("./SourceMapDevToolModuleOptionsPlugin"));
+const METACHARACTERS_REGEXP = /[-[\]\\/{}()*+?.^$|]/g;
+const CONTENT_HASH_DETECT_REGEXP = /\[contenthash(:\w+)?\]/;
+const CSS_AND_JS_MODULE_EXTENSIONS_REGEXP = /\.((c|m)?js|css)($|\?)/i;
+const CSS_EXTENSION_DETECT_REGEXP = /\.css($|\?)/i;
+const MAP_URL_COMMENT_REGEXP = /\[map\]/g;
+const URL_COMMENT_REGEXP = /\[url\]/g;
+const URL_FORMATTING_REGEXP = /^\n\/\/(.*)$/;
+/**
+ * Reset's .lastIndex of stateful Regular Expressions
+ * For when `test` or `exec` is called on them
+ *
+ */
+const resetRegexpState = regexp => {
+    regexp.lastIndex = -1;
+};
+/**
+ * Escapes regular expression metacharacters
+ */
+const quoteMeta = str => str.replace(METACHARACTERS_REGEXP, '\\$&');
+const getTaskForFile = (file, asset, assetInfo, options, compilation, cacheItem) => {
+    let source;
+    let sourceMap;
+    /**
+     * Check if asset can build source map
+     */
+    if (asset.sourceAndMap) {
+        const sourceAndMap = asset.sourceAndMap(options);
+        sourceMap = sourceAndMap.map;
+        source = sourceAndMap.source;
+    }
+    else {
+        sourceMap = asset.map(options);
+        source = asset.source();
+    }
+    if (!sourceMap || typeof source !== 'string')
+        return;
+    const context = compilation.options.context;
+    const root = compilation.compiler.root;
+    const cachedAbsolutify = identifier_1.makePathsAbsolute.bindContextCache(context, root);
+    const modules = sourceMap.sources.map(source => {
+        if (!source.startsWith('webpack://'))
+            return source;
+        source = cachedAbsolutify(source.slice(10));
+        const module = compilation.findModule(source);
+        return module || source;
+    });
+    return {
+        file,
+        asset,
+        source,
+        assetInfo,
+        sourceMap,
+        modules,
+        cacheItem,
+    };
+};
+class SourceMapDevToolPlugin {
+    constructor(options = {}) {
+        this.options = {};
+        this.sourceMapFilename = options.filename;
+        this.sourceMappingURLComment =
+            // eslint-disable-next-line no-useless-concat
+            options.append === false ? false : options.append || '\n//# source' + 'MappingURL=[url]';
+        this.moduleFilenameTemplate =
+            options.moduleFilenameTemplate || 'webpack://[namespace]/[resourcePath]';
+        this.fallbackModuleFilenameTemplate =
+            options.fallbackModuleFilenameTemplate || 'webpack://[namespace]/[resourcePath]?[hash]';
+        this.namespace = options.namespace || '';
+        this.options = options;
+    }
+    apply(compiler) {
+        const outputFs = compiler.outputFileSystem;
+        const sourceMapFilename = this.sourceMapFilename;
+        const sourceMappingURLComment = this.sourceMappingURLComment;
+        const moduleFilenameTemplate = this.moduleFilenameTemplate;
+        const namespace = this.namespace;
+        const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate;
+        const requestShortener = compiler.requestShortener;
+        const options = this.options;
+        options.test = options.test || CSS_AND_JS_MODULE_EXTENSIONS_REGEXP;
+        const matchObject = ModuleFilenameHelpers.matchObject.bind(undefined, options);
+        compiler.hooks.compilation.tap('SourceMapDevToolPlugin', compilation => {
+            new SourceMapDevToolModuleOptionsPlugin_1.default(options).apply(compilation);
+            compilation.hooks.processAssets.tapAsync({
+                name: 'SourceMapDevToolPlugin',
+                stage: Compilation_1.default.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+                additionalAssets: true,
+            }, (assets, callback) => {
+                const chunkGraph = compilation.chunkGraph;
+                const cache = compilation.getCache('SourceMapDevToolPlugin');
+                const moduleToSourceNameMapping = new Map();
+                const reportProgress = ProgressPlugin_1.default.getReporter(compilation.compiler) || ((...args) => { });
+                const fileToChunk = new Map();
+                for (const chunk of compilation.chunks) {
+                    for (const file of chunk.files) {
+                        fileToChunk.set(file, chunk);
+                    }
+                    for (const file of chunk.auxiliaryFiles) {
+                        fileToChunk.set(file, chunk);
+                    }
+                }
+                const files = [];
+                for (const file of Object.keys(assets)) {
+                    if (matchObject(file)) {
+                        files.push(file);
+                    }
+                }
+                // @ts-ignore
+                reportProgress(0.0);
+                const tasks = [];
+                let fileIndex = 0;
+                neo_async_1.default.each(files, (file, callback) => {
+                    var _a;
+                    const asset = compilation.getAsset(file);
+                    if ((_a = asset.info.related) === null || _a === void 0 ? void 0 : _a.sourceMap) {
+                        fileIndex++;
+                        return callback();
+                    }
+                    const cacheItem = cache.getItemCache(file, cache.mergeEtags(cache.getLazyHashedEtag(asset.source), namespace));
+                    cacheItem.get((err, cacheEntry) => {
+                        if (err) {
+                            return callback(err);
+                        }
+                        /**
+                         * If presented in cache, reassigns assets. Cache assets already have source maps.
+                         */
+                        if (cacheEntry) {
+                            const { assets, assetsInfo } = cacheEntry;
+                            for (const cachedFile of Object.keys(assets)) {
+                                if (cachedFile === file) {
+                                    compilation.updateAsset(cachedFile, assets[cachedFile], assetsInfo[cachedFile]);
+                                }
+                                else {
+                                    compilation.emitAsset(cachedFile, assets[cachedFile], assetsInfo[cachedFile]);
+                                }
+                                /**
+                                 * Add file to chunk, if not presented there
+                                 */
+                                if (cachedFile !== file) {
+                                    const chunk = fileToChunk.get(file);
+                                    if (chunk !== undefined)
+                                        chunk.auxiliaryFiles.add(cachedFile);
+                                }
+                            }
+                            reportProgress((0.5 * ++fileIndex) / files.length, file, 'restored cached SourceMap');
+                            return callback();
+                        }
+                        reportProgress((0.5 * fileIndex) / files.length, file, 'generate SourceMap');
+                        const task = getTaskForFile(file, asset.source, asset.info, {
+                            module: options.module,
+                            columns: options.columns,
+                        }, compilation, cacheItem);
+                        if (task) {
+                            const modules = task.modules;
+                            for (let idx = 0; idx < modules.length; idx++) {
+                                const module = modules[idx];
+                                if (!moduleToSourceNameMapping.get(module)) {
+                                    moduleToSourceNameMapping.set(module, ModuleFilenameHelpers.createFilename(module, {
+                                        moduleFilenameTemplate,
+                                        namespace,
+                                    }, {
+                                        requestShortener,
+                                        chunkGraph,
+                                        hashFunction: compilation.outputOptions.hashFunction,
+                                    }));
+                                }
+                            }
+                            tasks.push(task);
+                        }
+                        reportProgress((0.5 * ++fileIndex) / files.length, file, 'generated SourceMap');
+                        callback();
+                    });
+                }, err => {
+                    if (err) {
+                        return callback(err);
+                    }
+                    reportProgress(0.5, 'resolve sources');
+                    const usedNamesSet = new Set(moduleToSourceNameMapping.values());
+                    const conflictDetectionSet = new Set();
+                    const allModules = Array.from(moduleToSourceNameMapping.keys()).sort((a, b) => {
+                        const ai = typeof a === 'string' ? a : a.identifier();
+                        const bi = typeof b === 'string' ? b : b.identifier();
+                        return ai.length - bi.length;
+                    });
+                    // find modules with conflicting source names
+                    for (let idx = 0; idx < allModules.length; idx++) {
+                        const module = allModules[idx];
+                        let sourceName = moduleToSourceNameMapping.get(module);
+                        let hasName = conflictDetectionSet.has(sourceName);
+                        if (!hasName) {
+                            conflictDetectionSet.add(sourceName);
+                            continue;
+                        }
+                        // try the fallback name first
+                        sourceName = ModuleFilenameHelpers.createFilename(module, {
+                            moduleFilenameTemplate: fallbackModuleFilenameTemplate,
+                            namespace,
+                        }, {
+                            requestShortener,
+                            chunkGraph,
+                            hashFunction: compilation.outputOptions.hashFunction,
+                        });
+                        hasName = usedNamesSet.has(sourceName);
+                        if (!hasName) {
+                            moduleToSourceNameMapping.set(module, sourceName);
+                            usedNamesSet.add(sourceName);
+                            continue;
+                        }
+                        // otherwise just append stars until we have a valid name
+                        while (hasName) {
+                            sourceName += '*';
+                            hasName = usedNamesSet.has(sourceName);
+                        }
+                        moduleToSourceNameMapping.set(module, sourceName);
+                        usedNamesSet.add(sourceName);
+                    }
+                    let taskIndex = 0;
+                    neo_async_1.default.each(tasks, (task, callback) => {
+                        const assets = Object.create(null);
+                        const assetsInfo = Object.create(null);
+                        const file = task.file;
+                        const chunk = fileToChunk.get(file);
+                        const sourceMap = task.sourceMap;
+                        const source = task.source;
+                        const modules = task.modules;
+                        reportProgress(0.5 + (0.5 * taskIndex) / tasks.length, file, 'attach SourceMap');
+                        const moduleFilenames = modules.map(m => moduleToSourceNameMapping.get(m));
+                        sourceMap.sources = moduleFilenames;
+                        if (options.noSources) {
+                            sourceMap.sourcesContent = undefined;
+                        }
+                        sourceMap.sourceRoot = options.sourceRoot || '';
+                        sourceMap.file = file;
+                        const usesContentHash = sourceMapFilename && CONTENT_HASH_DETECT_REGEXP.test(sourceMapFilename);
+                        resetRegexpState(CONTENT_HASH_DETECT_REGEXP);
+                        // If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file`
+                        if (usesContentHash && task.assetInfo.contenthash) {
+                            const contenthash = task.assetInfo.contenthash;
+                            let pattern;
+                            if (Array.isArray(contenthash)) {
+                                pattern = contenthash.map(quoteMeta).join('|');
+                            }
+                            else {
+                                pattern = quoteMeta(contenthash);
+                            }
+                            sourceMap.file = sourceMap.file.replace(new RegExp(pattern, 'g'), m => 'x'.repeat(m.length));
+                        }
+                        let currentSourceMappingURLComment = sourceMappingURLComment;
+                        const cssExtensionDetected = CSS_EXTENSION_DETECT_REGEXP.test(file);
+                        resetRegexpState(CSS_EXTENSION_DETECT_REGEXP);
+                        if (currentSourceMappingURLComment !== false &&
+                            typeof currentSourceMappingURLComment !== 'function' &&
+                            cssExtensionDetected) {
+                            currentSourceMappingURLComment = currentSourceMappingURLComment.replace(URL_FORMATTING_REGEXP, '\n/*$1*/');
+                        }
+                        const sourceMapString = JSON.stringify(sourceMap);
+                        if (sourceMapFilename) {
+                            const filename = file;
+                            const sourceMapContentHash = usesContentHash &&
+                                (0, createHash_1.default)(compilation.outputOptions.hashFunction)
+                                    .update(sourceMapString)
+                                    .digest('hex');
+                            const pathParams = {
+                                chunk,
+                                filename: options.fileContext
+                                    ? (0, fs_1.relative)(outputFs, `/${options.fileContext}`, `/${filename}`)
+                                    : filename,
+                                contentHash: sourceMapContentHash,
+                            };
+                            const { path: sourceMapFile, info: sourceMapInfo } = compilation.getPathWithInfo(sourceMapFilename, pathParams);
+                            const sourceMapUrl = options.publicPath
+                                ? options.publicPath + sourceMapFile
+                                : (0, fs_1.relative)(outputFs, (0, fs_1.dirname)(outputFs, `/${file}`), `/${sourceMapFile}`);
+                            let asset = new webpack_sources_1.RawSource(source);
+                            if (currentSourceMappingURLComment !== false) {
+                                // Add source map url to compilation asset, if currentSourceMappingURLComment is set
+                                asset = new webpack_sources_1.ConcatSource(asset, compilation.getPath(currentSourceMappingURLComment, Object.assign({ url: sourceMapUrl }, pathParams)));
+                            }
+                            const assetInfo = {
+                                related: { sourceMap: sourceMapFile },
+                            };
+                            assets[file] = asset;
+                            assetsInfo[file] = assetInfo;
+                            compilation.updateAsset(file, asset, assetInfo);
+                            // Add source map file to compilation assets and chunk files
+                            const sourceMapAsset = new webpack_sources_1.RawSource(sourceMapString);
+                            const sourceMapAssetInfo = Object.assign(Object.assign({}, sourceMapInfo), { development: true });
+                            assets[sourceMapFile] = sourceMapAsset;
+                            assetsInfo[sourceMapFile] = sourceMapAssetInfo;
+                            compilation.emitAsset(sourceMapFile, sourceMapAsset, sourceMapAssetInfo);
+                            if (chunk !== undefined)
+                                chunk.auxiliaryFiles.add(sourceMapFile);
+                        }
+                        else {
+                            if (currentSourceMappingURLComment === false) {
+                                throw new Error("SourceMapDevToolPlugin: append can't be false when no filename is provided");
+                            }
+                            if (typeof currentSourceMappingURLComment === 'function') {
+                                throw new Error("SourceMapDevToolPlugin: append can't be a function when no filename is provided");
+                            }
+                            /**
+                             * Add source map as data url to asset
+                             */
+                            const asset = new webpack_sources_1.ConcatSource(new webpack_sources_1.RawSource(source), currentSourceMappingURLComment
+                                .replace(MAP_URL_COMMENT_REGEXP, () => sourceMapString)
+                                .replace(URL_COMMENT_REGEXP, () => `data:application/json;charset=utf-8;base64,${Buffer.from(sourceMapString, 'utf-8').toString('base64')}`));
+                            assets[file] = asset;
+                            assetsInfo[file] = undefined;
+                            compilation.updateAsset(file, asset);
+                        }
+                        task.cacheItem.store({ assets, assetsInfo }, err => {
+                            reportProgress(0.5 + (0.5 * ++taskIndex) / tasks.length, task.file, 'attached SourceMap');
+                            if (err) {
+                                return callback(err);
+                            }
+                            callback();
+                        });
+                    }, err => {
+                        reportProgress(1.0);
+                        callback(err);
+                    });
+                });
+            });
+        });
+    }
+}
+exports.default = SourceMapDevToolPlugin;

package/dist/template/ChunkTemplate.d.ts

@@ -0,0 +1,6 @@
+declare class ChunkTemplate {
+    _outputOptions: any;
+    hooks: any;
+    constructor(outputOptions: any, compilation: any);
+}
+export default ChunkTemplate;

package/dist/template/ChunkTemplate.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const JavascriptModulesPlugin_1 = require("../module/javascript/JavascriptModulesPlugin");
+class ChunkTemplate {
+    constructor(outputOptions, compilation) {
+        this._outputOptions = outputOptions || {};
+        this.hooks = Object.freeze({
+            renderManifest: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    compilation.hooks.renderManifest.tap(options, (entries, options) => {
+                        if (options.chunk.hasRuntime())
+                            return entries;
+                        return fn(entries, options);
+                    });
+                }, 'ChunkTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_MANIFEST'),
+            },
+            modules: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderChunk.tap(options, (source, renderContext) => fn(source, compilation.moduleTemplates.javascript, renderContext));
+                }, 'ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_MODULES'),
+            },
+            render: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).renderChunk.tap(options, (source, renderContext) => fn(source, compilation.moduleTemplates.javascript, renderContext));
+                }, 'ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_RENDER'),
+            },
+            renderWithEntry: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).render.tap(options, (source, renderContext) => {
+                        if (renderContext.chunkGraph.getNumberOfEntryModules(renderContext.chunk) === 0 ||
+                            renderContext.chunk.hasRuntime()) {
+                            return source;
+                        }
+                        return fn(source, renderContext.chunk);
+                    });
+                }, 'ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY'),
+            },
+            hash: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    compilation.hooks.fullHash.tap(options, fn);
+                }, 'ChunkTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_HASH'),
+            },
+            hashForChunk: {
+                tap: util_1.default.deprecate((options, fn) => {
+                    JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(options, (chunk, hash, context) => {
+                        if (chunk.hasRuntime())
+                            return;
+                        fn(hash, chunk, context);
+                    });
+                }, 'ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK'),
+            },
+        });
+    }
+}
+Object.defineProperty(ChunkTemplate.prototype, 'outputOptions', {
+    get: util_1.default.deprecate(
+    /**
+     * @this {ChunkTemplate}
+     * @returns {OutputOptions} output options
+     */
+    function () {
+        return this._outputOptions;
+    }, 'ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)', 'DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS'),
+});
+exports.default = ChunkTemplate;

package/dist/template/LibraryTemplatePlugin.d.ts

@@ -0,0 +1,6 @@
+declare class LibraryTemplatePlugin {
+    library: any;
+    constructor(name: any, target: any, umdNamedDefine: any, auxiliaryComment: any, exportProperty: any);
+    apply(compiler: any): void;
+}
+export default LibraryTemplatePlugin;