xhs-mp-pack 1.1.0-beta.0

package/dist/base/copyPatterns.js

@@ -0,0 +1,501 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 serialize_javascript_1 = __importDefault(require("serialize-javascript"));
+const normalize_path_1 = __importDefault(require("normalize-path"));
+const glob_parent_1 = __importDefault(require("glob-parent"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_1 = require("@/base/fs");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const webpack_sources_1 = require("webpack-sources");
+const globby_1 = __importDefault(require("globby"));
+const { version } = require('../../package.json');
+const template = /\[\\*([\w:]+)\\*\]/i;
+class CopyPatterns {
+    static createSnapshot(compilation, startTime, dependency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line consistent-return
+            return new Promise((resolve, reject) => {
+                compilation.fileSystemInfo.createSnapshot(startTime, [dependency], undefined, undefined, null, (error, snapshot) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve(snapshot);
+                });
+            });
+        });
+    }
+    static checkSnapshotValid(compilation, snapshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                compilation.fileSystemInfo.checkSnapshotValid(snapshot, (error, isValid) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve(isValid);
+                });
+            });
+        });
+    }
+    static getContentHash(compiler, compilation, source) {
+        const { outputOptions } = compilation;
+        const { hashDigest, hashDigestLength, hashFunction, hashSalt } = outputOptions;
+        const hash = (0, createHash_1.default)(hashFunction);
+        if (hashSalt) {
+            hash.update(hashSalt);
+        }
+        hash.update(source);
+        const fullContentHash = hash.digest(hashDigest);
+        return fullContentHash.toString().slice(0, hashDigestLength);
+    }
+    static runPattern(globby, compiler, compilation, logger, cache, inputPattern, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pattern = Object.assign({}, inputPattern);
+            const originalFrom = pattern.from;
+            const normalizedOriginalFrom = path_1.default.normalize(originalFrom);
+            logger.log(`starting to process a pattern from '${normalizedOriginalFrom}' using '${pattern.context}' context`);
+            let absoluteFrom;
+            if (path_1.default.isAbsolute(normalizedOriginalFrom)) {
+                absoluteFrom = normalizedOriginalFrom;
+            }
+            else {
+                absoluteFrom = path_1.default.resolve(pattern.context, normalizedOriginalFrom);
+            }
+            logger.debug(`getting stats for '${absoluteFrom}'...`);
+            const { inputFileSystem } = compiler;
+            let stats;
+            try {
+                stats = yield (0, fs_1.stat)(inputFileSystem, absoluteFrom);
+            }
+            catch (error) {
+                // Nothing
+            }
+            let fromType;
+            if (stats) {
+                if (stats.isDirectory()) {
+                    fromType = 'dir';
+                    logger.debug(`determined '${absoluteFrom}' is a directory`);
+                }
+                else if (stats.isFile()) {
+                    fromType = 'file';
+                    logger.debug(`determined '${absoluteFrom}' is a file`);
+                }
+                else {
+                    // Fallback
+                    fromType = 'glob';
+                    logger.debug(`determined '${absoluteFrom}' is unknown`);
+                }
+            }
+            else {
+                fromType = 'glob';
+                logger.debug(`determined '${absoluteFrom}' is a glob`);
+            }
+            const globOptions = Object.assign(Object.assign({ followSymbolicLinks: true }, (pattern.globOptions || {})), { cwd: pattern.context, objectMode: true });
+            // @ts-ignore
+            globOptions.fs = inputFileSystem;
+            let glob;
+            switch (fromType) {
+                case 'dir':
+                    compilation.contextDependencies.add(absoluteFrom);
+                    logger.debug(`added '${absoluteFrom}' as a context dependency`);
+                    pattern.context = absoluteFrom;
+                    glob = path_1.default.posix.join(fast_glob_1.default.escapePath((0, normalize_path_1.default)(path_1.default.resolve(absoluteFrom))), '**/*');
+                    absoluteFrom = path_1.default.join(absoluteFrom, '**/*');
+                    if (typeof globOptions.dot === 'undefined') {
+                        globOptions.dot = true;
+                    }
+                    break;
+                case 'file':
+                    compilation.fileDependencies.add(absoluteFrom);
+                    logger.debug(`added '${absoluteFrom}' as a file dependency`);
+                    pattern.context = path_1.default.dirname(absoluteFrom);
+                    glob = fast_glob_1.default.escapePath((0, normalize_path_1.default)(path_1.default.resolve(absoluteFrom)));
+                    if (typeof globOptions.dot === 'undefined') {
+                        globOptions.dot = true;
+                    }
+                    break;
+                case 'glob':
+                default: {
+                    const contextDependencies = path_1.default.normalize((0, glob_parent_1.default)(absoluteFrom));
+                    compilation.contextDependencies.add(contextDependencies);
+                    logger.debug(`added '${contextDependencies}' as a context dependency`);
+                    glob = path_1.default.isAbsolute(originalFrom)
+                        ? originalFrom
+                        : path_1.default.posix.join(fast_glob_1.default.escapePath((0, normalize_path_1.default)(path_1.default.resolve(pattern.context))), originalFrom);
+                }
+            }
+            logger.log(`begin globbing '${glob}'...`);
+            let globEntries;
+            try {
+                globEntries = yield globby(glob, globOptions);
+            }
+            catch (error) {
+                compilation.errors.push(error);
+                return;
+            }
+            if (globEntries.length === 0) {
+                if (pattern.noErrorOnMissing) {
+                    logger.log(`finished to process a pattern from '${normalizedOriginalFrom}' using '${pattern.context}' context to '${pattern.to}'`);
+                    return;
+                }
+                const missingError = new Error(`unable to locate '${glob}' glob`);
+                compilation.errors.push(missingError);
+                return;
+            }
+            let copiedResult;
+            try {
+                copiedResult = yield Promise.all(globEntries.map((globEntry) => __awaiter(this, void 0, void 0, function* () {
+                    // Exclude directories
+                    if (!globEntry.dirent.isFile()) {
+                        return;
+                    }
+                    if (pattern.filter) {
+                        let isFiltered;
+                        try {
+                            isFiltered = yield pattern.filter(globEntry.path);
+                        }
+                        catch (error) {
+                            compilation.errors.push(/** @type {WebpackError} */ error);
+                            return;
+                        }
+                        if (!isFiltered) {
+                            logger.log(`skip '${globEntry.path}', because it was filtered`);
+                            return;
+                        }
+                    }
+                    const from = globEntry.path;
+                    logger.debug(`found '${from}'`);
+                    // `globby`/`fast-glob` return the relative path when the path contains special characters on windows
+                    const absoluteFilename = path_1.default.resolve(pattern.context, from);
+                    const to = typeof pattern.to === 'function'
+                        ? yield pattern.to({
+                            context: pattern.context,
+                            absoluteFilename,
+                        })
+                        : path_1.default.normalize(typeof pattern.to !== 'undefined' ? pattern.to : '');
+                    const toType = pattern.toType
+                        ? pattern.toType
+                        : template.test(to)
+                            ? 'template'
+                            : path_1.default.extname(to) === '' || to.slice(-1) === path_1.default.sep
+                                ? 'dir'
+                                : 'file';
+                    logger.log(`'to' option '${to}' determinated as '${toType}'`);
+                    const relativeFrom = path_1.default.relative(pattern.context, absoluteFilename);
+                    let filename = toType === 'dir' ? path_1.default.join(to, relativeFrom) : to;
+                    if (path_1.default.isAbsolute(filename)) {
+                        filename = path_1.default.relative(compiler.options.output.path, filename);
+                    }
+                    logger.log(`determined that '${from}' should write to '${filename}'`);
+                    const sourceFilename = (0, normalize_path_1.default)(path_1.default.relative(compiler.context, absoluteFilename));
+                    // If this came from a glob or dir, add it to the file dependencies
+                    if (fromType === 'dir' || fromType === 'glob') {
+                        compilation.fileDependencies.add(absoluteFilename);
+                        logger.debug(`added '${absoluteFilename}' as a file dependency`);
+                    }
+                    let cacheEntry;
+                    logger.debug(`getting cache for '${absoluteFilename}'...`);
+                    try {
+                        cacheEntry = yield cache.getPromise(`${sourceFilename}|${index}`, null);
+                    }
+                    catch (error) {
+                        compilation.errors.push(/** @type {WebpackError} */ error);
+                        return;
+                    }
+                    let source;
+                    if (cacheEntry) {
+                        logger.debug(`found cache for '${absoluteFilename}'...`);
+                        let isValidSnapshot;
+                        logger.debug(`checking snapshot on valid for '${absoluteFilename}'...`);
+                        try {
+                            isValidSnapshot = yield CopyPatterns.checkSnapshotValid(compilation, cacheEntry.snapshot);
+                        }
+                        catch (error) {
+                            compilation.errors.push(/** @type {WebpackError} */ error);
+                            return;
+                        }
+                        if (isValidSnapshot) {
+                            logger.debug(`snapshot for '${absoluteFilename}' is valid`);
+                            ({ source } = cacheEntry);
+                        }
+                        else {
+                            logger.debug(`snapshot for '${absoluteFilename}' is invalid`);
+                        }
+                    }
+                    else {
+                        logger.debug(`missed cache for '${absoluteFilename}'`);
+                    }
+                    if (!source) {
+                        const startTime = Date.now();
+                        logger.debug(`reading '${absoluteFilename}'...`);
+                        let data;
+                        try {
+                            data = yield (0, fs_1.readFile)(inputFileSystem, absoluteFilename);
+                        }
+                        catch (error) {
+                            compilation.errors.push(/** @type {WebpackError} */ error);
+                            return;
+                        }
+                        logger.debug(`read '${absoluteFilename}'`);
+                        source = new webpack_sources_1.RawSource(data);
+                        let snapshot;
+                        logger.debug(`creating snapshot for '${absoluteFilename}'...`);
+                        try {
+                            snapshot = yield CopyPatterns.createSnapshot(compilation, startTime, absoluteFilename);
+                        }
+                        catch (error) {
+                            compilation.errors.push(/** @type {WebpackError} */ error);
+                            return;
+                        }
+                        if (snapshot) {
+                            logger.debug(`created snapshot for '${absoluteFilename}'`);
+                            logger.debug(`storing cache for '${absoluteFilename}'...`);
+                            try {
+                                yield cache.storePromise(`${sourceFilename}|${index}`, null, {
+                                    source,
+                                    snapshot,
+                                });
+                            }
+                            catch (error) {
+                                compilation.errors.push(/** @type {WebpackError} */ error);
+                                return;
+                            }
+                            logger.debug(`stored cache for '${absoluteFilename}'`);
+                        }
+                    }
+                    if (pattern.transform) {
+                        const transformObj = typeof pattern.transform === 'function'
+                            ? { transformer: pattern.transform }
+                            : pattern.transform;
+                        if (transformObj.transformer) {
+                            logger.log(`transforming content for '${absoluteFilename}'...`);
+                            const buffer = source.buffer();
+                            if (transformObj.cache) {
+                                // TODO: remove in the next major release
+                                const hasher = (0, createHash_1.default)('xxhash64');
+                                const defaultCacheKeys = {
+                                    version,
+                                    sourceFilename,
+                                    transform: transformObj.transformer,
+                                    contentHash: hasher.update(buffer).digest('hex'),
+                                    index,
+                                };
+                                const cacheKeys = `transform|${(0, serialize_javascript_1.default)(typeof transformObj.cache === 'boolean'
+                                    ? defaultCacheKeys
+                                    : typeof transformObj.cache.keys === 'function'
+                                        ? yield transformObj.cache.keys(defaultCacheKeys, absoluteFilename)
+                                        : Object.assign(Object.assign({}, defaultCacheKeys), transformObj.cache.keys))}`;
+                                logger.debug(`getting transformation cache for '${absoluteFilename}'...`);
+                                const cacheItem = cache.getItemCache(cacheKeys, cache.getLazyHashedEtag(source));
+                                source = yield cacheItem.getPromise();
+                                logger.debug(source
+                                    ? `found transformation cache for '${absoluteFilename}'`
+                                    : `no transformation cache for '${absoluteFilename}'`);
+                                if (!source) {
+                                    const transformed = yield transformObj.transformer(buffer, absoluteFilename);
+                                    source = new webpack_sources_1.RawSource(transformed);
+                                    logger.debug(`caching transformation for '${absoluteFilename}'...`);
+                                    yield cacheItem.storePromise(source);
+                                    logger.debug(`cached transformation for '${absoluteFilename}'`);
+                                }
+                            }
+                            else {
+                                source = new webpack_sources_1.RawSource(yield transformObj.transformer(buffer, absoluteFilename));
+                            }
+                        }
+                    }
+                    let info = typeof pattern.info === 'undefined'
+                        ? {}
+                        : typeof pattern.info === 'function'
+                            ? pattern.info({
+                                absoluteFilename,
+                                sourceFilename,
+                                filename,
+                                toType,
+                            }) || {}
+                            : pattern.info || {};
+                    if (toType === 'template') {
+                        logger.log(`interpolating template '${filename}' for '${sourceFilename}'...`);
+                        const contentHash = CopyPatterns.getContentHash(compiler, compilation, source.buffer());
+                        const ext = path_1.default.extname(sourceFilename);
+                        const base = path_1.default.basename(sourceFilename);
+                        const name = base.slice(0, base.length - ext.length);
+                        const data = {
+                            filename: (0, normalize_path_1.default)(path_1.default.relative(pattern.context, absoluteFilename)),
+                            contentHash,
+                            chunk: {
+                                name,
+                                id: /** @type {string} */ sourceFilename,
+                                hash: contentHash,
+                            },
+                        };
+                        const { path: interpolatedFilename, info: assetInfo } = compilation.getPathWithInfo((0, normalize_path_1.default)(filename), data);
+                        info = Object.assign(Object.assign({}, info), assetInfo);
+                        filename = interpolatedFilename;
+                        logger.log(`interpolated template '${filename}' for '${sourceFilename}'`);
+                    }
+                    else {
+                        filename = (0, normalize_path_1.default)(filename);
+                    }
+                    // eslint-disable-next-line consistent-return
+                    return {
+                        sourceFilename,
+                        absoluteFilename,
+                        filename,
+                        source,
+                        info,
+                        force: pattern.force,
+                    };
+                })));
+            }
+            catch (error) {
+                compilation.errors.push(/** @type {WebpackError} */ error);
+                return;
+            }
+            if (copiedResult.length === 0) {
+                if (pattern.noErrorOnMissing) {
+                    logger.log(`finished to process a pattern from '${normalizedOriginalFrom}' using '${pattern.context}' context to '${pattern.to}'`);
+                    return;
+                }
+                const missingError = new Error(`unable to locate '${glob}' glob after filtering paths`);
+                compilation.errors.push(/** @type {WebpackError} */ missingError);
+                return;
+            }
+            logger.log(`finished to process a pattern from '${normalizedOriginalFrom}' using '${pattern.context}' context`);
+            return copiedResult;
+        });
+    }
+    copy({ compiler, compilation, logger, cache, patterns }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const copiedResultMap = new Map();
+            const scheduledTasks = [];
+            patterns.map((item, index) => scheduledTasks.push(() => __awaiter(this, void 0, void 0, function* () {
+                const normalizedPattern = typeof item === 'string' ? { from: item } : Object.assign({}, item);
+                const context = typeof normalizedPattern.context === 'undefined'
+                    ? compiler.context
+                    : path_1.default.isAbsolute(normalizedPattern.context)
+                        ? normalizedPattern.context
+                        : path_1.default.join(compiler.context, normalizedPattern.context);
+                normalizedPattern.context = context;
+                let copiedResult;
+                try {
+                    copiedResult = yield CopyPatterns.runPattern(globby_1.default, compiler, compilation, logger, cache, normalizedPattern, index);
+                }
+                catch (error) {
+                    compilation.errors.push(error);
+                    return;
+                }
+                if (!copiedResult) {
+                    return;
+                }
+                let filteredCopiedResult = copiedResult.filter(result => Boolean(result));
+                if (typeof normalizedPattern.transformAll !== 'undefined') {
+                    if (typeof normalizedPattern.to === 'undefined') {
+                        compilation.errors.push(new Error(`Invalid "pattern.to" for the "pattern.from": "${normalizedPattern.from}" and "pattern.transformAll" function. The "to" option must be specified.`));
+                        return;
+                    }
+                    filteredCopiedResult.sort((a, b) => a.absoluteFilename > b.absoluteFilename
+                        ? 1
+                        : a.absoluteFilename < b.absoluteFilename
+                            ? -1
+                            : 0);
+                    const mergedEtag = filteredCopiedResult.length === 1
+                        ? cache.getLazyHashedEtag(filteredCopiedResult[0].source)
+                        : filteredCopiedResult.reduce(
+                        // @ts-ignore
+                        (accumulator, asset, i) => {
+                            // eslint-disable-next-line no-param-reassign
+                            accumulator = cache.mergeEtags(i === 1 ? cache.getLazyHashedEtag(accumulator.source) : accumulator, cache.getLazyHashedEtag(asset.source));
+                            return accumulator;
+                        });
+                    const cacheItem = cache.getItemCache(`transformAll|${(0, serialize_javascript_1.default)({
+                        version,
+                        from: normalizedPattern.from,
+                        to: normalizedPattern.to,
+                        transformAll: normalizedPattern.transformAll,
+                    })}`, mergedEtag);
+                    let transformedAsset = yield cacheItem.getPromise();
+                    if (!transformedAsset) {
+                        transformedAsset = { filename: normalizedPattern.to };
+                        try {
+                            transformedAsset.data = yield normalizedPattern.transformAll(filteredCopiedResult.map(asset => ({
+                                data: asset.source.buffer(),
+                                sourceFilename: asset.sourceFilename,
+                                absoluteFilename: asset.absoluteFilename,
+                            })));
+                        }
+                        catch (error) {
+                            compilation.errors.push(/** @type {WebpackError} */ error);
+                            return;
+                        }
+                        const filename = typeof normalizedPattern.to === 'function'
+                            ? yield normalizedPattern.to({ context })
+                            : normalizedPattern.to;
+                        if (template.test(filename)) {
+                            const contentHash = CopyPatterns.getContentHash(compiler, compilation, transformedAsset.data);
+                            const { path: interpolatedFilename, info: assetInfo } = compilation.getPathWithInfo((0, normalize_path_1.default)(filename), {
+                                contentHash,
+                                chunk: {
+                                    id: 'unknown-copied-asset',
+                                    hash: contentHash,
+                                },
+                            });
+                            transformedAsset.filename = interpolatedFilename;
+                            transformedAsset.info = assetInfo;
+                        }
+                        transformedAsset.source = new webpack_sources_1.RawSource(transformedAsset.data);
+                        transformedAsset.force = normalizedPattern.force;
+                        yield cacheItem.storePromise(transformedAsset);
+                    }
+                    filteredCopiedResult = [transformedAsset];
+                }
+                const priority = normalizedPattern.priority || 0;
+                if (!copiedResultMap.has(priority)) {
+                    copiedResultMap.set(priority, []);
+                }
+                copiedResultMap.get(priority).push(...filteredCopiedResult);
+            })));
+            yield (0, fs_1.throttleAll)(100, scheduledTasks);
+            const copiedResult = [...copiedResultMap.entries()].sort((a, b) => a[0] - b[0]);
+            // Avoid writing assets inside `p-limit`, because it creates concurrency.
+            // It could potentially lead to an error - 'Multiple assets emit different content to the same filename'
+            copiedResult
+                .reduce((acc, val) => acc.concat(val[1]), [])
+                .filter(Boolean)
+                .forEach((result) => {
+                const { absoluteFilename, sourceFilename, filename, source, force } = result;
+                const existingAsset = compilation.getAsset(filename);
+                if (existingAsset) {
+                    if (force) {
+                        const info = { copied: true, sourceFilename };
+                        logger.log(`force updating '${filename}' from '${absoluteFilename}' to compilation assets, because it already exists...`);
+                        compilation.updateAsset(filename, source, Object.assign(Object.assign({}, info), result.info));
+                        logger.log(`force updated '${filename}' from '${absoluteFilename}' to compilation assets, because it already exists`);
+                        return;
+                    }
+                    logger.log(`skip adding '${filename}' from '${absoluteFilename}' to compilation assets, because it already exists`);
+                    return;
+                }
+                const info = { copied: true, sourceFilename };
+                logger.log(`writing '${filename}' from '${absoluteFilename}' to compilation assets...`);
+                compilation.emitAsset(filename, source, Object.assign(Object.assign({}, info), result.info));
+                logger.log(`written '${filename}' from '${absoluteFilename}' to compilation assets`);
+            });
+        });
+    }
+}
+exports.default = CopyPatterns;

package/dist/base/createHash.d.ts

@@ -0,0 +1,3 @@
+import Hash from './Hash';
+declare const _default: (algorithm: string | typeof Hash | undefined) => any;
+export default _default;

package/dist/base/createHash.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Hash_1 = __importDefault(require("./Hash"));
+const BULK_SIZE = 2000;
+// We are using an object instead of a Map as this will stay static during the runtime
+// so access to it can be optimized by v8
+const digestCaches = {};
+class BulkUpdateDecorator extends Hash_1.default {
+    constructor(hashOrFactory, hashKey) {
+        super();
+        this.hashKey = hashKey;
+        if (typeof hashOrFactory === 'function') {
+            this.hashFactory = hashOrFactory;
+            this.hash = undefined;
+        }
+        else {
+            this.hashFactory = undefined;
+            this.hash = hashOrFactory;
+        }
+        this.buffer = '';
+    }
+    update(data, inputEncoding) {
+        if (inputEncoding !== undefined || typeof data !== 'string' || data.length > BULK_SIZE) {
+            if (this.hash === undefined)
+                this.hash = this.hashFactory();
+            if (this.buffer.length > 0) {
+                this.hash.update(this.buffer);
+                this.buffer = '';
+            }
+            this.hash.update(data, inputEncoding);
+        }
+        else {
+            this.buffer += data;
+            if (this.buffer.length > BULK_SIZE) {
+                if (this.hash === undefined)
+                    this.hash = this.hashFactory();
+                this.hash.update(this.buffer);
+                this.buffer = '';
+            }
+        }
+        return this;
+    }
+    digest(encoding) {
+        let digestCache;
+        const buffer = this.buffer;
+        if (this.hash === undefined) {
+            // short data for hash, we can use caching
+            const cacheKey = `${this.hashKey}-${encoding}`;
+            digestCache = digestCaches[cacheKey];
+            if (digestCache === undefined) {
+                digestCache = digestCaches[cacheKey] = new Map();
+            }
+            const cacheEntry = digestCache.get(buffer);
+            if (cacheEntry !== undefined)
+                return cacheEntry;
+            this.hash = this.hashFactory();
+        }
+        if (buffer.length > 0) {
+            this.hash.update(buffer);
+        }
+        const digestResult = this.hash.digest(encoding);
+        const result = typeof digestResult === 'string' ? digestResult : digestResult.toString();
+        if (digestCache !== undefined) {
+            digestCache.set(buffer, result);
+        }
+        return result;
+    }
+}
+/* istanbul ignore next */
+class DebugHash extends Hash_1.default {
+    constructor() {
+        super();
+        this.string = '';
+    }
+    update(data, inputEncoding) {
+        if (typeof data !== 'string')
+            data = data.toString('utf-8');
+        const prefix = Buffer.from('@webpack-debug-digest@').toString('hex');
+        if (data.startsWith(prefix)) {
+            data = Buffer.from(data.slice(prefix.length), 'hex').toString();
+        }
+        // @ts-ignore
+        this.string += `[${data}](${new Error().stack.split('\n', 3)[2]})\n`;
+        return this;
+    }
+    digest(encoding) {
+        return Buffer.from(`@webpack-debug-digest@${this.string}`).toString('hex');
+    }
+}
+let crypto;
+let createXXHash64;
+let createMd4;
+let BatchedHash;
+exports.default = (algorithm) => {
+    if (typeof algorithm === 'function') {
+        // eslint-disable-next-line new-cap
+        return new BulkUpdateDecorator(() => new algorithm());
+    }
+    switch (algorithm) {
+        // TODO add non-cryptographic algorithm here
+        case 'debug':
+            return new DebugHash();
+        case 'xxhash64':
+            if (createXXHash64 === undefined) {
+                createXXHash64 = require('./hash/xxhash64').default;
+                if (BatchedHash === undefined) {
+                    BatchedHash = require('./hash/BatchedHash').default;
+                }
+            }
+            return new BatchedHash(createXXHash64());
+        case 'md4':
+            if (createMd4 === undefined) {
+                createMd4 = require('./hash/md4').default;
+                if (BatchedHash === undefined) {
+                    BatchedHash = require('./hash/BatchedHash').default;
+                }
+            }
+            return new BatchedHash(createMd4());
+        case 'native-md4':
+            if (crypto === undefined)
+                crypto = require('crypto');
+            return new BulkUpdateDecorator(() => crypto.createHash('md4'), 'md4');
+        default:
+            if (crypto === undefined)
+                crypto = require('crypto');
+            return new BulkUpdateDecorator(() => crypto.createHash(algorithm), algorithm);
+    }
+};

package/dist/base/defaults.d.ts

@@ -0,0 +1,3 @@
+declare const applyWebpackOptionsBaseDefaults: (options: any) => void;
+declare const applyWebpackOptionsDefaults: (options: any) => void;
+export { applyWebpackOptionsBaseDefaults, applyWebpackOptionsDefaults };