xhs-mp-pack 1.1.0-beta.0

package/dist/module/NormalModuleFactory.js

@@ -0,0 +1,761 @@
+"use strict";
+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 neo_async_1 = __importDefault(require("neo-async"));
+const tapable_1 = require("tapable");
+const ChunkGraph_1 = __importDefault(require("@/chunk/ChunkGraph"));
+const NormalModule_1 = __importDefault(require("@/module/NormalModule"));
+const BasicEffectRulePlugin_1 = __importDefault(require("@/rules/BasicEffectRulePlugin"));
+const BasicMatcherRulePlugin_1 = __importDefault(require("@/rules/BasicMatcherRulePlugin"));
+const ObjectMatcherRulePlugin_1 = __importDefault(require("@/rules/ObjectMatcherRulePlugin"));
+const RuleSetCompiler_1 = __importDefault(require("@/rules/RuleSetCompiler"));
+const UseEffectRulePlugin_1 = __importDefault(require("@/rules/UseEffectRulePlugin"));
+const LazySet_1 = __importDefault(require("@/base/LazySet"));
+const URLAbsoluteSpecifier_1 = require("@/base/URLAbsoluteSpecifier");
+const cleverMerge_1 = require("@/base/cleverMerge");
+const fs_1 = require("@/base/fs");
+const identifier_1 = require("@/base/identifier");
+const ModuleTypeConstants_1 = require("./ModuleTypeConstants");
+const ModuleGraph_1 = __importDefault(require("./ModuleGraph"));
+const ModuleFactory_1 = __importDefault(require("./ModuleFactory"));
+const Module_1 = __importDefault(require("./Module"));
+const EMPTY_RESOLVE_OPTIONS = {};
+const EMPTY_PARSER_OPTIONS = {};
+const EMPTY_GENERATOR_OPTIONS = {};
+const EMPTY_ELEMENTS = [];
+const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
+const LEADING_DOT_EXTENSION_REGEX = /^[^.]/;
+const loaderToIdent = data => {
+    if (!data.options) {
+        return data.loader;
+    }
+    if (typeof data.options === 'string') {
+        return `${data.loader}?${data.options}`;
+    }
+    if (typeof data.options !== 'object') {
+        throw new Error('loader options must be string or object');
+    }
+    if (data.ident) {
+        return `${data.loader}??${data.ident}`;
+    }
+    return `${data.loader}?${JSON.stringify(data.options)}`;
+};
+const stringifyLoadersAndResource = (loaders, resource) => {
+    let str = '';
+    for (const loader of loaders) {
+        str += `${loaderToIdent(loader)}!`;
+    }
+    return str + resource;
+};
+const needCalls = (times, callback) => (err) => {
+    if (--times === 0) {
+        return callback(err);
+    }
+    if (err && times > 0) {
+        times = NaN;
+        return callback(err);
+    }
+};
+const mergeGlobalOptions = (globalOptions, type, localOptions) => {
+    const parts = type.split('/');
+    let result;
+    let current = '';
+    for (const part of parts) {
+        current = current ? `${current}/${part}` : part;
+        const options = globalOptions[current];
+        if (typeof options === 'object') {
+            if (result === undefined) {
+                result = options;
+            }
+            else {
+                result = (0, cleverMerge_1.cachedCleverMerge)(result, options);
+            }
+        }
+    }
+    if (result === undefined) {
+        return localOptions;
+    }
+    return (0, cleverMerge_1.cachedCleverMerge)(result, localOptions);
+};
+// TODO webpack 6 remove
+const deprecationChangedHookMessage = (name, hook) => {
+    const names = hook.taps
+        .map(tapped => tapped.name)
+        .join(', ');
+    return (`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
+        'Do not return the passed object, but modify it instead. ' +
+        'Returning false will ignore the request and results in no module created.');
+};
+const ruleSetCompiler = new RuleSetCompiler_1.default([
+    new BasicMatcherRulePlugin_1.default('test', 'resource'),
+    new BasicMatcherRulePlugin_1.default('scheme'),
+    new BasicMatcherRulePlugin_1.default('mimetype'),
+    new BasicMatcherRulePlugin_1.default('dependency'),
+    new BasicMatcherRulePlugin_1.default('include', 'resource'),
+    new BasicMatcherRulePlugin_1.default('exclude', 'resource', true),
+    new BasicMatcherRulePlugin_1.default('resource'),
+    new BasicMatcherRulePlugin_1.default('resourceQuery'),
+    new BasicMatcherRulePlugin_1.default('resourceFragment'),
+    new BasicMatcherRulePlugin_1.default('realResource'),
+    new BasicMatcherRulePlugin_1.default('issuer'),
+    new BasicMatcherRulePlugin_1.default('compiler'),
+    new BasicMatcherRulePlugin_1.default('issuerLayer'),
+    new ObjectMatcherRulePlugin_1.default('assert', 'assertions'),
+    new ObjectMatcherRulePlugin_1.default('descriptionData'),
+    new BasicEffectRulePlugin_1.default('type'),
+    new BasicEffectRulePlugin_1.default('sideEffects'),
+    new BasicEffectRulePlugin_1.default('parser'),
+    new BasicEffectRulePlugin_1.default('resolve'),
+    new BasicEffectRulePlugin_1.default('generator'),
+    new BasicEffectRulePlugin_1.default('layer'),
+    new UseEffectRulePlugin_1.default(),
+]);
+class NormalModuleFactory extends ModuleFactory_1.default {
+    constructor({ context = '', fs, resolverFactory, options, associatedObjectForCache = {}, layers = false, }) {
+        super();
+        this.hooks = Object.freeze({
+            resolve: new tapable_1.AsyncSeriesBailHook(['resolveData']),
+            resolveForScheme: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(['resourceData', 'resolveData'])),
+            resolveInScheme: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(['resourceData', 'resolveData'])),
+            factorize: new tapable_1.AsyncSeriesBailHook(['resolveData']),
+            beforeResolve: new tapable_1.AsyncSeriesBailHook(['resolveData']),
+            afterResolve: new tapable_1.AsyncSeriesBailHook(['resolveData']),
+            createModule: new tapable_1.AsyncSeriesBailHook(['createData', 'resolveData']),
+            module: new tapable_1.SyncWaterfallHook(['module', 'createData', 'resolveData']),
+            createParser: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['parserOptions'])),
+            parser: new tapable_1.HookMap(() => new tapable_1.SyncHook(['parser', 'parserOptions'])),
+            createGenerator: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['generatorOptions'])),
+            generator: new tapable_1.HookMap(() => new tapable_1.SyncHook(['generator', 'generatorOptions'])),
+            createModuleClass: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['createData', 'resolveData'])),
+        });
+        this.resolverFactory = resolverFactory;
+        this.ruleSet = ruleSetCompiler.compile([
+            {
+                rules: options.defaultRules,
+            },
+            {
+                rules: options.rules,
+            },
+        ]);
+        this.context = context || '';
+        this.fs = fs;
+        this._globalParserOptions = options.parser;
+        this._globalGeneratorOptions = options.generator;
+        this.parserCache = new Map();
+        this.generatorCache = new Map();
+        this._restoredUnsafeCacheEntries = new Set();
+        const cacheParseResource = identifier_1.parseResource.bindCache(associatedObjectForCache);
+        const cachedParseResourceWithoutFragment = identifier_1.parseResourceWithoutFragment.bindCache(associatedObjectForCache);
+        this._parseResourceWithoutFragment = cachedParseResourceWithoutFragment;
+        this.hooks.factorize.tapAsync({
+            name: 'NormalModuleFactory',
+            stage: 100,
+        }, (resolveData, callback) => {
+            this.hooks.resolve.callAsync(resolveData, (err, result) => {
+                if (err)
+                    return callback(err);
+                // Ignored
+                if (result === false)
+                    return callback();
+                // direct module
+                if (result instanceof Module_1.default)
+                    return callback(null, result);
+                if (typeof result === 'object')
+                    throw new Error(`${deprecationChangedHookMessage('resolve', this.hooks.resolve)} Returning a Module object will result in this module used as result.`);
+                this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
+                    if (err)
+                        return callback(err);
+                    if (typeof result === 'object')
+                        throw new Error(deprecationChangedHookMessage('afterResolve', this.hooks.afterResolve));
+                    // Ignored
+                    if (result === false)
+                        return callback();
+                    const createData = resolveData.createData;
+                    this.hooks.createModule.callAsync(createData, resolveData, (err, createdModule) => {
+                        if (!createdModule) {
+                            if (!resolveData.request) {
+                                return callback(new Error('Empty dependency (no request)'));
+                            }
+                            // TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
+                            createdModule = this.hooks.createModuleClass
+                                .for(createData.settings.type)
+                                .call(createData, resolveData);
+                            if (!createdModule) {
+                                createdModule = new NormalModule_1.default(createData);
+                            }
+                        }
+                        createdModule = this.hooks.module.call(createdModule, createData, resolveData);
+                        return callback(null, createdModule);
+                    });
+                });
+            });
+        });
+        this.hooks.resolve.tapAsync({
+            name: 'NormalModuleFactory',
+            stage: 100,
+        }, (data, callback) => {
+            const { contextInfo, context, dependencies, dependencyType, request, assertions, resolveOptions, fileDependencies, missingDependencies, contextDependencies, } = data;
+            const loaderResolver = this.getResolver('loader');
+            let matchResourceData;
+            let unresolvedResource;
+            let elements;
+            let noPreAutoLoaders = false;
+            let noAutoLoaders = false;
+            let noPrePostAutoLoaders = false;
+            const contextScheme = (0, URLAbsoluteSpecifier_1.getScheme)(context);
+            let scheme = (0, URLAbsoluteSpecifier_1.getScheme)(request);
+            if (!scheme) {
+                let requestWithoutMatchResource = request;
+                const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
+                if (matchResourceMatch) {
+                    let matchResource = matchResourceMatch[1];
+                    if (matchResource.charCodeAt(0) === 46) {
+                        // 46 === ".", 47 === "/"
+                        const secondChar = matchResource.charCodeAt(1);
+                        if (secondChar === 47 || (secondChar === 46 && matchResource.charCodeAt(2) === 47)) {
+                            // if matchResources startsWith ../ or ./
+                            matchResource = (0, fs_1.join)(this.fs, context, matchResource);
+                        }
+                    }
+                    matchResourceData = Object.assign({ resource: matchResource }, cacheParseResource(matchResource));
+                    requestWithoutMatchResource = request.slice(matchResourceMatch[0].length);
+                }
+                scheme = (0, URLAbsoluteSpecifier_1.getScheme)(requestWithoutMatchResource);
+                if (!scheme && !contextScheme) {
+                    const firstChar = requestWithoutMatchResource.charCodeAt(0);
+                    const secondChar = requestWithoutMatchResource.charCodeAt(1);
+                    noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!"
+                    noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!"
+                    noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!";
+                    const rawElements = requestWithoutMatchResource
+                        .slice(noPreAutoLoaders || noPrePostAutoLoaders ? 2 : noAutoLoaders ? 1 : 0)
+                        .split(/!+/);
+                    unresolvedResource = rawElements.pop();
+                    elements = rawElements.map(el => {
+                        const { path, query } = cachedParseResourceWithoutFragment(el);
+                        return {
+                            loader: path,
+                            options: query ? query.slice(1) : undefined,
+                        };
+                    });
+                    scheme = (0, URLAbsoluteSpecifier_1.getScheme)(unresolvedResource);
+                }
+                else {
+                    unresolvedResource = requestWithoutMatchResource;
+                    elements = EMPTY_ELEMENTS;
+                }
+            }
+            else {
+                unresolvedResource = request;
+                elements = EMPTY_ELEMENTS;
+            }
+            const resolveContext = {
+                fileDependencies,
+                missingDependencies,
+                contextDependencies,
+            };
+            let resourceData;
+            let loaders;
+            const continueCallback = needCalls(2, (err) => {
+                if (err)
+                    return callback(err);
+                // translate option idents
+                try {
+                    for (const item of loaders) {
+                        if (typeof item.options === 'string' && item.options[0] === '?') {
+                            const ident = item.options.slice(1);
+                            if (ident === '[[missing ident]]') {
+                                throw new Error('No ident is provided by referenced loader. ' +
+                                    'When using a function for Rule.use in config you need to ' +
+                                    "provide an 'ident' property for referenced loader options.");
+                            }
+                            item.options = this.ruleSet.references.get(ident);
+                            if (item.options === undefined) {
+                                throw new Error('Invalid ident is provided by referenced loader');
+                            }
+                            item.ident = ident;
+                        }
+                    }
+                }
+                catch (e) {
+                    return callback(e);
+                }
+                if (!resourceData) {
+                    // ignored
+                    return callback(null, dependencies[0].createIgnoredModule(context));
+                }
+                const userRequest = (matchResourceData !== undefined ? `${matchResourceData.resource}!=!` : '') +
+                    stringifyLoadersAndResource(loaders, resourceData.resource);
+                const settings = {};
+                const useLoadersPost = [];
+                const useLoaders = [];
+                const useLoadersPre = [];
+                // handle .webpack[] suffix
+                let resource;
+                let match;
+                if (matchResourceData &&
+                    typeof (resource = matchResourceData.resource) === 'string' &&
+                    (match = /\.webpack\[([^\]]+)\]$/.exec(resource))) {
+                    settings.type = match[1];
+                    matchResourceData.resource = matchResourceData.resource.slice(0, -settings.type.length - 10);
+                }
+                else {
+                    settings.type = ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO;
+                    const resourceDataForRules = matchResourceData || resourceData;
+                    const result = this.ruleSet.exec({
+                        resource: resourceDataForRules.path,
+                        realResource: resourceData.path,
+                        resourceQuery: resourceDataForRules.query,
+                        resourceFragment: resourceDataForRules.fragment,
+                        scheme,
+                        assertions,
+                        mimetype: matchResourceData ? '' : resourceData.data.mimetype || '',
+                        dependency: dependencyType,
+                        descriptionData: matchResourceData
+                            ? undefined
+                            : resourceData.data.descriptionFileData,
+                        issuer: contextInfo.issuer,
+                        compiler: contextInfo.compiler,
+                        issuerLayer: contextInfo.issuerLayer || '',
+                    });
+                    for (const r of result) {
+                        // https://github.com/webpack/webpack/issues/16466
+                        // if a request exists PrePostAutoLoaders, should disable modifying Rule.type
+                        if (r.type === 'type' && noPrePostAutoLoaders) {
+                            continue;
+                        }
+                        if (r.type === 'use') {
+                            if (!noAutoLoaders && !noPrePostAutoLoaders) {
+                                useLoaders.push(r.value);
+                            }
+                        }
+                        else if (r.type === 'use-post') {
+                            if (!noPrePostAutoLoaders) {
+                                useLoadersPost.push(r.value);
+                            }
+                        }
+                        else if (r.type === 'use-pre') {
+                            if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
+                                useLoadersPre.push(r.value);
+                            }
+                        }
+                        else if (typeof r.value === 'object' &&
+                            r.value !== null &&
+                            typeof settings[r.type] === 'object' &&
+                            settings[r.type] !== null) {
+                            settings[r.type] = (0, cleverMerge_1.cachedCleverMerge)(settings[r.type], r.value);
+                        }
+                        else {
+                            settings[r.type] = r.value;
+                        }
+                    }
+                }
+                let postLoaders;
+                let normalLoaders;
+                let preLoaders;
+                const continueCallback = needCalls(3, err => {
+                    if (err) {
+                        return callback(err);
+                    }
+                    const allLoaders = postLoaders;
+                    if (matchResourceData === undefined) {
+                        for (const loader of loaders)
+                            allLoaders.push(loader);
+                        for (const loader of normalLoaders)
+                            allLoaders.push(loader);
+                    }
+                    else {
+                        for (const loader of normalLoaders)
+                            allLoaders.push(loader);
+                        for (const loader of loaders)
+                            allLoaders.push(loader);
+                    }
+                    for (const loader of preLoaders)
+                        allLoaders.push(loader);
+                    const type = settings.type;
+                    const resolveOptions = settings.resolve;
+                    const layer = settings.layer;
+                    if (layer !== undefined && !layers) {
+                        return callback(new Error("'Rule.layer' is only allowed when 'experiments.layers' is enabled"));
+                    }
+                    try {
+                        Object.assign(data.createData, {
+                            layer: layer === undefined ? contextInfo.issuerLayer || null : layer,
+                            request: stringifyLoadersAndResource(allLoaders, resourceData.resource),
+                            userRequest,
+                            rawRequest: request,
+                            loaders: allLoaders,
+                            resource: resourceData.resource,
+                            context: resourceData.context || (0, loader_runner_1.getContext)(resourceData.resource),
+                            matchResource: matchResourceData ? matchResourceData.resource : undefined,
+                            resourceResolveData: resourceData.data,
+                            settings,
+                            type,
+                            parser: this.getParser(type, settings.parser),
+                            parserOptions: settings.parser,
+                            generator: this.getGenerator(type, settings.generator),
+                            generatorOptions: settings.generator,
+                            resolveOptions,
+                        });
+                    }
+                    catch (e) {
+                        return callback(e);
+                    }
+                    callback();
+                });
+                this.resolveRequestArray(contextInfo, this.context, useLoadersPost, loaderResolver, resolveContext, (err, result) => {
+                    postLoaders = result;
+                    continueCallback(err);
+                });
+                this.resolveRequestArray(contextInfo, this.context, useLoaders, loaderResolver, resolveContext, (err, result) => {
+                    normalLoaders = result;
+                    continueCallback(err);
+                });
+                this.resolveRequestArray(contextInfo, this.context, useLoadersPre, loaderResolver, resolveContext, (err, result) => {
+                    preLoaders = result;
+                    continueCallback(err);
+                });
+            });
+            this.resolveRequestArray(contextInfo, contextScheme ? this.context : context, elements, loaderResolver, resolveContext, (err, result) => {
+                if (err)
+                    return continueCallback(err);
+                loaders = result;
+                continueCallback();
+            });
+            const defaultResolve = context => {
+                if (/^($|\?)/.test(unresolvedResource)) {
+                    resourceData = Object.assign({ resource: unresolvedResource, data: {} }, cacheParseResource(unresolvedResource));
+                    continueCallback();
+                }
+                // resource without scheme and with path
+                else {
+                    const normalResolver = this.getResolver('normal', dependencyType
+                        ? (0, cleverMerge_1.cachedSetProperty)(resolveOptions || EMPTY_RESOLVE_OPTIONS, 'dependencyType', dependencyType)
+                        : resolveOptions);
+                    this.resolveResource(contextInfo, context, unresolvedResource, normalResolver, resolveContext, (err, resolvedResource, resolvedResourceResolveData) => {
+                        if (err)
+                            return continueCallback(err);
+                        if (resolvedResource !== false) {
+                            resourceData = Object.assign({ resource: resolvedResource, data: resolvedResourceResolveData }, cacheParseResource(resolvedResource));
+                        }
+                        continueCallback();
+                    });
+                }
+            };
+            // resource with scheme
+            if (scheme) {
+                resourceData = {
+                    resource: unresolvedResource,
+                    data: {},
+                    path: undefined,
+                    query: undefined,
+                    fragment: undefined,
+                    context: undefined,
+                };
+                this.hooks.resolveForScheme.for(scheme).callAsync(resourceData, data, err => {
+                    if (err)
+                        return continueCallback(err);
+                    continueCallback();
+                });
+            }
+            // resource within scheme
+            else if (contextScheme) {
+                resourceData = {
+                    resource: unresolvedResource,
+                    data: {},
+                    path: undefined,
+                    query: undefined,
+                    fragment: undefined,
+                    context: undefined,
+                };
+                this.hooks.resolveInScheme
+                    .for(contextScheme)
+                    .callAsync(resourceData, data, (err, handled) => {
+                    if (err)
+                        return continueCallback(err);
+                    if (!handled)
+                        return defaultResolve(this.context);
+                    continueCallback();
+                });
+            }
+            // resource without scheme and without path
+            else
+                defaultResolve(context);
+        });
+    }
+    cleanupForCache() {
+        for (const module of this._restoredUnsafeCacheEntries) {
+            ChunkGraph_1.default.clearChunkGraphForModule(module);
+            ModuleGraph_1.default.clearModuleGraphForModule(module);
+            module.cleanupForCache();
+        }
+    }
+    create(data, callback) {
+        const dependencies = data.dependencies;
+        const context = data.context || this.context;
+        const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
+        const dependency = dependencies[0];
+        const request = dependency.request;
+        const assertions = dependency.assertions;
+        const contextInfo = data.contextInfo;
+        const fileDependencies = new LazySet_1.default();
+        const missingDependencies = new LazySet_1.default();
+        const contextDependencies = new LazySet_1.default();
+        const dependencyType = (dependencies.length > 0 && dependencies[0].category) || '';
+        const resolveData = {
+            contextInfo,
+            resolveOptions,
+            context,
+            request,
+            assertions,
+            dependencies,
+            dependencyType,
+            fileDependencies,
+            missingDependencies,
+            contextDependencies,
+            createData: {},
+            cacheable: true,
+        };
+        this.hooks.beforeResolve.callAsync(resolveData, (err, result) => {
+            if (err) {
+                return callback(err, {
+                    fileDependencies,
+                    missingDependencies,
+                    contextDependencies,
+                    cacheable: false,
+                });
+            }
+            // Ignored
+            if (result === false) {
+                return callback(null, {
+                    fileDependencies,
+                    missingDependencies,
+                    contextDependencies,
+                    cacheable: resolveData.cacheable,
+                });
+            }
+            if (typeof result === 'object')
+                throw new Error(deprecationChangedHookMessage('beforeResolve', this.hooks.beforeResolve));
+            this.hooks.factorize.callAsync(resolveData, (err, module) => {
+                if (err) {
+                    return callback(err, {
+                        fileDependencies,
+                        missingDependencies,
+                        contextDependencies,
+                        cacheable: false,
+                    });
+                }
+                const factoryResult = {
+                    module,
+                    fileDependencies,
+                    missingDependencies,
+                    contextDependencies,
+                    cacheable: resolveData.cacheable,
+                };
+                callback(null, factoryResult);
+            });
+        });
+    }
+    resolveResource(contextInfo, context, unresolvedResource, resolver, resolveContext, callback) {
+        resolver.resolve(contextInfo, context, unresolvedResource, resolveContext, (err, resolvedResource, resolvedResourceResolveData) => {
+            if (err) {
+                return this._resolveResourceErrorHints(err, contextInfo, context, unresolvedResource, resolver, resolveContext, (err2, hints) => {
+                    if (err2) {
+                        err.message += `
+A fatal error happened during resolving additional hints for this error: ${err2.message}`;
+                        err.stack += `
+
+A fatal error happened during resolving additional hints for this error:
+${err2.stack}`;
+                        return callback(err);
+                    }
+                    if (hints && hints.length > 0) {
+                        err.message += `
+${hints.join('\n\n')}`;
+                    }
+                    // Check if the extension is missing a leading dot (e.g. "js" instead of ".js")
+                    let appendResolveExtensionsHint = false;
+                    const specifiedExtensions = Array.from(resolver.options.extensions);
+                    const expectedExtensions = specifiedExtensions.map((extension) => {
+                        if (LEADING_DOT_EXTENSION_REGEX.test(extension)) {
+                            appendResolveExtensionsHint = true;
+                            return `.${extension}`;
+                        }
+                        return extension;
+                    });
+                    if (appendResolveExtensionsHint) {
+                        err.message += `\nDid you miss the leading dot in 'resolve.extensions'? Did you mean '${JSON.stringify(expectedExtensions)}' instead of '${JSON.stringify(specifiedExtensions)}'?`;
+                    }
+                    callback(err);
+                });
+            }
+            callback(err, resolvedResource, resolvedResourceResolveData);
+        });
+    }
+    _resolveResourceErrorHints(error, contextInfo, context, unresolvedResource, resolver, resolveContext, callback) {
+        neo_async_1.default.parallel([
+            callback => {
+                if (!resolver.options.fullySpecified)
+                    return callback();
+                resolver
+                    .withOptions({
+                    fullySpecified: false,
+                })
+                    .resolve(contextInfo, context, unresolvedResource, resolveContext, (err, resolvedResource) => {
+                    if (!err && resolvedResource) {
+                        const resource = (0, identifier_1.parseResource)(resolvedResource).path.replace(/^.*[\\/]/, '');
+                        return callback(null, `Did you mean '${resource}'?
+BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified
+(probably because the origin is strict EcmaScript Module, e. g. a module with javascript mimetype, a '*.mjs' file, or a '*.js' file where the package.json contains '"type": "module"').
+The extension in the request is mandatory for it to be fully specified.
+Add the extension to the request.`);
+                    }
+                    callback();
+                });
+            },
+            callback => {
+                if (!resolver.options.enforceExtension)
+                    return callback();
+                resolver
+                    .withOptions({
+                    enforceExtension: false,
+                    extensions: [],
+                })
+                    .resolve(contextInfo, context, unresolvedResource, resolveContext, (err, resolvedResource) => {
+                    if (!err && resolvedResource) {
+                        let hint = '';
+                        const match = /(\.[^.]+)(\?|$)/.exec(unresolvedResource);
+                        if (match) {
+                            const fixedRequest = unresolvedResource.replace(/(\.[^.]+)(\?|$)/, '$2');
+                            if (resolver.options.extensions.has(match[1])) {
+                                hint = `Did you mean '${fixedRequest}'?`;
+                            }
+                            else {
+                                hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
+                            }
+                        }
+                        else {
+                            hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
+                        }
+                        return callback(null, `The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified.
+${hint}
+Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?`);
+                    }
+                    callback();
+                });
+            },
+            callback => {
+                if (/^\.\.?\//.test(unresolvedResource) || resolver.options.preferRelative) {
+                    return callback();
+                }
+                resolver.resolve(contextInfo, context, `./${unresolvedResource}`, resolveContext, (err, resolvedResource) => {
+                    if (err || !resolvedResource)
+                        return callback();
+                    const moduleDirectories = resolver.options.modules
+                        .map(m => (Array.isArray(m) ? m.join(', ') : m))
+                        .join(', ');
+                    callback(null, `Did you mean './${unresolvedResource}'?
+Requests that should resolve in the current directory need to start with './'.
+Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}).
+If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.`);
+                });
+            },
+        ], (err, hints) => {
+            if (err)
+                return callback(err);
+            callback(null, hints.filter(Boolean));
+        });
+    }
+    resolveRequestArray(contextInfo, context, array, resolver, resolveContext, callback) {
+        if (array.length === 0)
+            return callback(null, array);
+        neo_async_1.default.map(array, (item, callback) => {
+            resolver.resolve(contextInfo, context, item.loader, resolveContext, (err, result, resolveRequest) => {
+                if (err && /^[^/]*$/.test(item.loader) && !/-loader$/.test(item.loader)) {
+                    return resolver.resolve(contextInfo, context, `${item.loader}-loader`, resolveContext, err2 => {
+                        if (!err2) {
+                            err.message =
+                                `${err.message}\n` +
+                                    `BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n` +
+                                    `                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
+                                    `                 see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed`;
+                        }
+                        callback(err);
+                    });
+                }
+                if (err)
+                    return callback(err);
+                const parsedResult = this._parseResourceWithoutFragment(result);
+                const type = /\.mjs$/i.test(parsedResult.path)
+                    ? 'module'
+                    : /\.cjs$/i.test(parsedResult.path)
+                        ? 'commonjs'
+                        : resolveRequest.descriptionFileData === undefined
+                            ? undefined
+                            : resolveRequest.descriptionFileData.type;
+                const resolved = {
+                    loader: parsedResult.path,
+                    type,
+                    options: item.options === undefined
+                        ? parsedResult.query
+                            ? parsedResult.query.slice(1)
+                            : undefined
+                        : item.options,
+                    ident: item.options === undefined ? undefined : item.ident,
+                };
+                return callback(null, resolved);
+            });
+        }, callback);
+    }
+    getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
+        let cache = this.parserCache.get(type);
+        if (cache === undefined) {
+            cache = new WeakMap();
+            this.parserCache.set(type, cache);
+        }
+        let parser = cache.get(parserOptions);
+        if (parser === undefined) {
+            parser = this.createParser(type, parserOptions);
+            cache.set(parserOptions, parser);
+        }
+        return parser;
+    }
+    createParser(type, parserOptions = {}) {
+        parserOptions = mergeGlobalOptions(this._globalParserOptions, type, parserOptions);
+        const parser = this.hooks.createParser.for(type).call(parserOptions);
+        if (!parser) {
+            throw new Error(`No parser registered for ${type}`);
+        }
+        this.hooks.parser.for(type).call(parser, parserOptions);
+        return parser;
+    }
+    getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
+        let cache = this.generatorCache.get(type);
+        if (cache === undefined) {
+            cache = new WeakMap();
+            this.generatorCache.set(type, cache);
+        }
+        let generator = cache.get(generatorOptions);
+        if (generator === undefined) {
+            generator = this.createGenerator(type, generatorOptions);
+            cache.set(generatorOptions, generator);
+        }
+        return generator;
+    }
+    createGenerator(type, generatorOptions = {}) {
+        generatorOptions = mergeGlobalOptions(this._globalGeneratorOptions, type, generatorOptions);
+        const generator = this.hooks.createGenerator.for(type).call(generatorOptions);
+        if (!generator) {
+            throw new Error(`No generator registered for ${type}`);
+        }
+        this.hooks.generator.for(type).call(generator, generatorOptions);
+        return generator;
+    }
+    getResolver(type, resolveOptions) {
+        return this.resolverFactory.get(type, resolveOptions);
+    }
+}
+exports.default = NormalModuleFactory;