xhs-mp-pack 1.1.0-beta.0

package/dist/base/defaults.js

@@ -0,0 +1,671 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyWebpackOptionsDefaults = exports.applyWebpackOptionsBaseDefaults = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const Template_1 = require("@/template/Template");
+const cleverMerge_1 = require("@/base/cleverMerge");
+// Lazy load the Terser plugin
+const terser_webpack_plugin_1 = __importDefault(require("terser-webpack-plugin"));
+const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
+const D = (obj, prop, value) => {
+    if (obj[prop] === undefined) {
+        obj[prop] = value;
+    }
+};
+const F = (obj, prop, factory) => {
+    if (obj[prop] === undefined) {
+        obj[prop] = factory();
+    }
+};
+const A = (obj, prop, factory) => {
+    const value = obj[prop];
+    if (value === undefined) {
+        obj[prop] = factory();
+    }
+    else if (Array.isArray(value)) {
+        let newArray;
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            if (item === '...') {
+                if (newArray === undefined) {
+                    newArray = value.slice(0, i);
+                    obj[prop] = newArray;
+                }
+                const items = factory();
+                if (items !== undefined) {
+                    for (const item of items) {
+                        newArray.push(item);
+                    }
+                }
+            }
+            else if (newArray !== undefined) {
+                newArray.push(item);
+            }
+        }
+    }
+};
+const applyWebpackOptionsBaseDefaults = options => {
+    F(options, 'context', () => process.cwd());
+    applyInfrastructureLoggingDefaults(options.infrastructureLogging);
+};
+exports.applyWebpackOptionsBaseDefaults = applyWebpackOptionsBaseDefaults;
+const applyWebpackOptionsDefaults = options => {
+    F(options, 'context', () => process.cwd());
+    F(options, 'target', () => ['web', 'es5']);
+    const { mode, name, target } = options;
+    const targetProperties = {
+        web: true,
+        browser: true,
+        document: true,
+        importScriptsInWorker: true,
+    };
+    const development = mode === 'development';
+    const production = mode === 'production' || !mode;
+    if (typeof options.entry !== 'function') {
+        for (const key of Object.keys(options.entry)) {
+            F(options.entry[key], 'import', () => ['./src']);
+        }
+    }
+    F(options, 'devtool', () => (development ? 'eval' : false));
+    D(options, 'watch', false);
+    D(options, 'profile', false);
+    D(options, 'parallelism', 100);
+    D(options, 'recordsInputPath', false);
+    D(options, 'recordsOutputPath', false);
+    const futureDefaults = options.experiments.futureDefaults;
+    F(options, 'cache', () => (development ? { type: 'memory' } : false));
+    applyCacheDefaults(options.cache, {
+        name: name || 'default',
+        mode: mode || 'production',
+        development,
+        cacheUnaffected: options.experiments.cacheUnaffected,
+    });
+    const cache = !!options.cache;
+    applySnapshotDefaults(options.snapshot, {
+        production,
+        futureDefaults,
+    });
+    applyModuleDefaults(options.module, {
+        cache,
+        futureDefaults,
+    });
+    applyOutputDefaults(options.output, {
+        context: options.context,
+        isAffectedByBrowserslist: target === undefined ||
+            (typeof target === 'string' && target.startsWith('browserslist')) ||
+            (Array.isArray(target) && target.some(target => target.startsWith('browserslist'))),
+        outputModule: options.experiments.outputModule,
+        development,
+        entry: options.entry,
+        module: options.module,
+        futureDefaults,
+    });
+    applyExternalsPresetsDefaults(options.externalsPresets);
+    applyLoaderDefaults(options.loader, {
+        environment: options.output.environment,
+    });
+    F(options, 'externalsType', () => options.output.library && options.output.module ? 'module' : 'var');
+    applyOptimizationDefaults(options.optimization, {
+        development,
+        production,
+        css: options.experiments.css,
+        records: !!(options.recordsInputPath || options.recordsOutputPath),
+    });
+    options.resolve = (0, cleverMerge_1.cleverMerge)(getResolveDefaults({
+        cache,
+        context: options.context,
+        mode: options.mode,
+        css: options.experiments.css,
+    }), options.resolve);
+    options.resolveLoader = (0, cleverMerge_1.cleverMerge)(getResolveLoaderDefaults({ cache }), options.resolveLoader);
+};
+exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
+const applyCacheDefaults = (cache, { name, mode, development, cacheUnaffected }) => {
+    if (cache === false)
+        return;
+    switch (cache.type) {
+        case 'filesystem':
+            F(cache, 'name', () => `${name}-${mode}`);
+            D(cache, 'version', '');
+            F(cache, 'cacheDirectory', () => {
+                const cwd = process.cwd();
+                let dir = cwd;
+                for (;;) {
+                    try {
+                        if (fs_1.default.statSync(path_1.default.join(dir, 'package.json')).isFile())
+                            break;
+                        // eslint-disable-next-line no-empty
+                    }
+                    catch (e) { }
+                    const parent = path_1.default.dirname(dir);
+                    if (dir === parent) {
+                        dir = undefined;
+                        break;
+                    }
+                    dir = parent;
+                }
+                if (!dir) {
+                    return path_1.default.resolve(cwd, '.cache/webpack');
+                }
+                if (process.versions.pnp === '1') {
+                    return path_1.default.resolve(dir, '.pnp/.cache/webpack');
+                }
+                if (process.versions.pnp === '3') {
+                    return path_1.default.resolve(dir, '.yarn/.cache/webpack');
+                }
+                return path_1.default.resolve(dir, 'node_modules/.cache/webpack');
+            });
+            F(cache, 'cacheLocation', () => path_1.default.resolve(cache.cacheDirectory, cache.name));
+            D(cache, 'hashAlgorithm', 'md4');
+            D(cache, 'store', 'pack');
+            D(cache, 'compression', false);
+            D(cache, 'profile', false);
+            D(cache, 'idleTimeout', 60000);
+            D(cache, 'idleTimeoutForInitialStore', 5000);
+            D(cache, 'idleTimeoutAfterLargeChanges', 1000);
+            D(cache, 'maxMemoryGenerations', development ? 5 : Infinity);
+            D(cache, 'maxAge', 1000 * 60 * 60 * 24 * 60); // 1 month
+            D(cache, 'allowCollectingMemory', development);
+            D(cache, 'memoryCacheUnaffected', development && cacheUnaffected);
+            D(cache, 'readonly', false);
+            D(cache.buildDependencies, 'defaultWebpack', [path_1.default.resolve(__dirname, '..') + path_1.default.sep]);
+            break;
+        case 'memory':
+            D(cache, 'maxGenerations', Infinity);
+            D(cache, 'cacheUnaffected', development && cacheUnaffected);
+            break;
+    }
+};
+const applyJavascriptParserOptionsDefaults = (parserOptions, { futureDefaults, isNode }) => {
+    D(parserOptions, 'unknownContextRequest', '.');
+    D(parserOptions, 'unknownContextRegExp', false);
+    D(parserOptions, 'unknownContextRecursive', true);
+    D(parserOptions, 'unknownContextCritical', true);
+    D(parserOptions, 'exprContextRequest', '.');
+    D(parserOptions, 'exprContextRegExp', false);
+    D(parserOptions, 'exprContextRecursive', true);
+    D(parserOptions, 'exprContextCritical', true);
+    D(parserOptions, 'wrappedContextRegExp', /.*/);
+    D(parserOptions, 'wrappedContextRecursive', true);
+    D(parserOptions, 'wrappedContextCritical', false);
+    D(parserOptions, 'strictThisContextOnImports', false);
+    D(parserOptions, 'importMeta', true);
+    D(parserOptions, 'dynamicImportMode', 'lazy');
+    D(parserOptions, 'dynamicImportPrefetch', false);
+    D(parserOptions, 'dynamicImportPreload', false);
+    D(parserOptions, 'dynamicImportFetchPriority', false);
+    D(parserOptions, 'createRequire', isNode);
+    if (futureDefaults)
+        D(parserOptions, 'exportsPresence', 'error');
+};
+const applyModuleDefaults = (module, { cache, futureDefaults }) => {
+    if (cache) {
+        D(module, 'unsafeCache', module => {
+            const name = module.nameForCondition();
+            return name && NODE_MODULES_REGEXP.test(name);
+        });
+    }
+    else {
+        D(module, 'unsafeCache', false);
+    }
+    F(module.parser, ModuleTypeConstants_1.ASSET_MODULE_TYPE, () => ({}));
+    F(module.parser.asset, 'dataUrlCondition', () => ({}));
+    if (typeof module.parser.asset.dataUrlCondition === 'object') {
+        D(module.parser.asset.dataUrlCondition, 'maxSize', 8096);
+    }
+    F(module.parser, 'javascript', () => ({}));
+    applyJavascriptParserOptionsDefaults(module.parser.javascript, {
+        futureDefaults,
+        isNode: false,
+    });
+    A(module, 'defaultRules', () => {
+        const esm = {
+            type: ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM,
+            resolve: {
+                byDependency: {
+                    esm: {
+                        fullySpecified: true,
+                    },
+                },
+            },
+        };
+        const commonjs = {
+            type: ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+        };
+        const rules = [
+            {
+                mimetype: 'application/node',
+                type: ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO,
+            },
+            {
+                test: /\.json$/i,
+                type: ModuleTypeConstants_1.JSON_MODULE_TYPE,
+            },
+            {
+                mimetype: 'application/json',
+                type: ModuleTypeConstants_1.JSON_MODULE_TYPE,
+            },
+            Object.assign({ test: /\.mjs$/i }, esm),
+            Object.assign({ test: /\.js$/i, descriptionData: {
+                    type: 'module',
+                } }, esm),
+            Object.assign({ test: /\.cjs$/i }, commonjs),
+            Object.assign({ test: /\.js$/i, descriptionData: {
+                    type: 'commonjs',
+                } }, commonjs),
+            Object.assign({ mimetype: {
+                    or: ['text/javascript', 'application/javascript'],
+                } }, esm),
+        ];
+        rules.push({
+            dependency: 'url',
+            oneOf: [
+                {
+                    scheme: /^data$/,
+                    type: 'asset/inline',
+                },
+                {
+                    type: 'asset/resource',
+                },
+            ],
+        }, {
+            assert: { type: 'json' },
+            type: ModuleTypeConstants_1.JSON_MODULE_TYPE,
+        });
+        return rules;
+    });
+};
+// {
+//   timestamp: true
+// }
+const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
+    if (futureDefaults) {
+        F(snapshot, 'managedPaths', () => process.versions.pnp === '3'
+            ? [/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/]
+            : [/^(.+?[\\/]node_modules[\\/])/]);
+        F(snapshot, 'immutablePaths', () => process.versions.pnp === '3'
+            ? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
+            : []);
+    }
+    else {
+        A(snapshot, 'managedPaths', () => {
+            if (process.versions.pnp === '3') {
+                const match = /^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(require.resolve('watchpack'));
+                if (match) {
+                    return [path_1.default.resolve(match[1], 'unplugged')];
+                }
+            }
+            else {
+                const match = /^(.+?[\\/]node_modules[\\/])/.exec(require.resolve('watchpack'));
+                if (match) {
+                    return [match[1]];
+                }
+            }
+            return [];
+        });
+        A(snapshot, 'immutablePaths', () => {
+            if (process.versions.pnp === '1') {
+                const match = /^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(require.resolve('watchpack'));
+                if (match) {
+                    return [match[1]];
+                }
+            }
+            else if (process.versions.pnp === '3') {
+                const match = /^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(require.resolve('watchpack'));
+                if (match) {
+                    return [match[1]];
+                }
+            }
+            return [];
+        });
+    }
+    F(snapshot, 'resolveBuildDependencies', () => ({
+        timestamp: true,
+        hash: true,
+    }));
+    F(snapshot, 'buildDependencies', () => ({ timestamp: true, hash: true }));
+    F(snapshot, 'module', () => (production ? { timestamp: true, hash: true } : { timestamp: true }));
+    F(snapshot, 'resolve', () => (production ? { timestamp: true, hash: true } : { timestamp: true }));
+};
+const applyOutputDefaults = (output, { context, outputModule, development, entry, module, futureDefaults, isAffectedByBrowserslist }) => {
+    const getLibraryName = (library) => {
+        const libraryName = typeof library === 'object' && library && !Array.isArray(library) && 'type' in library
+            ? library.name
+            : library;
+        if (Array.isArray(libraryName)) {
+            return libraryName.join('.');
+        }
+        if (typeof libraryName === 'object') {
+            return getLibraryName(libraryName.root);
+        }
+        if (typeof libraryName === 'string') {
+            return libraryName;
+        }
+        return '';
+    };
+    F(output, 'uniqueName', () => {
+        const libraryName = getLibraryName(output.library).replace(/^\[(\\*[\w:]+\\*)\](\.)|(\.)\[(\\*[\w:]+\\*)\](?=\.|$)|\[(\\*[\w:]+\\*)\]/g, (m, a, d1, d2, b, c) => {
+            const content = a || b || c;
+            return content.startsWith('\\') && content.endsWith('\\')
+                ? `${d2 || ''}[${content.slice(1, -1)}]${d1 || ''}`
+                : '';
+        });
+        if (libraryName)
+            return libraryName;
+        const pkgPath = path_1.default.resolve(context, 'package.json');
+        try {
+            const packageInfo = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+            return packageInfo.name || '';
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                e.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
+                throw e;
+            }
+            return '';
+        }
+    });
+    F(output, 'module', () => !!outputModule);
+    D(output, 'filename', output.module ? '[name].mjs' : '[name].js');
+    F(output, 'iife', () => !output.module);
+    D(output, 'importFunctionName', 'import');
+    D(output, 'importMetaName', 'import.meta');
+    F(output, 'chunkFilename', () => {
+        const filename = output.filename;
+        if (typeof filename !== 'function') {
+            const hasName = filename.includes('[name]');
+            const hasId = filename.includes('[id]');
+            const hasChunkHash = filename.includes('[chunkhash]');
+            const hasContentHash = filename.includes('[contenthash]');
+            // Anything changing depending on chunk is fine
+            if (hasChunkHash || hasContentHash || hasName || hasId)
+                return filename;
+            // Otherwise prefix "[id]." in front of the basename to make it changing
+            return filename.replace(/(^|\/)([^/]*(?:\?|$))/, '$1[id].$2');
+        }
+        return output.module ? '[id].mjs' : '[id].js';
+    });
+    F(output, 'cssFilename', () => {
+        const filename = output.filename;
+        if (typeof filename !== 'function') {
+            return filename.replace(/\.[mc]?js(\?|$)/, '.css$1');
+        }
+        return '[id].css';
+    });
+    F(output, 'cssChunkFilename', () => {
+        const chunkFilename = output.chunkFilename;
+        if (typeof chunkFilename !== 'function') {
+            return chunkFilename.replace(/\.[mc]?js(\?|$)/, '.css$1');
+        }
+        return '[id].css';
+    });
+    D(output, 'assetModuleFilename', '[hash][ext][query]');
+    D(output, 'webassemblyModuleFilename', '[hash].module.wasm');
+    D(output, 'compareBeforeEmit', true);
+    D(output, 'charset', true);
+    F(output, 'hotUpdateGlobal', () => Template_1.Template.toIdentifier(`webpackHotUpdate${Template_1.Template.toIdentifier(output.uniqueName)}`));
+    F(output, 'chunkLoadingGlobal', () => Template_1.Template.toIdentifier(`webpackChunk${Template_1.Template.toIdentifier(output.uniqueName)}`));
+    F(output, 'globalObject', () => 'self');
+    F(output, 'chunkFormat', () => 'array-push');
+    D(output, 'asyncChunks', true);
+    F(output, 'chunkLoading', () => 'jsonp');
+    F(output, 'devtoolNamespace', () => output.uniqueName);
+    if (output.library) {
+        F(output.library, 'type', () => (output.module ? 'module' : 'var'));
+    }
+    F(output, 'path', () => path_1.default.join(process.cwd(), 'dist'));
+    F(output, 'pathinfo', () => development);
+    D(output, 'sourceMapFilename', '[file].map[query]');
+    D(output, 'hotUpdateChunkFilename', `[id].[fullhash].hot-update.${output.module ? 'mjs' : 'js'}`);
+    D(output, 'hotUpdateMainFilename', '[runtime].[fullhash].hot-update.json');
+    D(output, 'crossOriginLoading', false);
+    F(output, 'scriptType', () => (output.module ? 'module' : false));
+    D(output, 'chunkLoadTimeout', 120000);
+    D(output, 'hashFunction', futureDefaults ? 'xxhash64' : 'md4');
+    D(output, 'hashDigest', 'hex');
+    D(output, 'hashDigestLength', futureDefaults ? 16 : 20);
+    D(output, 'strictModuleExceptionHandling', false);
+    // const environment = output.environment
+    // const optimistic = v => v || v === undefined
+    // const conditionallyOptimistic = (v, c) => (v === undefined && c) || v
+    // F(environment, 'bigIntLiteral', () => false)
+    // F(environment, 'const', () => tp && optimistic(tp.const))
+    // F(environment, 'arrowFunction', () => tp && optimistic(tp.arrowFunction))
+    // F(environment, 'forOf', () => tp && optimistic(tp.forOf))
+    // F(environment, 'destructuring', () => tp && optimistic(tp.destructuring))
+    // F(environment, 'optionalChaining', () => tp && optimistic(tp.optionalChaining))
+    // F(environment, 'templateLiteral', () => tp && optimistic(tp.templateLiteral))
+    // F(environment, 'dynamicImport', () =>
+    //   conditionallyOptimistic(tp && tp.dynamicImport, output.module),
+    // )
+    // F(environment, 'dynamicImportInWorker', () =>
+    //   conditionallyOptimistic(tp && tp.dynamicImportInWorker, output.module),
+    // )
+    // F(environment, 'module', () => conditionallyOptimistic(tp && tp.module, output.module))
+    const { trustedTypes } = output;
+    if (trustedTypes) {
+        F(trustedTypes, 'policyName', () => output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, '_') || 'webpack');
+        D(trustedTypes, 'onPolicyCreationFailure', 'stop');
+    }
+    const forEachEntry = fn => {
+        for (const name of Object.keys(entry)) {
+            fn(entry[name]);
+        }
+    };
+    A(output, 'enabledLibraryTypes', () => {
+        const enabledLibraryTypes = [];
+        if (output.library) {
+            enabledLibraryTypes.push(output.library.type);
+        }
+        forEachEntry(desc => {
+            if (desc.library) {
+                enabledLibraryTypes.push(desc.library.type);
+            }
+        });
+        return enabledLibraryTypes;
+    });
+    A(output, 'enabledChunkLoadingTypes', () => {
+        const enabledChunkLoadingTypes = new Set();
+        if (output.chunkLoading) {
+            enabledChunkLoadingTypes.add(output.chunkLoading);
+        }
+        if (output.workerChunkLoading) {
+            enabledChunkLoadingTypes.add(output.workerChunkLoading);
+        }
+        forEachEntry(desc => {
+            if (desc.chunkLoading) {
+                enabledChunkLoadingTypes.add(desc.chunkLoading);
+            }
+        });
+        return Array.from(enabledChunkLoadingTypes);
+    });
+    A(output, 'enabledWasmLoadingTypes', () => {
+        const enabledWasmLoadingTypes = new Set();
+        if (output.wasmLoading) {
+            enabledWasmLoadingTypes.add(output.wasmLoading);
+        }
+        if (output.workerWasmLoading) {
+            enabledWasmLoadingTypes.add(output.workerWasmLoading);
+        }
+        forEachEntry(desc => {
+            if (desc.wasmLoading) {
+                enabledWasmLoadingTypes.add(desc.wasmLoading);
+            }
+        });
+        return Array.from(enabledWasmLoadingTypes);
+    });
+};
+const applyExternalsPresetsDefaults = externalsPresets => {
+    D(externalsPresets, 'web', true);
+};
+const applyLoaderDefaults = (loader, { environment }) => {
+    F(loader, 'target', () => 'web');
+    D(loader, 'environment', environment);
+};
+const applyOptimizationDefaults = (optimization, { production, development, css, records }) => {
+    D(optimization, 'removeAvailableModules', false);
+    D(optimization, 'removeEmptyChunks', true);
+    D(optimization, 'mergeDuplicateChunks', true);
+    D(optimization, 'flagIncludedChunks', production);
+    F(optimization, 'moduleIds', () => {
+        if (production)
+            return 'deterministic';
+        if (development)
+            return 'named';
+        return 'natural';
+    });
+    F(optimization, 'chunkIds', () => {
+        if (production)
+            return 'deterministic';
+        if (development)
+            return 'named';
+        return 'natural';
+    });
+    F(optimization, 'sideEffects', () => (production ? true : 'flag'));
+    D(optimization, 'providedExports', true);
+    D(optimization, 'usedExports', production);
+    D(optimization, 'innerGraph', production);
+    D(optimization, 'mangleExports', production);
+    D(optimization, 'concatenateModules', production);
+    D(optimization, 'runtimeChunk', false);
+    D(optimization, 'emitOnErrors', !production);
+    D(optimization, 'checkWasmTypes', production);
+    D(optimization, 'mangleWasmImports', false);
+    D(optimization, 'portableRecords', records);
+    D(optimization, 'realContentHash', production);
+    D(optimization, 'minimize', production);
+    A(optimization, 'minimizer', () => [
+        {
+            apply: compiler => {
+                new terser_webpack_plugin_1.default({
+                    terserOptions: {
+                        compress: {
+                            passes: 2,
+                        },
+                    },
+                }).apply(compiler);
+            },
+        },
+    ]);
+    F(optimization, 'nodeEnv', () => {
+        if (production)
+            return 'production';
+        if (development)
+            return 'development';
+        return false;
+    });
+    const { splitChunks } = optimization;
+    if (splitChunks) {
+        A(splitChunks, 'defaultSizeTypes', () => css ? ['javascript', 'css', 'unknown'] : ['javascript', 'unknown']);
+        D(splitChunks, 'hidePathInfo', production);
+        D(splitChunks, 'chunks', 'async');
+        D(splitChunks, 'usedExports', optimization.usedExports === true);
+        D(splitChunks, 'minChunks', 1);
+        F(splitChunks, 'minSize', () => (production ? 20000 : 10000));
+        F(splitChunks, 'minRemainingSize', () => (development ? 0 : undefined));
+        F(splitChunks, 'enforceSizeThreshold', () => (production ? 50000 : 30000));
+        F(splitChunks, 'maxAsyncRequests', () => (production ? 30 : Infinity));
+        F(splitChunks, 'maxInitialRequests', () => (production ? 30 : Infinity));
+        D(splitChunks, 'automaticNameDelimiter', '-');
+        const cacheGroups = splitChunks.cacheGroups;
+        F(cacheGroups, 'default', () => ({
+            idHint: '',
+            reuseExistingChunk: true,
+            minChunks: 2,
+            priority: -20,
+        }));
+        F(cacheGroups, 'defaultVendors', () => ({
+            idHint: 'vendors',
+            reuseExistingChunk: true,
+            test: NODE_MODULES_REGEXP,
+            priority: -10,
+        }));
+    }
+};
+const getResolveDefaults = ({ cache, context, mode, css }) => {
+    const conditions = ['webpack'];
+    conditions.push(mode === 'development' ? 'development' : 'production');
+    conditions.push('browser');
+    const jsExtensions = ['.js', '.json', '.wasm'];
+    const browserField = true;
+    const cjsDeps = () => ({
+        aliasFields: browserField ? ['browser'] : [],
+        mainFields: browserField ? ['browser', 'module', '...'] : ['module', '...'],
+        conditionNames: ['require', 'module', '...'],
+        extensions: [...jsExtensions],
+    });
+    const esmDeps = () => ({
+        aliasFields: browserField ? ['browser'] : [],
+        mainFields: browserField ? ['browser', 'module', '...'] : ['module', '...'],
+        conditionNames: ['import', 'module', '...'],
+        extensions: [...jsExtensions],
+    });
+    const resolveOptions = {
+        cache,
+        modules: ['node_modules'],
+        conditionNames: conditions,
+        mainFiles: ['index'],
+        extensions: [],
+        aliasFields: [],
+        exportsFields: ['exports'],
+        roots: [context],
+        mainFields: ['main'],
+        byDependency: {
+            wasm: esmDeps(),
+            esm: esmDeps(),
+            loaderImport: esmDeps(),
+            url: {
+                preferRelative: true,
+            },
+            worker: Object.assign(Object.assign({}, esmDeps()), { preferRelative: true }),
+            commonjs: cjsDeps(),
+            amd: cjsDeps(),
+            // for backward-compat: loadModule
+            loader: cjsDeps(),
+            // for backward-compat: Custom Dependency
+            unknown: cjsDeps(),
+            // for backward-compat: getResolve without dependencyType
+            undefined: cjsDeps(),
+        },
+    };
+    if (css) {
+        const styleConditions = [];
+        styleConditions.push('webpack');
+        styleConditions.push(mode === 'development' ? 'development' : 'production');
+        styleConditions.push('style');
+        resolveOptions.byDependency['css-import'] = {
+            // We avoid using any main files because we have to be consistent with CSS `@import`
+            // and CSS `@import` does not handle `main` files in directories,
+            // you should always specify the full URL for styles
+            mainFiles: [],
+            mainFields: ['style', '...'],
+            conditionNames: styleConditions,
+            extensions: ['.css'],
+        };
+    }
+    return resolveOptions;
+};
+const getResolveLoaderDefaults = ({ cache }) => {
+    const resolveOptions = {
+        cache,
+        conditionNames: ['loader', 'require', 'node'],
+        exportsFields: ['exports'],
+        mainFields: ['loader', 'main'],
+        extensions: ['.js'],
+        mainFiles: ['index'],
+    };
+    return resolveOptions;
+};
+const applyInfrastructureLoggingDefaults = infrastructureLogging => {
+    F(infrastructureLogging, 'stream', () => process.stderr);
+    const tty = infrastructureLogging.stream.isTTY && process.env.TERM !== 'dumb';
+    D(infrastructureLogging, 'level', 'info');
+    D(infrastructureLogging, 'debug', false);
+    D(infrastructureLogging, 'colors', tty);
+    D(infrastructureLogging, 'appendOnly', !tty);
+};

package/dist/base/deprecation.d.ts

@@ -0,0 +1,21 @@
+declare const arrayToSetDeprecation: (set: any, name: any) => void;
+declare const createArrayToSetDeprecationSet: (name: any) => {
+    new (items?: any): {
+        add(value: any): any;
+        clear(): void;
+        delete(value: any): boolean;
+        forEach(callbackfn: (value: any, value2: any, set: Set<any>) => void, thisArg?: any): void;
+        has(value: any): boolean;
+        readonly size: number;
+        entries(): IterableIterator<[any, any]>;
+        keys(): IterableIterator<any>;
+        values(): IterableIterator<any>;
+        [Symbol.iterator](): IterableIterator<any>;
+        readonly [Symbol.toStringTag]: string;
+    };
+    readonly [Symbol.species]: SetConstructor;
+};
+declare const soonFrozenObjectDeprecation: (obj: Object, name: string, code: string, note?: string) => Object;
+declare const deprecateAllProperties: (obj: any, message: string, code: string) => {};
+declare const createFakeHook: (fakeHook: any, message?: string, code?: string) => any;
+export { arrayToSetDeprecation, createArrayToSetDeprecationSet, soonFrozenObjectDeprecation, deprecateAllProperties, createFakeHook, };