xhs-mp-pack 1.1.0-beta.0

package/dist/base/logging/nodeConsole.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const truncateArgs_1 = __importDefault(require("@/base/logging/truncateArgs"));
+exports.default = ({ colors, appendOnly, stream }) => {
+    let currentStatusMessage;
+    let hasStatusMessage = false;
+    let currentIndent = '';
+    let currentCollapsed = 0;
+    const indent = (str, prefix, colorPrefix, colorSuffix) => {
+        if (str === '')
+            return str;
+        prefix = currentIndent + prefix;
+        if (colors) {
+            return (prefix +
+                colorPrefix +
+                str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
+                colorSuffix);
+        }
+        return prefix + str.replace(/\n/g, `\n${prefix}`);
+    };
+    const clearStatusMessage = () => {
+        if (hasStatusMessage) {
+            stream.write('\x1b[2K\r');
+            hasStatusMessage = false;
+        }
+    };
+    const writeStatusMessage = () => {
+        if (!currentStatusMessage)
+            return;
+        const l = stream.columns || 40;
+        const args = (0, truncateArgs_1.default)(currentStatusMessage, l - 1);
+        const str = args.join(' ');
+        const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
+        stream.write(`\x1b[2K\r${coloredStr}`);
+        hasStatusMessage = true;
+    };
+    const writeColored = (prefix, colorPrefix, colorSuffix) => (...args) => {
+        if (currentCollapsed > 0)
+            return;
+        clearStatusMessage();
+        const str = indent(util_1.default.format(...args), prefix, colorPrefix, colorSuffix);
+        stream.write(`${str}\n`);
+        writeStatusMessage();
+    };
+    const writeGroupMessage = writeColored('<-> ', '\u001b[1m\u001b[36m', '\u001b[39m\u001b[22m');
+    const writeGroupCollapsedMessage = writeColored('<+> ', '\u001b[1m\u001b[36m', '\u001b[39m\u001b[22m');
+    return {
+        log: writeColored('    ', '\u001b[1m', '\u001b[22m'),
+        debug: writeColored('    ', '', ''),
+        trace: writeColored('    ', '', ''),
+        info: writeColored('<i> ', '\u001b[1m\u001b[32m', '\u001b[39m\u001b[22m'),
+        warn: writeColored('<w> ', '\u001b[1m\u001b[33m', '\u001b[39m\u001b[22m'),
+        error: writeColored('<e> ', '\u001b[1m\u001b[31m', '\u001b[39m\u001b[22m'),
+        logTime: writeColored('<t> ', '\u001b[1m\u001b[35m', '\u001b[39m\u001b[22m'),
+        group: (...args) => {
+            writeGroupMessage(...args);
+            if (currentCollapsed > 0) {
+                currentCollapsed++;
+            }
+            else {
+                currentIndent += '  ';
+            }
+        },
+        groupCollapsed: (...args) => {
+            writeGroupCollapsedMessage(...args);
+            currentCollapsed++;
+        },
+        groupEnd: () => {
+            if (currentCollapsed > 0)
+                currentCollapsed--;
+            else if (currentIndent.length >= 2)
+                currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+        },
+        profile: console.profile && (name => console.profile(name)),
+        profileEnd: console.profileEnd && (name => console.profileEnd(name)),
+        clear: !appendOnly &&
+            console.clear &&
+            (() => {
+                clearStatusMessage();
+                console.clear();
+                writeStatusMessage();
+            }),
+        status: appendOnly
+            ? writeColored('<s> ', '', '')
+            : (name, ...args) => {
+                args = args.filter(Boolean);
+                if (name === undefined && args.length === 0) {
+                    clearStatusMessage();
+                    currentStatusMessage = undefined;
+                }
+                else if (typeof name === 'string' && name.startsWith('[webpack.Progress] ')) {
+                    currentStatusMessage = [name.slice(19), ...args];
+                    writeStatusMessage();
+                }
+                else if (name === '[webpack.Progress]') {
+                    currentStatusMessage = [...args];
+                    writeStatusMessage();
+                }
+                else {
+                    currentStatusMessage = [name, ...args];
+                    writeStatusMessage();
+                }
+            },
+    };
+};

package/dist/base/logging/runtime.d.ts

@@ -0,0 +1,8 @@
+import { SyncBailHook } from 'tapable';
+import { Logger } from './Logger';
+declare const getLogger: (name: any) => Logger;
+declare const configureDefaultLogger: (options: any) => void;
+declare const hooks: {
+    log: SyncBailHook<any, string, import("tapable").UnsetAdditionalOptions>;
+};
+export { getLogger, configureDefaultLogger, hooks };

package/dist/base/logging/runtime.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hooks = exports.configureDefaultLogger = exports.getLogger = void 0;
+const tapable_1 = require("tapable");
+const Logger_1 = require("./Logger");
+const createConsoleLogger_1 = __importDefault(require("./createConsoleLogger"));
+const currentDefaultLoggerOptions = {
+    level: 'info',
+    debug: false,
+    console,
+};
+let currentDefaultLogger = (0, createConsoleLogger_1.default)(currentDefaultLoggerOptions);
+const getLogger = name => new Logger_1.Logger((type, args) => {
+    if (hooks.log.call(name, type, args) === undefined) {
+        currentDefaultLogger(name, type, args);
+    }
+}, childName => getLogger(`${name}/${childName}`));
+exports.getLogger = getLogger;
+const configureDefaultLogger = options => {
+    Object.assign(currentDefaultLoggerOptions, options);
+    currentDefaultLogger = (0, createConsoleLogger_1.default)(currentDefaultLoggerOptions);
+};
+exports.configureDefaultLogger = configureDefaultLogger;
+const hooks = {
+    log: new tapable_1.SyncBailHook(['origin', 'type', 'args']),
+};
+exports.hooks = hooks;

package/dist/base/logging/truncateArgs.d.ts

@@ -0,0 +1,2 @@
+declare const truncateArgs: (args: any, maxLength: any) => any;
+export default truncateArgs;

package/dist/base/logging/truncateArgs.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const arraySum = array => {
+    let sum = 0;
+    for (const item of array)
+        sum += item;
+    return sum;
+};
+const truncateArgs = (args, maxLength) => {
+    const lengths = args.map(a => `${a}`.length);
+    const availableLength = maxLength - lengths.length + 1;
+    if (availableLength > 0 && args.length === 1) {
+        if (availableLength >= args[0].length) {
+            return args;
+        }
+        if (availableLength > 3) {
+            return [`...${args[0].slice(-availableLength + 3)}`];
+        }
+        return [args[0].slice(-availableLength)];
+    }
+    // Check if there is space for at least 4 chars per arg
+    if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
+        // remove args
+        if (args.length > 1)
+            return truncateArgs(args.slice(0, args.length - 1), maxLength);
+        return [];
+    }
+    let currentLength = arraySum(lengths);
+    // Check if all fits into maxLength
+    if (currentLength <= availableLength)
+        return args;
+    // Try to remove chars from the longest items until it fits
+    while (currentLength > availableLength) {
+        const maxLength = Math.max(...lengths);
+        const shorterItems = lengths.filter(l => l !== maxLength);
+        const nextToMaxLength = shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
+        const maxReduce = maxLength - nextToMaxLength;
+        let maxItems = lengths.length - shorterItems.length;
+        let overrun = currentLength - availableLength;
+        for (let i = 0; i < lengths.length; i++) {
+            if (lengths[i] === maxLength) {
+                const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
+                lengths[i] -= reduce;
+                currentLength -= reduce;
+                overrun -= reduce;
+                maxItems--;
+            }
+        }
+    }
+    // Return args reduced to length in lengths
+    return args.map((a, i) => {
+        const str = `${a}`;
+        const length = lengths[i];
+        if (str.length === length) {
+            return str;
+        }
+        if (length > 5) {
+            return `...${str.slice(-length + 3)}`;
+        }
+        if (length > 0) {
+            return str.slice(-length);
+        }
+        return '';
+    });
+};
+exports.default = truncateArgs;

package/dist/base/memoize.d.ts

@@ -0,0 +1,2 @@
+declare const memoize: (fn: any) => any;
+export default memoize;

package/dist/base/memoize.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoize = (fn) => {
+    let cache = false;
+    let result;
+    return () => {
+        if (cache) {
+            return result;
+        }
+        result = fn();
+        cache = true;
+        // Allow to clean up memory for fn
+        // and all dependent resources
+        fn = undefined;
+        return result;
+    };
+};
+exports.default = memoize;

package/dist/base/missingModule.d.ts

@@ -0,0 +1,4 @@
+declare const missingModule: (request: any) => string;
+declare const promise: (request: any) => string;
+declare const moduleCode: (request: any) => string;
+export { missingModule, promise, moduleCode };

package/dist/base/missingModule.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleCode = exports.promise = exports.missingModule = void 0;
+const toErrorCode = err => `var e = new Error(${JSON.stringify(err)}); e.code = 'MODULE_NOT_FOUND';`;
+const missingModule = request => `!(function webpackMissingModule() { ${moduleCode(request)} }())`;
+exports.missingModule = missingModule;
+const promise = request => {
+    const errorCode = toErrorCode(`Cannot find module '${request}'`);
+    return `Promise.reject(function webpackMissingModule() { ${errorCode} return e; }())`;
+};
+exports.promise = promise;
+const moduleCode = request => {
+    const errorCode = toErrorCode(`Cannot find module '${request}'`);
+    return `${errorCode} throw e;`;
+};
+exports.moduleCode = moduleCode;

package/dist/base/moduleAlias.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/base/moduleAlias.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const moduleAlias = require('module-alias');
+moduleAlias.addAlias('@', path_1.default.join(__dirname, '..'));

package/dist/base/nonNumericOnlyHash.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {string} hash hash
+ * @param {number} hashLength hash length
+ * @returns {string} returns hash that has at least one non numeric char
+ */
+declare const _default: (hash: any, hashLength: any) => any;
+export default _default;

package/dist/base/nonNumericOnlyHash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const A_CODE = 'a'.charCodeAt(0);
+/**
+ * @param {string} hash hash
+ * @param {number} hashLength hash length
+ * @returns {string} returns hash that has at least one non numeric char
+ */
+exports.default = (hash, hashLength) => {
+    if (hashLength < 1)
+        return '';
+    const slice = hash.slice(0, hashLength);
+    if (slice.match(/[^\d]/))
+        return slice;
+    return `${String.fromCharCode(A_CODE + (parseInt(hash[0], 10) % 6))}${slice.slice(1)}`;
+};

package/dist/base/normalization.d.ts

@@ -0,0 +1,32 @@
+declare const getNormalizedWebpackOptions: (config: any) => {
+    amd: any;
+    bail: any;
+    cache: any;
+    context: any;
+    dependencies: any;
+    devServer: any;
+    devtool: any;
+    entry: {};
+    experiments: any;
+    externals: any;
+    externalsPresets: any;
+    externalsType: any;
+    ignoreWarnings: any;
+    infrastructureLogging: any;
+    loader: any;
+    mode: any;
+    module: any;
+    name: any;
+    optimization: any;
+    output: any;
+    parallelism: any;
+    plugins: any;
+    profile: any;
+    recordsInputPath: any;
+    recordsOutputPath: any;
+    resolve: any;
+    resolveLoader: any;
+    snapshot: any;
+    stats: any;
+};
+export { getNormalizedWebpackOptions };

package/dist/base/normalization.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNormalizedWebpackOptions = void 0;
+const nestedConfig = (value, fn) => (value === undefined ? fn({}) : fn(value));
+const cloneObject = value => (Object.assign({}, value));
+const optionalNestedConfig = (value, fn) => (value === undefined ? undefined : fn(value));
+const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
+const optionalNestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : undefined);
+const keyedNestedConfig = (value, fn, customKeys) => {
+    const result = value === undefined
+        ? {}
+        : Object.keys(value).reduce(
+        // eslint-disable-next-line no-return-assign
+        (obj, key) => (
+        // eslint-disable-next-line no-sequences
+        (obj[key] = (customKeys && key in customKeys ? customKeys[key] : fn)(value[key])), obj), {});
+    if (customKeys) {
+        for (const key of Object.keys(customKeys)) {
+            if (!(key in result)) {
+                result[key] = customKeys[key]({});
+            }
+        }
+    }
+    return result;
+};
+const getNormalizedWebpackOptions = config => ({
+    amd: config.amd,
+    bail: config.bail,
+    cache: optionalNestedConfig(config.cache, cache => {
+        if (cache === false)
+            return false;
+        if (cache === true) {
+            return {
+                type: 'memory',
+                maxGenerations: undefined,
+            };
+        }
+        switch (cache.type) {
+            case 'filesystem':
+                return {
+                    type: 'filesystem',
+                    allowCollectingMemory: cache.allowCollectingMemory,
+                    maxMemoryGenerations: cache.maxMemoryGenerations,
+                    maxAge: cache.maxAge,
+                    profile: cache.profile,
+                    buildDependencies: cloneObject(cache.buildDependencies),
+                    cacheDirectory: cache.cacheDirectory,
+                    cacheLocation: cache.cacheLocation,
+                    hashAlgorithm: cache.hashAlgorithm,
+                    compression: cache.compression,
+                    idleTimeout: cache.idleTimeout,
+                    idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
+                    idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
+                    name: cache.name,
+                    store: cache.store,
+                    version: cache.version,
+                    readonly: cache.readonly,
+                };
+            case undefined:
+            case 'memory':
+                return {
+                    type: 'memory',
+                    maxGenerations: cache.maxGenerations,
+                };
+            default:
+                throw new Error(`Not implemented cache.type ${cache.type}`);
+        }
+    }),
+    context: config.context,
+    dependencies: config.dependencies,
+    devServer: optionalNestedConfig(config.devServer, devServer => (Object.assign({}, devServer))),
+    devtool: config.devtool,
+    entry: config.entry === undefined
+        ? { main: {} }
+        : typeof config.entry === 'function'
+            ? (fn => () => Promise.resolve().then(fn).then(getNormalizedEntryStatic))(config.entry)
+            : getNormalizedEntryStatic(config.entry),
+    experiments: nestedConfig(config.experiments, experiments => (Object.assign(Object.assign({}, experiments), { buildHttp: optionalNestedConfig(experiments.buildHttp, options => Array.isArray(options) ? { allowedUris: options } : options), lazyCompilation: optionalNestedConfig(experiments.lazyCompilation, options => options === true ? {} : options), css: optionalNestedConfig(experiments.css, options => (options === true ? {} : options)) }))),
+    externals: config.externals,
+    externalsPresets: cloneObject(config.externalsPresets),
+    externalsType: config.externalsType,
+    ignoreWarnings: config.ignoreWarnings
+        ? config.ignoreWarnings.map(ignore => {
+            if (typeof ignore === 'function')
+                return ignore;
+            const i = ignore instanceof RegExp ? { message: ignore } : ignore;
+            return (warning, { requestShortener }) => {
+                if (!i.message && !i.module && !i.file)
+                    return false;
+                if (i.message && !i.message.test(warning.message)) {
+                    return false;
+                }
+                if (i.module &&
+                    (!warning.module ||
+                        !i.module.test(warning.module.readableIdentifier(requestShortener)))) {
+                    return false;
+                }
+                if (i.file && (!warning.file || !i.file.test(warning.file))) {
+                    return false;
+                }
+                return true;
+            };
+        })
+        : undefined,
+    infrastructureLogging: cloneObject(config.infrastructureLogging),
+    loader: cloneObject(config.loader),
+    mode: config.mode,
+    module: nestedConfig(config.module, module => ({
+        noParse: module.noParse,
+        unsafeCache: module.unsafeCache,
+        parser: keyedNestedConfig(module.parser, cloneObject, {
+            javascript: parserOptions => (Object.assign({ unknownContextRequest: module.unknownContextRequest, unknownContextRegExp: module.unknownContextRegExp, unknownContextRecursive: module.unknownContextRecursive, unknownContextCritical: module.unknownContextCritical, exprContextRequest: module.exprContextRequest, exprContextRegExp: module.exprContextRegExp, exprContextRecursive: module.exprContextRecursive, exprContextCritical: module.exprContextCritical, wrappedContextRegExp: module.wrappedContextRegExp, wrappedContextRecursive: module.wrappedContextRecursive, wrappedContextCritical: module.wrappedContextCritical, 
+                // TODO webpack 6 remove
+                strictExportPresence: module.strictExportPresence, strictThisContextOnImports: module.strictThisContextOnImports }, parserOptions)),
+        }),
+        generator: cloneObject(module.generator),
+        defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
+        rules: nestedArray(module.rules, r => [...r]),
+    })),
+    name: config.name,
+    optimization: nestedConfig(config.optimization, optimization => (Object.assign(Object.assign({}, optimization), { runtimeChunk: getNormalizedOptimizationRuntimeChunk(optimization.runtimeChunk), splitChunks: nestedConfig(optimization.splitChunks, splitChunks => splitChunks && Object.assign(Object.assign({}, splitChunks), { defaultSizeTypes: splitChunks.defaultSizeTypes
+                ? [...splitChunks.defaultSizeTypes]
+                : ['...'], cacheGroups: cloneObject(splitChunks.cacheGroups) })), emitOnErrors: optimization.emitOnErrors }))),
+    output: nestedConfig(config.output, output => {
+        const { library } = output;
+        const libraryAsName = library;
+        const libraryBase = typeof library === 'object' && library && !Array.isArray(library) && 'type' in library
+            ? library
+            : libraryAsName || output.libraryTarget
+                ? {
+                    name: libraryAsName,
+                }
+                : undefined;
+        const result = {
+            assetModuleFilename: output.assetModuleFilename,
+            asyncChunks: output.asyncChunks,
+            charset: output.charset,
+            chunkFilename: output.chunkFilename,
+            chunkFormat: output.chunkFormat,
+            chunkLoading: output.chunkLoading,
+            chunkLoadingGlobal: output.chunkLoadingGlobal,
+            chunkLoadTimeout: output.chunkLoadTimeout,
+            cssFilename: output.cssFilename,
+            cssChunkFilename: output.cssChunkFilename,
+            clean: output.clean,
+            compareBeforeEmit: output.compareBeforeEmit,
+            crossOriginLoading: output.crossOriginLoading,
+            devtoolFallbackModuleFilenameTemplate: output.devtoolFallbackModuleFilenameTemplate,
+            devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
+            devtoolNamespace: output.devtoolNamespace,
+            environment: cloneObject(output.environment),
+            enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
+                ? [...output.enabledChunkLoadingTypes]
+                : ['...'],
+            enabledLibraryTypes: output.enabledLibraryTypes ? [...output.enabledLibraryTypes] : ['...'],
+            enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
+                ? [...output.enabledWasmLoadingTypes]
+                : ['...'],
+            filename: output.filename,
+            globalObject: output.globalObject,
+            hashDigest: output.hashDigest,
+            hashDigestLength: output.hashDigestLength,
+            hashFunction: output.hashFunction,
+            hashSalt: output.hashSalt,
+            hotUpdateChunkFilename: output.hotUpdateChunkFilename,
+            hotUpdateGlobal: output.hotUpdateGlobal,
+            hotUpdateMainFilename: output.hotUpdateMainFilename,
+            ignoreBrowserWarnings: output.ignoreBrowserWarnings,
+            iife: output.iife,
+            importFunctionName: output.importFunctionName,
+            importMetaName: output.importMetaName,
+            scriptType: output.scriptType,
+            library: libraryBase && {
+                type: output.libraryTarget !== undefined ? output.libraryTarget : libraryBase.type,
+                auxiliaryComment: output.auxiliaryComment !== undefined
+                    ? output.auxiliaryComment
+                    : libraryBase.auxiliaryComment,
+                amdContainer: output.amdContainer !== undefined ? output.amdContainer : libraryBase.amdContainer,
+                export: output.libraryExport !== undefined ? output.libraryExport : libraryBase.export,
+                name: libraryBase.name,
+                umdNamedDefine: output.umdNamedDefine !== undefined
+                    ? output.umdNamedDefine
+                    : libraryBase.umdNamedDefine,
+            },
+            module: output.module,
+            path: output.path,
+            pathinfo: output.pathinfo,
+            publicPath: output.publicPath,
+            sourceMapFilename: output.sourceMapFilename,
+            sourcePrefix: output.sourcePrefix,
+            strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+            trustedTypes: optionalNestedConfig(output.trustedTypes, trustedTypes => {
+                if (trustedTypes === true)
+                    return {};
+                if (typeof trustedTypes === 'string')
+                    return { policyName: trustedTypes };
+                return Object.assign({}, trustedTypes);
+            }),
+            uniqueName: output.uniqueName,
+            wasmLoading: output.wasmLoading,
+            webassemblyModuleFilename: output.webassemblyModuleFilename,
+            workerPublicPath: output.workerPublicPath,
+            workerChunkLoading: output.workerChunkLoading,
+            workerWasmLoading: output.workerWasmLoading,
+        };
+        return result;
+    }),
+    parallelism: config.parallelism,
+    plugins: nestedArray(config.plugins, p => [...p]),
+    profile: config.profile,
+    recordsInputPath: config.recordsInputPath !== undefined ? config.recordsInputPath : config.recordsPath,
+    recordsOutputPath: config.recordsOutputPath !== undefined ? config.recordsOutputPath : config.recordsPath,
+    resolve: nestedConfig(config.resolve, resolve => (Object.assign(Object.assign({}, resolve), { byDependency: keyedNestedConfig(resolve.byDependency, cloneObject) }))),
+    resolveLoader: cloneObject(config.resolveLoader),
+    snapshot: nestedConfig(config.snapshot, snapshot => ({
+        resolveBuildDependencies: optionalNestedConfig(snapshot.resolveBuildDependencies, resolveBuildDependencies => ({
+            timestamp: resolveBuildDependencies.timestamp,
+            hash: resolveBuildDependencies.hash,
+        })),
+        buildDependencies: optionalNestedConfig(snapshot.buildDependencies, buildDependencies => ({
+            timestamp: buildDependencies.timestamp,
+            hash: buildDependencies.hash,
+        })),
+        resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
+            timestamp: resolve.timestamp,
+            hash: resolve.hash,
+        })),
+        module: optionalNestedConfig(snapshot.module, module => ({
+            timestamp: module.timestamp,
+            hash: module.hash,
+        })),
+        immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
+        managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p]),
+    })),
+    stats: nestedConfig(config.stats, stats => {
+        if (stats === false) {
+            return {
+                preset: 'none',
+            };
+        }
+        if (stats === true) {
+            return {
+                preset: 'normal',
+            };
+        }
+        if (typeof stats === 'string') {
+            return {
+                preset: stats,
+            };
+        }
+        return Object.assign({}, stats);
+    }),
+});
+exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
+const getNormalizedEntryStatic = entry => {
+    if (typeof entry === 'string') {
+        return {
+            main: {
+                import: [entry],
+            },
+        };
+    }
+    if (Array.isArray(entry)) {
+        return {
+            main: {
+                import: entry,
+            },
+        };
+    }
+    const result = {};
+    for (const key of Object.keys(entry)) {
+        const value = entry[key];
+        if (typeof value === 'string') {
+            result[key] = {
+                import: [value],
+            };
+        }
+        else if (Array.isArray(value)) {
+            result[key] = {
+                import: value,
+            };
+        }
+        else {
+            result[key] = {
+                import: value.import && (Array.isArray(value.import) ? value.import : [value.import]),
+                filename: value.filename,
+                layer: value.layer,
+                runtime: value.runtime,
+                baseUri: value.baseUri,
+                publicPath: value.publicPath,
+                chunkLoading: value.chunkLoading,
+                asyncChunks: value.asyncChunks,
+                wasmLoading: value.wasmLoading,
+                dependOn: value.dependOn && (Array.isArray(value.dependOn) ? value.dependOn : [value.dependOn]),
+                library: value.library,
+            };
+        }
+    }
+    return result;
+};
+const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
+    if (runtimeChunk === undefined)
+        return undefined;
+    if (runtimeChunk === false)
+        return false;
+    if (runtimeChunk === 'single') {
+        return {
+            name: () => 'runtime',
+        };
+    }
+    if (runtimeChunk === true || runtimeChunk === 'multiple') {
+        return {
+            name: entrypoint => `runtime~${entrypoint.name}`,
+        };
+    }
+    const { name } = runtimeChunk;
+    return {
+        name: typeof name === 'function' ? name : () => name,
+    };
+};

package/dist/base/numberHash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Computes a hash value for the given string and range. This hashing algorithm is a modified
+ * version of the [FNV-1a algorithm](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function).
+ * It is optimized for speed and does **not** generate a cryptographic hash value.
+ *
+ * We use `numberHash` in `lib/ids/IdHelpers.js` to generate hash values for the module identifier. The generated
+ * hash is used as a prefix for the module id's to avoid collisions with other modules.
+ *
+ * ```js
+ * const numberHash = require("mp-compiler/@/base/util/numberHash");
+ * numberHash("hello", 1000); // 57
+ * numberHash("hello world"); // 990
+ * ```
+ *
+ */
+declare const _default: (str: string, range: number) => number;
+export default _default;