xhs-mp-pack 1.1.0-beta.0

package/dist/module/NormalModule.js

@@ -0,0 +1,904 @@
+"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 loader_runner_1 = require("loader-runner");
+const querystring_1 = __importDefault(require("querystring"));
+const tapable_1 = require("tapable");
+const webpack_sources_1 = require("webpack-sources");
+const HookBaseError_1 = require("@/base/errors/HookBaseError");
+const ModuleBuildError_1 = __importDefault(require("@/base/errors/ModuleBuildError"));
+const ModuleError_1 = __importDefault(require("@/base/errors/ModuleError"));
+const ModuleParseError_1 = __importDefault(require("@/base/errors/ModuleParseError"));
+const ModuleWarning_1 = __importDefault(require("@/base/errors/ModuleWarning"));
+const UnhandledSchemeError_1 = __importDefault(require("@/base/errors/UnhandledSchemeError"));
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const formatLocation_1 = __importDefault(require("@/base/formatLocation"));
+const LazySet_1 = __importDefault(require("@/base/LazySet"));
+const SetHelpers_1 = require("@/base/SetHelpers");
+const URLAbsoluteSpecifier_1 = require("@/base/URLAbsoluteSpecifier");
+const comparators_1 = require("@/base/comparators");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const deprecation_1 = require("@/base/deprecation");
+const fs_1 = require("@/base/fs");
+const identifier_1 = require("@/base/identifier");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const memoize_1 = __importDefault(require("@/base/memoize"));
+const InvalidDependenciesModuleWarning_1 = __importDefault(require("@/base/errors/InvalidDependenciesModuleWarning"));
+const RuntimeGlobals = __importStar(require("./RuntimeGlobals"));
+const ModuleTypeConstants_1 = require("./ModuleTypeConstants");
+const ModuleGraphConnection_1 = require("./ModuleGraphConnection");
+const Module_1 = __importDefault(require("./Module"));
+const Compilation_1 = __importDefault(require("../Compilation"));
+const parseJson = require('json-parse-even-better-errors');
+const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
+const contextifySourceUrl = (context, source, associatedObjectForCache) => {
+    if (source.startsWith('webpack://'))
+        return source;
+    return `webpack://${(0, identifier_1.makePathsRelative)(context, source, associatedObjectForCache)}`;
+};
+const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
+    if (!Array.isArray(sourceMap.sources))
+        return sourceMap;
+    const { sourceRoot } = sourceMap;
+    const mapper = !sourceRoot
+        ? source => source
+        : sourceRoot.endsWith('/')
+            ? source => source.startsWith('/') ? `${sourceRoot.slice(0, -1)}${source}` : `${sourceRoot}${source}`
+            : source => (source.startsWith('/') ? `${sourceRoot}${source}` : `${sourceRoot}/${source}`);
+    const newSources = sourceMap.sources.map(source => contextifySourceUrl(context, mapper(source), associatedObjectForCache));
+    return Object.assign(Object.assign({}, sourceMap), { file: 'x', sourceRoot: undefined, sources: newSources });
+};
+const asString = (input) => {
+    if (Buffer.isBuffer(input)) {
+        return input.toString('utf-8');
+    }
+    return input;
+};
+const asBuffer = (input) => {
+    if (!Buffer.isBuffer(input)) {
+        return Buffer.from(input, 'utf-8');
+    }
+    return input;
+};
+class NonErrorEmittedError extends BaseError_1.default {
+    constructor(error) {
+        super();
+        this.name = 'NonErrorEmittedError';
+        this.message = `(Emitted value instead of an instance of Error) ${error}`;
+    }
+}
+(0, makeSerializable_1.default)(NonErrorEmittedError, 'mp-compiler/core/module/NormalModule', 'NonErrorEmittedError');
+const compilationHooksMap = new WeakMap();
+class NormalModule extends Module_1.default {
+    static getCompilationHooks(compilation) {
+        if (!(compilation instanceof Compilation_1.default)) {
+            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
+        }
+        let hooks = compilationHooksMap.get(compilation);
+        if (hooks === undefined) {
+            hooks = {
+                loader: new tapable_1.SyncHook(['loaderContext', 'module']),
+                beforeLoaders: new tapable_1.SyncHook(['loaders', 'module', 'loaderContext']),
+                beforeParse: new tapable_1.SyncHook(['module']),
+                beforeSnapshot: new tapable_1.SyncHook(['module']),
+                // TODO webpack 6 deprecate
+                readResourceForScheme: new tapable_1.HookMap(scheme => {
+                    const hook = hooks.readResource.for(scheme);
+                    return (0, deprecation_1.createFakeHook)({
+                        tap: (options, fn) => hook.tap(options, loaderContext => fn(loaderContext.resource, loaderContext._module)),
+                        tapAsync: (options, fn) => hook.tapAsync(options, (loaderContext, callback) => fn(loaderContext.resource, loaderContext._module, callback)),
+                        tapPromise: (options, fn) => hook.tapPromise(options, loaderContext => fn(loaderContext.resource, loaderContext._module)),
+                    });
+                }),
+                readResource: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(['loaderContext'])),
+                needBuild: new tapable_1.AsyncSeriesBailHook(['module', 'context']),
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+    constructor({ layer, type, request, userRequest, rawRequest, loaders, resource, resourceResolveData, context, matchResource, parser, parserOptions, generator, generatorOptions, resolveOptions, }) {
+        super(type, context || (0, loader_runner_1.getContext)(resource), layer);
+        this.type = '';
+        // Info from Factory
+        this.request = request;
+        this.userRequest = userRequest;
+        this.rawRequest = rawRequest;
+        this.binary = /^(asset|webassembly)\b/.test(type);
+        this.parser = parser;
+        this.parserOptions = parserOptions;
+        this.generator = generator;
+        this.generatorOptions = generatorOptions;
+        this.resource = resource;
+        this.resourceResolveData = resourceResolveData;
+        this.matchResource = matchResource;
+        this.loaders = loaders;
+        if (resolveOptions !== undefined) {
+            // already declared in super class
+            this.resolveOptions = resolveOptions;
+        }
+        // Info from Build
+        this.error = null;
+        this._source = null;
+        this._sourceSizes = undefined;
+        this._sourceTypes = undefined;
+        // Cache
+        this._lastSuccessfulBuildMeta = {};
+        this._forceBuild = true;
+        this._isEvaluatingSideEffects = false;
+        this._addedSideEffectsBailout = undefined;
+        this._codeGeneratorData = new Map();
+    }
+    identifier() {
+        if (this.layer === null) {
+            if (this.type === ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO) {
+                return this.request;
+            }
+            return `${this.type}|${this.request}`;
+        }
+        return `${this.type}|${this.request}|${this.layer}`;
+    }
+    readableIdentifier(requestShortener) {
+        return requestShortener.shorten(this.userRequest);
+    }
+    libIdent(options) {
+        let ident = (0, identifier_1.contextify)(options.context, this.userRequest, options.associatedObjectForCache);
+        if (this.layer)
+            ident = `(${this.layer})/${ident}`;
+        return ident;
+    }
+    nameForCondition() {
+        const resource = this.matchResource || this.resource;
+        const idx = resource.indexOf('?');
+        if (idx >= 0)
+            return resource.slice(0, idx);
+        return resource;
+    }
+    updateCacheModule(module) {
+        super.updateCacheModule(module);
+        const m = module;
+        this.binary = m.binary;
+        this.request = m.request;
+        this.userRequest = m.userRequest;
+        this.rawRequest = m.rawRequest;
+        this.parser = m.parser;
+        this.parserOptions = m.parserOptions;
+        this.generator = m.generator;
+        this.generatorOptions = m.generatorOptions;
+        this.resource = m.resource;
+        this.resourceResolveData = m.resourceResolveData;
+        this.context = m.context;
+        this.matchResource = m.matchResource;
+        this.loaders = m.loaders;
+    }
+    /**
+     * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+     */
+    cleanupForCache() {
+        // Make sure to cache types and sizes before cleanup when this module has been built
+        // They are accessed by the stats and we don't want them to crash after cleanup
+        // TODO reconsider this for webpack 6
+        if (this.buildInfo) {
+            if (this._sourceTypes === undefined)
+                this.getSourceTypes();
+            for (const type of this._sourceTypes) {
+                this.size(type);
+            }
+        }
+        super.cleanupForCache();
+        this.parser = undefined;
+        this.parserOptions = undefined;
+        this.generator = undefined;
+        this.generatorOptions = undefined;
+    }
+    getUnsafeCacheData() {
+        const data = super.getUnsafeCacheData();
+        data.parserOptions = this.parserOptions;
+        data.generatorOptions = this.generatorOptions;
+        return data;
+    }
+    restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+        this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+    }
+    _restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+        super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+        this.parserOptions = unsafeCacheData.parserOptions;
+        this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);
+        this.generatorOptions = unsafeCacheData.generatorOptions;
+        this.generator = normalModuleFactory.getGenerator(this.type, this.generatorOptions);
+        // we assume the generator behaves identically and keep cached sourceTypes/Sizes
+    }
+    createSourceForAsset(context, name, content, sourceMap, associatedObjectForCache) {
+        if (sourceMap) {
+            if (typeof sourceMap === 'string' && (this.useSourceMap || this.useSimpleSourceMap)) {
+                return new webpack_sources_1.OriginalSource(content, contextifySourceUrl(context, sourceMap, associatedObjectForCache));
+            }
+            if (this.useSourceMap) {
+                return new webpack_sources_1.SourceMapSource(content, name, contextifySourceMap(context, sourceMap, associatedObjectForCache));
+            }
+        }
+        return new webpack_sources_1.RawSource(content);
+    }
+    _createLoaderContext(resolver, options, compilation, fs, hooks) {
+        const { requestShortener } = compilation.runtimeTemplate;
+        const getCurrentLoaderName = () => {
+            const currentLoader = this.getCurrentLoader(loaderContext);
+            if (!currentLoader)
+                return '(not in loader scope)';
+            return requestShortener.shorten(currentLoader.loader);
+        };
+        const getResolveContext = () => ({
+            fileDependencies: {
+                add: d => loaderContext.addDependency(d),
+            },
+            contextDependencies: {
+                add: d => loaderContext.addContextDependency(d),
+            },
+            missingDependencies: {
+                add: d => loaderContext.addMissingDependency(d),
+            },
+        });
+        const getAbsolutify = (0, memoize_1.default)(() => identifier_1.absolutify.bindCache(compilation.compiler.root));
+        const getAbsolutifyInContext = (0, memoize_1.default)(() => identifier_1.absolutify.bindContextCache(this.context, compilation.compiler.root));
+        const getContextify = (0, memoize_1.default)(() => identifier_1.contextify.bindCache(compilation.compiler.root));
+        const getContextifyInContext = (0, memoize_1.default)(() => identifier_1.contextify.bindContextCache(this.context, compilation.compiler.root));
+        const utils = {
+            absolutify: (context, request) => context === this.context
+                ? getAbsolutifyInContext()(request)
+                : getAbsolutify()(context, request),
+            contextify: (context, request) => context === this.context
+                ? getContextifyInContext()(request)
+                : getContextify()(context, request),
+            createHash: type => (0, createHash_1.default)(type || compilation.outputOptions.hashFunction),
+        };
+        const loaderContext = {
+            version: 2,
+            getOptions: schema => {
+                const loader = this.getCurrentLoader(loaderContext);
+                let { options } = loader;
+                if (typeof options === 'string') {
+                    if (options.startsWith('{') && options.endsWith('}')) {
+                        try {
+                            options = parseJson(options);
+                        }
+                        catch (e) {
+                            throw new Error(`Cannot parse string options: ${e.message}`);
+                        }
+                    }
+                    else {
+                        options = querystring_1.default.parse(options, '&', '=', {
+                            maxKeys: 0,
+                        });
+                    }
+                }
+                if (options === null || options === undefined) {
+                    options = {};
+                }
+                // if (schema) {
+                //   let name = 'Loader'
+                //   let baseDataPath = 'options'
+                //   let match
+                //   if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
+                //     ;[, name, baseDataPath] = match
+                //   }
+                //   getValidate()(schema, options, {
+                //     name,
+                //     baseDataPath,
+                //   })
+                // }
+                return options;
+            },
+            emitWarning: warning => {
+                if (!(warning instanceof Error)) {
+                    warning = new NonErrorEmittedError(warning);
+                }
+                this.addWarning(new ModuleWarning_1.default(warning, {
+                    from: getCurrentLoaderName(),
+                }));
+            },
+            emitError: error => {
+                if (!(error instanceof Error)) {
+                    error = new NonErrorEmittedError(error);
+                }
+                this.addError(new ModuleError_1.default(error, {
+                    from: getCurrentLoaderName(),
+                }));
+            },
+            getLogger: name => {
+                const currentLoader = this.getCurrentLoader(loaderContext);
+                return compilation.getLogger(() => [currentLoader === null || currentLoader === void 0 ? void 0 : currentLoader.loader, name, this.identifier()].filter(Boolean).join('|'));
+            },
+            resolve(context, request, callback) {
+                resolver.resolve({}, context, request, getResolveContext(), callback);
+            },
+            getResolve(options) {
+                const child = options ? resolver.withOptions(options) : resolver;
+                return (context, request, callback) => {
+                    if (callback) {
+                        child.resolve({}, context, request, getResolveContext(), callback);
+                    }
+                    else {
+                        return new Promise((resolve, reject) => {
+                            child.resolve({}, context, request, getResolveContext(), (err, result) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve(result);
+                            });
+                        });
+                    }
+                };
+            },
+            emitFile: (name, content, sourceMap, assetInfo) => {
+                if (!this.buildInfo.assets) {
+                    this.buildInfo.assets = Object.create(null);
+                    this.buildInfo.assetsInfo = new Map();
+                }
+                this.buildInfo.assets[name] = this.createSourceForAsset(options.context, name, content, sourceMap, compilation.compiler.root);
+                this.buildInfo.assetsInfo.set(name, assetInfo);
+            },
+            addBuildDependency: dep => {
+                if (this.buildInfo.buildDependencies === undefined) {
+                    this.buildInfo.buildDependencies = new LazySet_1.default();
+                }
+                this.buildInfo.buildDependencies.add(dep);
+            },
+            utils,
+            rootContext: options.context,
+            webpack: true,
+            sourceMap: !!this.useSourceMap,
+            mode: options.mode || 'production',
+            _module: this,
+            _compilation: compilation,
+            _compiler: compilation.compiler,
+            fs,
+        };
+        Object.assign(loaderContext, options.loader);
+        hooks.loader.call(loaderContext, this);
+        return loaderContext;
+    }
+    getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
+        var _a;
+        if (((_a = this.loaders) === null || _a === void 0 ? void 0 : _a.length) && index < this.loaders.length && index >= 0 && this.loaders[index]) {
+            return this.loaders[index];
+        }
+        return null;
+    }
+    createSource(context, content, sourceMap, associatedObjectForCache) {
+        if (Buffer.isBuffer(content)) {
+            // @ts-ignore
+            return new webpack_sources_1.RawSource(content);
+        }
+        // if there is no identifier return raw source
+        if (!this.identifier) {
+            return new webpack_sources_1.RawSource(content);
+        }
+        // from here on we assume we have an identifier
+        const identifier = this.identifier();
+        if (this.useSourceMap && sourceMap) {
+            return new webpack_sources_1.SourceMapSource(content, contextifySourceUrl(context, identifier, associatedObjectForCache), contextifySourceMap(context, sourceMap, associatedObjectForCache));
+        }
+        if (this.useSourceMap || this.useSimpleSourceMap) {
+            return new webpack_sources_1.OriginalSource(content, contextifySourceUrl(context, identifier, associatedObjectForCache));
+        }
+        return new webpack_sources_1.RawSource(content);
+    }
+    _doBuild(options, compilation, resolver, fs, hooks, callback) {
+        const loaderContext = this._createLoaderContext(resolver, options, compilation, fs, hooks);
+        const processResult = (err, result) => {
+            if (err) {
+                if (!(err instanceof Error)) {
+                    err = new NonErrorEmittedError(err);
+                }
+                const currentLoader = this.getCurrentLoader(loaderContext);
+                const error = new ModuleBuildError_1.default(err, {
+                    from: currentLoader &&
+                        compilation.runtimeTemplate.requestShortener.shorten(currentLoader.loader),
+                });
+                return callback(error);
+            }
+            const source = result[0];
+            const sourceMap = result.length >= 1 ? result[1] : null;
+            const extraInfo = result.length >= 2 ? result[2] : null;
+            if (!Buffer.isBuffer(source) && typeof source !== 'string') {
+                const currentLoader = this.getCurrentLoader(loaderContext, 0);
+                const err = new Error(`Final loader (${currentLoader
+                    ? compilation.runtimeTemplate.requestShortener.shorten(currentLoader.loader)
+                    : 'unknown'}) didn't return a Buffer or String`);
+                const error = new ModuleBuildError_1.default(err);
+                return callback(error);
+            }
+            this._source = this.createSource(options.context, this.binary ? asBuffer(source) : asString(source), sourceMap, compilation.compiler.root);
+            if (this._sourceSizes !== undefined)
+                this._sourceSizes.clear();
+            this._ast =
+                typeof extraInfo === 'object' && extraInfo !== null && extraInfo.webpackAST !== undefined
+                    ? extraInfo.webpackAST
+                    : null;
+            return callback();
+        };
+        this.buildInfo.fileDependencies = new LazySet_1.default();
+        this.buildInfo.contextDependencies = new LazySet_1.default();
+        this.buildInfo.missingDependencies = new LazySet_1.default();
+        this.buildInfo.cacheable = true;
+        try {
+            hooks.beforeLoaders.call(this.loaders, this, loaderContext);
+        }
+        catch (err) {
+            processResult(err);
+            return;
+        }
+        if (this.loaders.length > 0) {
+            this.buildInfo.buildDependencies = new LazySet_1.default();
+        }
+        (0, loader_runner_1.runLoaders)({
+            resource: this.resource,
+            loaders: this.loaders,
+            context: loaderContext,
+            processResource: (loaderContext, resourcePath, callback) => {
+                const resource = loaderContext.resource;
+                const scheme = (0, URLAbsoluteSpecifier_1.getScheme)(resource);
+                hooks.readResource.for(scheme).callAsync(loaderContext, (err, result) => {
+                    if (err)
+                        return callback(err);
+                    if (typeof result !== 'string' && !result) {
+                        return callback(new UnhandledSchemeError_1.default(scheme, resource));
+                    }
+                    return callback(null, result);
+                });
+            },
+        }, (err, result) => {
+            // Cleanup loaderContext to avoid leaking memory in ICs
+            loaderContext._compilation =
+                loaderContext._compiler =
+                    loaderContext._module =
+                        loaderContext.fs =
+                            undefined;
+            if (!result) {
+                this.buildInfo.cacheable = false;
+                return processResult(err || new Error('No result from loader-runner processing'), null);
+            }
+            this.buildInfo.fileDependencies.addAll(result.fileDependencies);
+            this.buildInfo.contextDependencies.addAll(result.contextDependencies);
+            this.buildInfo.missingDependencies.addAll(result.missingDependencies);
+            for (const loader of this.loaders) {
+                this.buildInfo.buildDependencies.add(loader.loader);
+            }
+            this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
+            processResult(err, result.result);
+        });
+    }
+    markModuleAsErrored(error) {
+        // Restore build meta from successful build to keep importing state
+        this.buildMeta = Object.assign({}, this._lastSuccessfulBuildMeta);
+        this.error = error;
+        this.addError(error);
+    }
+    applyNoParseRule(rule, content) {
+        // must start with "rule" if rule is a string
+        if (typeof rule === 'string') {
+            return content.startsWith(rule);
+        }
+        if (typeof rule === 'function') {
+            return rule(content);
+        }
+        // we assume rule is a regexp
+        return rule.test(content);
+    }
+    // check if module should not be parsed
+    // returns "true" if the module should !not! be parsed
+    // returns "false" if the module !must! be parsed
+    shouldPreventParsing(noParseRule, request) {
+        // if no noParseRule exists, return false
+        // the module !must! be parsed.
+        if (!noParseRule) {
+            return false;
+        }
+        // we only have one rule to check
+        if (!Array.isArray(noParseRule)) {
+            // returns "true" if the module is !not! to be parsed
+            return this.applyNoParseRule(noParseRule, request);
+        }
+        for (let i = 0; i < noParseRule.length; i++) {
+            const rule = noParseRule[i];
+            // early exit on first truthy match
+            // this module is !not! to be parsed
+            if (this.applyNoParseRule(rule, request)) {
+                return true;
+            }
+        }
+        // no match found, so this module !should! be parsed
+        return false;
+    }
+    _initBuildHash(compilation) {
+        const hash = (0, createHash_1.default)(compilation.outputOptions.hashFunction);
+        if (this._source) {
+            hash.update('source');
+            this._source.updateHash(hash);
+        }
+        hash.update('meta');
+        hash.update(JSON.stringify(this.buildMeta));
+        this.buildInfo.hash = hash.digest('hex');
+    }
+    build(options, compilation, resolver, fs, callback) {
+        this._forceBuild = false;
+        this._source = null;
+        if (this._sourceSizes !== undefined)
+            this._sourceSizes.clear();
+        this._sourceTypes = undefined;
+        this._ast = null;
+        this.error = null;
+        this.clearWarningsAndErrors();
+        this.clearDependenciesAndBlocks();
+        this.buildMeta = {};
+        this.buildInfo = {
+            cacheable: false,
+            parsed: true,
+            fileDependencies: undefined,
+            contextDependencies: undefined,
+            missingDependencies: undefined,
+            buildDependencies: undefined,
+            valueDependencies: undefined,
+            hash: undefined,
+            assets: undefined,
+            assetsInfo: undefined,
+        };
+        const startTime = compilation.compiler.fsStartTime || Date.now();
+        const hooks = NormalModule.getCompilationHooks(compilation);
+        return this._doBuild(options, compilation, resolver, fs, hooks, err => {
+            var _a;
+            // if we have an error mark module as failed and exit
+            if (err) {
+                this.markModuleAsErrored(err);
+                this._initBuildHash(compilation);
+                return callback();
+            }
+            const handleParseError = e => {
+                const source = this._source.source();
+                const loaders = this.loaders.map(item => (0, identifier_1.contextify)(options.context, item.loader, compilation.compiler.root));
+                const error = new ModuleParseError_1.default(source, e, loaders, this.type);
+                this.markModuleAsErrored(error);
+                this._initBuildHash(compilation);
+                return callback();
+            };
+            const handleParseResult = result => {
+                this.dependencies.sort((0, comparators_1.concatComparators)((0, comparators_1.compareSelect)(a => a.loc, comparators_1.compareLocations), (0, comparators_1.keepOriginalOrder)(this.dependencies)));
+                this._initBuildHash(compilation);
+                this._lastSuccessfulBuildMeta = this.buildMeta;
+                return handleBuildDone();
+            };
+            const handleBuildDone = () => {
+                try {
+                    hooks.beforeSnapshot.call(this);
+                }
+                catch (err) {
+                    this.markModuleAsErrored(err);
+                    return callback();
+                }
+                const snapshotOptions = compilation.options.snapshot.module;
+                if (!this.buildInfo.cacheable || !snapshotOptions) {
+                    return callback();
+                }
+                // add warning for all non-absolute paths in fileDependencies, etc
+                // This makes it easier to find problems with watching and/or caching
+                let nonAbsoluteDependencies;
+                const checkDependencies = deps => {
+                    for (const dep of deps) {
+                        if (!ABSOLUTE_PATH_REGEX.test(dep)) {
+                            if (nonAbsoluteDependencies === undefined)
+                                nonAbsoluteDependencies = new Set();
+                            nonAbsoluteDependencies.add(dep);
+                            deps.delete(dep);
+                            try {
+                                const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, '');
+                                const absolute = (0, fs_1.join)(compilation.fileSystemInfo.fs, this.context, depWithoutGlob);
+                                if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
+                                    ;
+                                    (depWithoutGlob !== dep ? this.buildInfo.contextDependencies : deps).add(absolute);
+                                }
+                            }
+                            catch (e) {
+                                // ignore
+                            }
+                        }
+                    }
+                };
+                checkDependencies(this.buildInfo.fileDependencies);
+                checkDependencies(this.buildInfo.missingDependencies);
+                checkDependencies(this.buildInfo.contextDependencies);
+                if (nonAbsoluteDependencies !== undefined) {
+                    this.addWarning(new InvalidDependenciesModuleWarning_1.default(this, nonAbsoluteDependencies));
+                }
+                // convert file/context/missingDependencies into filesystem snapshot
+                compilation.fileSystemInfo.createSnapshot(startTime, this.buildInfo.fileDependencies, this.buildInfo.contextDependencies, this.buildInfo.missingDependencies, snapshotOptions, (err, snapshot) => {
+                    if (err) {
+                        this.markModuleAsErrored(err);
+                        return;
+                    }
+                    this.buildInfo.fileDependencies = undefined;
+                    this.buildInfo.contextDependencies = undefined;
+                    this.buildInfo.missingDependencies = undefined;
+                    this.buildInfo.snapshot = snapshot;
+                    return callback();
+                });
+            };
+            try {
+                hooks.beforeParse.call(this);
+            }
+            catch (err) {
+                this.markModuleAsErrored(err);
+                this._initBuildHash(compilation);
+                return callback();
+            }
+            // check if this module should !not! be parsed.
+            // if so, exit here;
+            const noParseRule = (_a = options.module) === null || _a === void 0 ? void 0 : _a.noParse;
+            if (this.shouldPreventParsing(noParseRule, this.request)) {
+                // We assume that we need module and exports
+                this.buildInfo.parsed = false;
+                this._initBuildHash(compilation);
+                return handleBuildDone();
+            }
+            let result;
+            try {
+                const source = this._source.source();
+                result = this.parser.parse(this._ast || source, {
+                    source,
+                    current: this,
+                    module: this,
+                    compilation,
+                    options,
+                });
+            }
+            catch (e) {
+                handleParseError(e);
+                return;
+            }
+            handleParseResult(result);
+        });
+    }
+    getConcatenationBailoutReason(context) {
+        return this.generator.getConcatenationBailoutReason(this, context);
+    }
+    getSideEffectsConnectionState(moduleGraph) {
+        var _a;
+        if (this.factoryMeta !== undefined) {
+            if (this.factoryMeta.sideEffectFree)
+                return false;
+            if (this.factoryMeta.sideEffectFree === false)
+                return true;
+        }
+        if ((_a = this.buildMeta) === null || _a === void 0 ? void 0 : _a.sideEffectFree) {
+            if (this._isEvaluatingSideEffects)
+                return ModuleGraphConnection_1.CIRCULAR_CONNECTION;
+            this._isEvaluatingSideEffects = true;
+            let current = false;
+            for (const dep of this.dependencies) {
+                const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+                if (state === true) {
+                    if (this._addedSideEffectsBailout === undefined
+                        ? ((this._addedSideEffectsBailout = new WeakSet()), true)
+                        : !this._addedSideEffectsBailout.has(moduleGraph)) {
+                        this._addedSideEffectsBailout.add(moduleGraph);
+                        moduleGraph
+                            .getOptimizationBailout(this)
+                            .push(() => `Dependency (${dep.type}) with side effects at ${(0, formatLocation_1.default)(dep.loc)}`);
+                    }
+                    this._isEvaluatingSideEffects = false;
+                    return true;
+                }
+                if (state !== ModuleGraphConnection_1.CIRCULAR_CONNECTION) {
+                    current = (0, ModuleGraphConnection_1.addConnectionStates)(current, state);
+                }
+            }
+            this._isEvaluatingSideEffects = false;
+            // When caching is implemented here, make sure to not cache when
+            // at least one circular connection was in the loop above
+            return current;
+        }
+        return true;
+    }
+    getSourceTypes() {
+        if (this._sourceTypes === undefined) {
+            this._sourceTypes = this.generator.getTypes(this);
+        }
+        return this._sourceTypes;
+    }
+    codeGeneration({ dependencyTemplates, runtimeTemplate, moduleGraph, chunkGraph, runtime, concatenationScope, codeGenerationResults, sourceTypes, }) {
+        const runtimeRequirements = new Set();
+        if (!this.buildInfo.parsed) {
+            runtimeRequirements.add(RuntimeGlobals.module);
+            runtimeRequirements.add(RuntimeGlobals.exports);
+            runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+        }
+        const getData = () => this._codeGeneratorData;
+        const sources = new Map();
+        for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
+            const source = this.error
+                ? new webpack_sources_1.RawSource(`throw new Error(${JSON.stringify(this.error.message)});`)
+                : this.generator.generate(this, {
+                    dependencyTemplates,
+                    runtimeTemplate,
+                    moduleGraph,
+                    chunkGraph,
+                    runtimeRequirements,
+                    runtime,
+                    concatenationScope,
+                    codeGenerationResults,
+                    getData,
+                    type,
+                });
+            if (source) {
+                sources.set(type, new webpack_sources_1.CachedSource(source));
+            }
+        }
+        const resultEntry = {
+            sources,
+            runtimeRequirements,
+            data: this._codeGeneratorData,
+        };
+        return resultEntry;
+    }
+    originalSource() {
+        return this._source;
+    }
+    invalidateBuild() {
+        this._forceBuild = true;
+    }
+    needBuild(context, callback) {
+        const { fileSystemInfo, compilation, valueCacheVersions } = context;
+        // build if enforced
+        if (this._forceBuild)
+            return callback(null, true);
+        // always try to build in case of an error
+        if (this.error)
+            return callback(null, true);
+        // always build when module is not cacheable
+        if (!this.buildInfo.cacheable)
+            return callback(null, true);
+        // build when there is no snapshot to check
+        if (!this.buildInfo.snapshot)
+            return callback(null, true);
+        // build when valueDependencies have changed
+        const valueDependencies = this.buildInfo.valueDependencies;
+        if (valueDependencies) {
+            if (!valueCacheVersions)
+                return callback(null, true);
+            for (const [key, value] of valueDependencies) {
+                if (value === undefined)
+                    return callback(null, true);
+                const current = valueCacheVersions.get(key);
+                if (value !== current &&
+                    (typeof value === 'string' ||
+                        typeof current === 'string' ||
+                        current === undefined ||
+                        !(0, SetHelpers_1.isSubset)(value, current))) {
+                    return callback(null, true);
+                }
+            }
+        }
+        // check snapshot for validity
+        fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+            if (err)
+                return callback(err);
+            if (!valid) {
+                console.log('没命中缓存', this.identifier());
+                return callback(null, true);
+            }
+            console.log('命中缓存', this.identifier());
+            const hooks = NormalModule.getCompilationHooks(compilation);
+            hooks.needBuild.callAsync(this, context, (err, needBuild) => {
+                if (err) {
+                    return callback((0, HookBaseError_1.makeBaseError)(err, 'NormalModule.getCompilationHooks().needBuild'));
+                }
+                callback(null, !!needBuild);
+            });
+        });
+    }
+    size(type) {
+        const cachedSize = this._sourceSizes === undefined ? undefined : this._sourceSizes.get(type);
+        if (cachedSize !== undefined) {
+            return cachedSize;
+        }
+        const size = Math.max(1, this.generator.getSize(this, type));
+        if (this._sourceSizes === undefined) {
+            this._sourceSizes = new Map();
+        }
+        this._sourceSizes.set(type, size);
+        return size;
+    }
+    addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies) {
+        const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
+        if (snapshot) {
+            fileDependencies.addAll(snapshot.getFileIterable());
+            contextDependencies.addAll(snapshot.getContextIterable());
+            missingDependencies.addAll(snapshot.getMissingIterable());
+        }
+        else {
+            const { fileDependencies: fileDeps, contextDependencies: contextDeps, missingDependencies: missingDeps, } = this.buildInfo;
+            if (fileDeps !== undefined)
+                fileDependencies.addAll(fileDeps);
+            if (contextDeps !== undefined)
+                contextDependencies.addAll(contextDeps);
+            if (missingDeps !== undefined)
+                missingDependencies.addAll(missingDeps);
+        }
+        if (buildDeps !== undefined) {
+            buildDependencies.addAll(buildDeps);
+        }
+    }
+    updateHash(hash, context) {
+        hash.update(this.buildInfo.hash);
+        this.generator.updateHash(hash, Object.assign({ module: this }, context));
+        super.updateHash(hash, context);
+    }
+    serialize(context) {
+        const { write } = context;
+        // deserialize
+        write(this._source);
+        write(this.error);
+        write(this._lastSuccessfulBuildMeta);
+        write(this._forceBuild);
+        write(this._codeGeneratorData);
+        super.serialize(context);
+    }
+    static deserialize(context) {
+        const obj = new NormalModule({
+            // will be deserialized by Module
+            layer: null,
+            type: '',
+            // will be filled by updateCacheModule
+            resource: '',
+            context: '',
+            request: null,
+            userRequest: null,
+            rawRequest: null,
+            loaders: null,
+            matchResource: null,
+            parser: null,
+            parserOptions: null,
+            generator: null,
+            generatorOptions: null,
+            resolveOptions: null,
+            resourceResolveData: null,
+        });
+        obj.deserialize(context);
+        return obj;
+    }
+    deserialize(context) {
+        const { read } = context;
+        this._source = read();
+        this.error = read();
+        this._lastSuccessfulBuildMeta = read();
+        this._forceBuild = read();
+        this._codeGeneratorData = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(NormalModule, 'mp-compiler/core/module/NormalModule');
+exports.default = NormalModule;