xhs-mp-pack 1.1.0-beta.0

package/dist/Compiler.js

@@ -0,0 +1,845 @@
+"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 json_parse_even_better_errors_1 = __importDefault(require("json-parse-even-better-errors"));
+const neo_async_1 = __importDefault(require("neo-async"));
+const tapable_1 = require("tapable");
+const webpack_sources_1 = require("webpack-sources");
+const Cache_1 = __importDefault(require("@/cache/Cache"));
+const CacheFacade_1 = require("@/cache/CacheFacade");
+const ChunkGraph_1 = __importDefault(require("@/chunk/ChunkGraph"));
+const ConcurrentCompilationError_1 = __importDefault(require("@/base/errors/ConcurrentCompilationError"));
+const ContextModuleFactory_1 = __importDefault(require("@/module/ContextModuleFactory"));
+const ModuleGraph_1 = __importDefault(require("@/module/ModuleGraph"));
+const NormalModuleFactory_1 = __importDefault(require("@/module/NormalModuleFactory"));
+const RequestShortener_1 = __importDefault(require("@/base/RequestShortener"));
+const Stats_1 = __importDefault(require("@/base/stats/Stats"));
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const fs_1 = require("@/base/fs");
+const identifier_1 = require("@/base/identifier");
+const source_1 = require("@/base/source");
+const ModuleFilenameHelpers = __importStar(require("@/base/ModuleFilenameHelpers"));
+const JavascriptModulesPlugin_1 = require("./module/javascript/JavascriptModulesPlugin");
+const Logger_1 = require("./base/logging/Logger");
+const Watching_1 = __importDefault(require("./Watching"));
+const ResolverFactory_1 = __importDefault(require("./ResolverFactory"));
+const Compilation_1 = __importDefault(require("./Compilation"));
+const MPPack_1 = require("./MPPack");
+const isSorted = (array) => {
+    for (let i = 1; i < array.length; i++) {
+        if (array[i - 1] > array[i])
+            return false;
+    }
+    return true;
+};
+const sortObject = (obj, keys) => {
+    const o = {};
+    for (const k of keys.sort()) {
+        o[k] = obj[k];
+    }
+    return o;
+};
+const includesHash = (filename, hashes) => {
+    if (!hashes)
+        return false;
+    if (Array.isArray(hashes)) {
+        return hashes.some(hash => filename.includes(hash));
+    }
+    return filename.includes(hashes);
+};
+class Compiler {
+    constructor(project, packSetting, options = {}) {
+        this.context = '';
+        this.options = {};
+        this.outputPath = '';
+        this.outputFileSystem = null;
+        this.intermediateFileSystem = null;
+        this.inputFileSystem = null;
+        this.watchFileSystem = null;
+        this.recordsInputPath = null;
+        this.recordsOutputPath = null;
+        this.records = {};
+        this.managedPaths = new Set();
+        this.immutablePaths = new Set();
+        this.compilerPath = '';
+        this.running = false;
+        this.idle = false;
+        this.watchMode = false;
+        this._assetEmittingSourceCache = new WeakMap();
+        this._assetEmittingWrittenFiles = new Map();
+        this._assetEmittingPreviousFiles = new Set();
+        this.hooks = Object.freeze({
+            initialize: new tapable_1.SyncHook([]),
+            shouldEmit: new tapable_1.SyncBailHook(['compilation']),
+            done: new tapable_1.AsyncSeriesHook(['stats']),
+            afterDone: new tapable_1.SyncHook(['stats']),
+            additionalPass: new tapable_1.AsyncSeriesHook([]),
+            beforeRun: new tapable_1.AsyncSeriesHook(['compiler']),
+            run: new tapable_1.AsyncSeriesHook(['compiler']),
+            emit: new tapable_1.AsyncSeriesHook(['compilation']),
+            assetEmitted: new tapable_1.AsyncSeriesHook(['file', 'info']),
+            afterEmit: new tapable_1.AsyncSeriesHook(['compilation']),
+            thisCompilation: new tapable_1.SyncHook(['compilation', 'params']),
+            compilation: new tapable_1.SyncHook(['compilation', 'params']),
+            normalModuleFactory: new tapable_1.SyncHook(['normalModuleFactory']),
+            contextModuleFactory: new tapable_1.SyncHook(['contextModuleFactory']),
+            beforeCompile: new tapable_1.AsyncSeriesHook(['params']),
+            compile: new tapable_1.SyncHook(['params']),
+            make: new tapable_1.AsyncParallelHook(['compilation']),
+            finishMake: new tapable_1.AsyncSeriesHook(['compilation']),
+            afterCompile: new tapable_1.AsyncSeriesHook(['compilation']),
+            readRecords: new tapable_1.AsyncSeriesHook([]),
+            emitRecords: new tapable_1.AsyncSeriesHook([]),
+            watchRun: new tapable_1.AsyncSeriesHook(['compiler']),
+            failed: new tapable_1.SyncHook(['error']),
+            invalid: new tapable_1.SyncHook(['filename', 'changeTime']),
+            watchClose: new tapable_1.SyncHook([]),
+            shutdown: new tapable_1.AsyncSeriesHook([]),
+            infrastructureLog: new tapable_1.SyncBailHook(['origin', 'type', 'args']),
+            // TODO the following hooks are weirdly located here
+            environment: new tapable_1.SyncHook([]),
+            afterEnvironment: new tapable_1.SyncHook([]),
+            afterResolvers: new tapable_1.SyncHook(['compiler']),
+            entryOption: new tapable_1.SyncBailHook(['context', 'entry']),
+        });
+        this.root = this;
+        this.resolverFactory = new ResolverFactory_1.default();
+        this.project = project;
+        this.packSetting = packSetting;
+        this.context = options.context;
+        this.options = options;
+        this.requestShortener = new RequestShortener_1.default(this.context, this.root);
+        this.cache = new Cache_1.default();
+        this.compilerPath = '';
+        this.running = false;
+        this.idle = false;
+        this.watchMode = false;
+        this.makeWebpackCompalibility();
+    }
+    // 注册webpack对象，兼容webpack插件
+    makeWebpackCompalibility() {
+        this.MPPack = MPPack_1.MPPack;
+        // @ts-ignore
+        this.webpack = {
+            javascript: {
+                JavascriptModulesPlugin: JavascriptModulesPlugin_1.JavascriptModulesPlugin,
+            },
+            Compilation: Compilation_1.default,
+            ModuleFilenameHelpers,
+            sources: {
+                SourceMapSource: webpack_sources_1.SourceMapSource,
+                ConcatSource: webpack_sources_1.ConcatSource,
+                RawSource: webpack_sources_1.RawSource,
+            },
+        };
+    }
+    getCache(name) {
+        return new CacheFacade_1.CacheFacade(this.cache, `${this.compilerPath}${name}`, this.options.output.hashFunction);
+    }
+    getInfrastructureLogger(name) {
+        if (!name) {
+            throw new TypeError('Compiler.getInfrastructureLogger(name) called without a name');
+        }
+        return new Logger_1.Logger((type, args) => {
+            if (typeof name === 'function') {
+                name = name();
+                if (!name) {
+                    throw new TypeError('Compiler.getInfrastructureLogger(name) called with a function not returning a name');
+                }
+            }
+            if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+                if (this.infrastructureLogger !== undefined) {
+                    this.infrastructureLogger(name, type, args);
+                }
+            }
+        }, childName => {
+            if (typeof name === 'function') {
+                if (typeof childName === 'function') {
+                    return this.getInfrastructureLogger(() => {
+                        if (typeof name === 'function') {
+                            name = name();
+                            if (!name) {
+                                throw new TypeError('Compiler.getInfrastructureLogger(name) called with a function not returning a name');
+                            }
+                        }
+                        if (typeof childName === 'function') {
+                            childName = childName();
+                            if (!childName) {
+                                throw new TypeError('Logger.getChildLogger(name) called with a function not returning a name');
+                            }
+                        }
+                        return `${name}/${childName}`;
+                    });
+                }
+                return this.getInfrastructureLogger(() => {
+                    if (typeof name === 'function') {
+                        name = name();
+                        if (!name) {
+                            throw new TypeError('Compiler.getInfrastructureLogger(name) called with a function not returning a name');
+                        }
+                    }
+                    return `${name}/${childName}`;
+                });
+            }
+            if (typeof childName === 'function') {
+                return this.getInfrastructureLogger(() => {
+                    if (typeof childName === 'function') {
+                        childName = childName();
+                        if (!childName) {
+                            throw new TypeError('Logger.getChildLogger(name) called with a function not returning a name');
+                        }
+                    }
+                    return `${name}/${childName}`;
+                });
+            }
+            return this.getInfrastructureLogger(`${name}/${childName}`);
+        });
+    }
+    // e.g. move compilation specific info from Modules into ModuleGraph
+    _cleanupLastCompilation() {
+        if (this._lastCompilation !== undefined) {
+            for (const module of this._lastCompilation.modules) {
+                ChunkGraph_1.default.clearChunkGraphForModule(module);
+                ModuleGraph_1.default.clearModuleGraphForModule(module);
+                module.cleanupForCache();
+            }
+            for (const chunk of this._lastCompilation.chunks) {
+                ChunkGraph_1.default.clearChunkGraphForChunk(chunk);
+            }
+            this._lastCompilation = undefined;
+        }
+    }
+    _cleanupLastNormalModuleFactory() {
+        if (this._lastNormalModuleFactory !== undefined) {
+            this._lastNormalModuleFactory.cleanupForCache();
+            this._lastNormalModuleFactory = undefined;
+        }
+    }
+    watch(watchOptions, handler) {
+        if (this.running) {
+            return handler(new ConcurrentCompilationError_1.default());
+        }
+        this.running = true;
+        this.watchMode = true;
+        this.watching = new Watching_1.default(this, watchOptions, handler);
+        return this.watching;
+    }
+    run(callback) {
+        if (this.running) {
+            return callback(new ConcurrentCompilationError_1.default());
+        }
+        let logger;
+        const finalCallback = (err, stats) => {
+            if (logger)
+                logger.time('beginIdle');
+            this.idle = true;
+            this.cache.beginIdle();
+            this.idle = true;
+            if (logger)
+                logger.timeEnd('beginIdle');
+            this.running = false;
+            if (err) {
+                this.hooks.failed.call(err);
+            }
+            if (callback !== undefined)
+                callback(err, stats);
+            this.hooks.afterDone.call(stats);
+        };
+        const startTime = Date.now();
+        this.running = true;
+        const onCompiled = (err, compilation) => {
+            if (err)
+                return finalCallback(err);
+            if (this.hooks.shouldEmit.call(compilation) === false) {
+                compilation.startTime = startTime;
+                compilation.endTime = Date.now();
+                const stats = new Stats_1.default(compilation);
+                this.hooks.done.callAsync(stats, err => {
+                    if (err)
+                        return finalCallback(err);
+                    return finalCallback(null, stats);
+                });
+                return;
+            }
+            process.nextTick(() => {
+                logger = compilation.getLogger('webpack.Compiler');
+                logger.time('emitAssets');
+                this.emitAssets(compilation, err => {
+                    logger.timeEnd('emitAssets');
+                    if (err)
+                        return finalCallback(err);
+                    logger.time('emitRecords');
+                    this.emitRecords(err => {
+                        logger.timeEnd('emitRecords');
+                        if (err)
+                            return finalCallback(err);
+                        compilation.startTime = startTime;
+                        compilation.endTime = Date.now();
+                        logger.time('done hook');
+                        const stats = new Stats_1.default(compilation);
+                        this.hooks.done.callAsync(stats, err => {
+                            logger.timeEnd('done hook');
+                            if (err)
+                                return finalCallback(err);
+                            this.cache.storeBuildDependencies(compilation.buildDependencies, err => {
+                                if (err)
+                                    return finalCallback(err);
+                                return finalCallback(null, stats);
+                            });
+                        });
+                    });
+                });
+            });
+        };
+        const run = () => {
+            this.hooks.beforeRun.callAsync(this, err => {
+                if (err)
+                    return finalCallback(err);
+                this.hooks.run.callAsync(this, err => {
+                    if (err)
+                        return finalCallback(err);
+                    this.readRecords(err => {
+                        if (err)
+                            return finalCallback(err);
+                        this.compile(onCompiled);
+                    });
+                });
+            });
+        };
+        if (this.idle) {
+            this.cache.endIdle(err => {
+                if (err)
+                    return finalCallback(err);
+                this.idle = false;
+                run();
+            });
+        }
+        else {
+            run();
+        }
+    }
+    runAsChild(callback) {
+        const startTime = Date.now();
+        const finalCallback = (err, entries, compilation) => {
+            try {
+                callback(err, entries, compilation);
+            }
+            catch (e) {
+                const err = new BaseError_1.default(`compiler.runAsChild callback error: ${e}`);
+                err.details = e.stack;
+                this.parentCompilation.errors.push(err);
+            }
+        };
+        this.compile((err, compilation) => {
+            if (err)
+                return finalCallback(err);
+            this.parentCompilation.children.push(compilation);
+            for (const { name, source, info } of compilation.getAssets()) {
+                this.parentCompilation.emitAsset(name, source, info);
+            }
+            const entries = [];
+            for (const ep of compilation.entrypoints.values()) {
+                entries.push(...ep.chunks);
+            }
+            compilation.startTime = startTime;
+            compilation.endTime = Date.now();
+            return finalCallback(null, entries, compilation);
+        });
+    }
+    purgeInputFileSystem() {
+        var _a;
+        if ((_a = this.inputFileSystem) === null || _a === void 0 ? void 0 : _a.purge) {
+            this.inputFileSystem.purge();
+        }
+    }
+    emitAssets(compilation, callback) {
+        let outputPath;
+        const emitFiles = err => {
+            if (err)
+                return callback(err);
+            const assets = compilation.getAssets();
+            compilation.assets = Object.assign({}, compilation.assets);
+            const caseInsensitiveMap = new Map();
+            const allTargetPaths = new Set();
+            neo_async_1.default.forEachLimit(assets, 15, ({ name: file, source, info }, callback) => {
+                let targetFile = file;
+                let immutable = info.immutable;
+                const queryStringIdx = targetFile.indexOf('?');
+                if (queryStringIdx >= 0) {
+                    targetFile = targetFile.slice(0, queryStringIdx);
+                    // We may remove the hash, which is in the query string
+                    // So we recheck if the file is immutable
+                    // This doesn't cover all cases, but immutable is only a performance optimization anyway
+                    immutable =
+                        immutable &&
+                            (includesHash(targetFile, info.contenthash) ||
+                                includesHash(targetFile, info.chunkhash) ||
+                                includesHash(targetFile, info.modulehash) ||
+                                includesHash(targetFile, info.fullhash));
+                }
+                const writeOut = (err) => {
+                    if (err)
+                        return callback(err);
+                    const targetPath = (0, fs_1.join)(this.outputFileSystem, outputPath, targetFile);
+                    allTargetPaths.add(targetPath);
+                    // check if the target file has already been written by this Compiler
+                    const targetFileGeneration = this._assetEmittingWrittenFiles.get(targetPath);
+                    // create an cache entry for this Source if not already existing
+                    let cacheEntry = this._assetEmittingSourceCache.get(source);
+                    if (cacheEntry === undefined) {
+                        cacheEntry = {
+                            sizeOnlySource: undefined,
+                            writtenTo: new Map(),
+                        };
+                        this._assetEmittingSourceCache.set(source, cacheEntry);
+                    }
+                    let similarEntry;
+                    const checkSimilarFile = () => {
+                        const caseInsensitiveTargetPath = targetPath.toLowerCase();
+                        similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath);
+                        if (similarEntry !== undefined) {
+                            const { path: other, source: otherSource } = similarEntry;
+                            if ((0, source_1.isSourceEqual)(otherSource, source)) {
+                                // Size may or may not be available at this point.
+                                // If it's not available add to "waiting" list and it will be updated once available
+                                if (similarEntry.size !== undefined) {
+                                    updateWithReplacementSource(similarEntry.size);
+                                }
+                                else {
+                                    if (!similarEntry.waiting)
+                                        similarEntry.waiting = [];
+                                    similarEntry.waiting.push({ file, cacheEntry });
+                                }
+                                alreadyWritten();
+                            }
+                            else {
+                                const err = new BaseError_1.default(`Prevent writing to file that only differs in casing or query string from already written file.
+This will lead to a race-condition and corrupted files on case-insensitive file systems.
+${targetPath}
+${other}`);
+                                err.file = file;
+                                callback(err);
+                            }
+                            return true;
+                        }
+                        caseInsensitiveMap.set(caseInsensitiveTargetPath, (similarEntry = {
+                            path: targetPath,
+                            source,
+                            size: undefined,
+                            waiting: undefined,
+                        }));
+                        return false;
+                    };
+                    const getContent = () => {
+                        if (typeof source.buffer === 'function') {
+                            return source.buffer();
+                        }
+                        const bufferOrString = source.source();
+                        if (Buffer.isBuffer(bufferOrString)) {
+                            return bufferOrString;
+                        }
+                        return Buffer.from(bufferOrString, 'utf8');
+                    };
+                    const alreadyWritten = () => {
+                        // cache the information that the Source has been already been written to that location
+                        if (targetFileGeneration === undefined) {
+                            const newGeneration = 1;
+                            this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
+                            cacheEntry.writtenTo.set(targetPath, newGeneration);
+                        }
+                        else {
+                            cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
+                        }
+                        callback();
+                    };
+                    const doWrite = content => {
+                        this.outputFileSystem.writeFile(targetPath, content, err => {
+                            if (err)
+                                return callback(err);
+                            // information marker that the asset has been emitted
+                            compilation.emittedAssets.add(file);
+                            // cache the information that the Source has been written to that location
+                            const newGeneration = targetFileGeneration === undefined ? 1 : targetFileGeneration + 1;
+                            cacheEntry.writtenTo.set(targetPath, newGeneration);
+                            this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
+                            this.hooks.assetEmitted.callAsync(file, {
+                                content,
+                                source,
+                                outputPath,
+                                compilation,
+                                targetPath,
+                            }, callback);
+                        });
+                    };
+                    const updateWithReplacementSource = size => {
+                        updateFileWithReplacementSource(file, cacheEntry, size);
+                        similarEntry.size = size;
+                        if (similarEntry.waiting !== undefined) {
+                            for (const { file, cacheEntry } of similarEntry.waiting) {
+                                updateFileWithReplacementSource(file, cacheEntry, size);
+                            }
+                        }
+                    };
+                    const updateFileWithReplacementSource = (file, cacheEntry, size) => {
+                        // Create a replacement resource which only allows to ask for size
+                        // This allows to GC all memory allocated by the Source
+                        // (expect when the Source is stored in any other cache)
+                        if (!cacheEntry.sizeOnlySource) {
+                            cacheEntry.sizeOnlySource = new webpack_sources_1.SizeOnlySource(size);
+                        }
+                        compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+                            size,
+                        });
+                    };
+                    const processExistingFile = stats => {
+                        // skip emitting if it's already there and an immutable file
+                        if (immutable) {
+                            updateWithReplacementSource(stats.size);
+                            return alreadyWritten();
+                        }
+                        const content = getContent();
+                        updateWithReplacementSource(content.length);
+                        // if it exists and content on disk matches content
+                        // skip writing the same content again
+                        // (to keep mtime and don't trigger watchers)
+                        // for a fast negative match file size is compared first
+                        if (content.length === stats.size) {
+                            compilation.comparedForEmitAssets.add(file);
+                            return this.outputFileSystem.readFile(targetPath, (err, existingContent) => {
+                                if (err || !content.equals(existingContent)) {
+                                    return doWrite(content);
+                                }
+                                return alreadyWritten();
+                            });
+                        }
+                        return doWrite(content);
+                    };
+                    const processMissingFile = () => {
+                        const content = getContent();
+                        updateWithReplacementSource(content.length);
+                        return doWrite(content);
+                    };
+                    // if the target file has already been written
+                    if (targetFileGeneration !== undefined) {
+                        // check if the Source has been written to this target file
+                        const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
+                        if (writtenGeneration === targetFileGeneration) {
+                            // if yes, we may skip writing the file
+                            // if it's already there
+                            // (we assume one doesn't modify files while the Compiler is running, other then removing them)
+                            if (this._assetEmittingPreviousFiles.has(targetPath)) {
+                                // We assume that assets from the last compilation say intact on disk (they are not removed)
+                                compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+                                    size: cacheEntry.sizeOnlySource.size(),
+                                });
+                                return callback();
+                            }
+                            // Settings immutable will make it accept file content without comparing when file exist
+                            immutable = true;
+                        }
+                        else if (!immutable) {
+                            if (checkSimilarFile())
+                                return;
+                            // We wrote to this file before which has very likely a different content
+                            // skip comparing and assume content is different for performance
+                            // This case happens often during watch mode.
+                            return processMissingFile();
+                        }
+                    }
+                    if (checkSimilarFile())
+                        return;
+                    if (this.options.output.compareBeforeEmit) {
+                        this.outputFileSystem.stat(targetPath, (err, stats) => {
+                            const exists = !err && stats.isFile();
+                            if (exists) {
+                                processExistingFile(stats);
+                            }
+                            else {
+                                processMissingFile();
+                            }
+                        });
+                    }
+                    else {
+                        processMissingFile();
+                    }
+                };
+                if (targetFile.match(/\/|\\/)) {
+                    const fs = this.outputFileSystem;
+                    const dir = (0, fs_1.dirname)(fs, (0, fs_1.join)(fs, outputPath, targetFile));
+                    (0, fs_1.mkdirp)(fs, dir, writeOut);
+                }
+                else {
+                    writeOut();
+                }
+            }, err => {
+                // Clear map to free up memory
+                caseInsensitiveMap.clear();
+                if (err) {
+                    this._assetEmittingPreviousFiles.clear();
+                    return callback(err);
+                }
+                this._assetEmittingPreviousFiles = allTargetPaths;
+                this.hooks.afterEmit.callAsync(compilation, err => {
+                    if (err)
+                        return callback(err);
+                    return callback();
+                });
+            });
+        };
+        this.hooks.emit.callAsync(compilation, err => {
+            if (err)
+                return callback(err);
+            outputPath = compilation.getPath(this.outputPath, {});
+            (0, fs_1.mkdirp)(this.outputFileSystem, outputPath, emitFiles);
+        });
+    }
+    emitRecords(callback) {
+        if (this.hooks.emitRecords.isUsed()) {
+            if (this.recordsOutputPath) {
+                neo_async_1.default.parallel([cb => this.hooks.emitRecords.callAsync(cb), this._emitRecords.bind(this)], err => callback(err));
+            }
+            else {
+                this.hooks.emitRecords.callAsync(callback);
+            }
+        }
+        else if (this.recordsOutputPath) {
+            this._emitRecords(callback);
+        }
+        else {
+            callback();
+        }
+    }
+    _emitRecords(callback) {
+        const writeFile = () => {
+            this.outputFileSystem.writeFile(this.recordsOutputPath, JSON.stringify(this.records, (n, value) => {
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    const keys = Object.keys(value);
+                    if (!isSorted(keys)) {
+                        return sortObject(value, keys);
+                    }
+                }
+                return value;
+            }, 2), callback);
+        };
+        const recordsOutputPathDirectory = (0, fs_1.dirname)(this.outputFileSystem, this.recordsOutputPath);
+        if (!recordsOutputPathDirectory) {
+            return writeFile();
+        }
+        (0, fs_1.mkdirp)(this.outputFileSystem, recordsOutputPathDirectory, err => {
+            if (err)
+                return callback(err);
+            writeFile();
+        });
+    }
+    readRecords(callback) {
+        if (this.hooks.readRecords.isUsed()) {
+            if (this.recordsInputPath) {
+                neo_async_1.default.parallel([cb => this.hooks.readRecords.callAsync(cb), this._readRecords.bind(this)], err => callback(err));
+            }
+            else {
+                this.records = {};
+                this.hooks.readRecords.callAsync(callback);
+            }
+        }
+        else if (this.recordsInputPath) {
+            this._readRecords(callback);
+        }
+        else {
+            this.records = {};
+            callback();
+        }
+    }
+    _readRecords(callback) {
+        if (!this.recordsInputPath) {
+            this.records = {};
+            return callback();
+        }
+        this.inputFileSystem.stat(this.recordsInputPath, err => {
+            // It doesn't exist
+            // We can ignore this.
+            if (err)
+                return callback();
+            this.inputFileSystem.readFile(this.recordsInputPath, (err, content) => {
+                if (err)
+                    return callback(err);
+                try {
+                    this.records = (0, json_parse_even_better_errors_1.default)(content.toString('utf-8'));
+                }
+                catch (e) {
+                    return callback(new Error(`Cannot parse records: ${e.message}`));
+                }
+                return callback();
+            });
+        });
+    }
+    createChildCompiler(compilation, compilerName, compilerIndex, outputOptions, plugins) {
+        const childCompiler = new Compiler(this.project, this.packSetting, Object.assign(Object.assign({}, this.options), { output: Object.assign(Object.assign({}, this.options.output), outputOptions) }));
+        childCompiler.name = compilerName;
+        childCompiler.outputPath = this.outputPath;
+        childCompiler.inputFileSystem = this.inputFileSystem;
+        childCompiler.outputFileSystem = null;
+        childCompiler.resolverFactory = this.resolverFactory;
+        childCompiler.modifiedFiles = this.modifiedFiles;
+        childCompiler.removedFiles = this.removedFiles;
+        childCompiler.fileTimestamps = this.fileTimestamps;
+        childCompiler.contextTimestamps = this.contextTimestamps;
+        childCompiler.fsStartTime = this.fsStartTime;
+        childCompiler.cache = this.cache;
+        childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
+        const relativeCompilerName = (0, identifier_1.makePathsRelative)(this.context, compilerName, this.root);
+        if (!this.records[relativeCompilerName]) {
+            this.records[relativeCompilerName] = [];
+        }
+        if (this.records[relativeCompilerName][compilerIndex]) {
+            childCompiler.records = this.records[relativeCompilerName][compilerIndex];
+        }
+        else {
+            this.records[relativeCompilerName].push((childCompiler.records = {}));
+        }
+        childCompiler.parentCompilation = compilation;
+        childCompiler.root = this.root;
+        if (Array.isArray(plugins)) {
+            for (const plugin of plugins) {
+                if (plugin) {
+                    plugin.apply(childCompiler);
+                }
+            }
+        }
+        for (const name in this.hooks) {
+            if (!['make', 'compile', 'emit', 'afterEmit', 'invalid', 'done', 'thisCompilation'].includes(name)) {
+                if (childCompiler.hooks[name]) {
+                    childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
+                }
+            }
+        }
+        compilation.hooks.childCompiler.call(childCompiler, compilerName, compilerIndex);
+        return childCompiler;
+    }
+    isChild() {
+        return !!this.parentCompilation;
+    }
+    createCompilation(params) {
+        this._cleanupLastCompilation();
+        this._lastCompilation = new Compilation_1.default(this, params);
+        return this._lastCompilation;
+    }
+    newCompilation(params) {
+        const compilation = this.createCompilation(params);
+        compilation.name = this.name;
+        compilation.records = this.records;
+        this.hooks.thisCompilation.call(compilation, params);
+        this.hooks.compilation.call(compilation, params);
+        return compilation;
+    }
+    createNormalModuleFactory() {
+        this._cleanupLastNormalModuleFactory();
+        const normalModuleFactory = new NormalModuleFactory_1.default({
+            context: this.options.context,
+            fs: this.inputFileSystem,
+            resolverFactory: this.resolverFactory,
+            options: this.options.module,
+            associatedObjectForCache: this.root,
+            layers: this.options.experiments.layers,
+        });
+        this._lastNormalModuleFactory = normalModuleFactory;
+        this.hooks.normalModuleFactory.call(normalModuleFactory);
+        return normalModuleFactory;
+    }
+    createContextModuleFactory() {
+        const contextModuleFactory = new ContextModuleFactory_1.default(this.resolverFactory);
+        this.hooks.contextModuleFactory.call(contextModuleFactory);
+        return contextModuleFactory;
+    }
+    newCompilationParams() {
+        const params = {
+            normalModuleFactory: this.createNormalModuleFactory(),
+            contextModuleFactory: this.createContextModuleFactory(),
+        };
+        return params;
+    }
+    compile(callback) {
+        const params = this.newCompilationParams();
+        this.hooks.beforeCompile.callAsync(params, err => {
+            if (err)
+                return callback(err);
+            this.hooks.compile.call(params);
+            const compilation = this.newCompilation(params);
+            const logger = compilation.getLogger('webpack.Compiler');
+            logger.time('make hook');
+            this.hooks.make.callAsync(compilation, err => {
+                logger.timeEnd('make hook');
+                if (err)
+                    return callback(err);
+                logger.time('finish make hook');
+                this.hooks.finishMake.callAsync(compilation, err => {
+                    logger.timeEnd('finish make hook');
+                    if (err)
+                        return callback(err);
+                    process.nextTick(() => {
+                        logger.time('finish compilation');
+                        compilation.finish(err => {
+                            logger.timeEnd('finish compilation');
+                            if (err)
+                                return callback(err);
+                            logger.time('seal compilation');
+                            compilation.seal(err => {
+                                logger.timeEnd('seal compilation');
+                                if (err)
+                                    return callback(err);
+                                logger.time('afterCompile hook');
+                                this.hooks.afterCompile.callAsync(compilation, err => {
+                                    logger.timeEnd('afterCompile hook');
+                                    if (err)
+                                        return callback(err);
+                                    return callback(null, compilation);
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    }
+    close(callback) {
+        if (this.watching) {
+            // When there is still an active watching, close this first
+            this.watching.close(err => {
+                this.close(callback);
+            });
+            return;
+        }
+        this.hooks.shutdown.callAsync(err => {
+            if (err)
+                return callback(err);
+            this._lastCompilation = undefined;
+            this._lastNormalModuleFactory = undefined;
+            this.cache.shutdown(callback);
+        });
+    }
+}
+exports.default = Compiler;