xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/UseStrictPlugin.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const PLUGIN_NAME = 'UseStrictPlugin';
+class UseStrictPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const handler = parser => {
+                parser.hooks.program.tap(PLUGIN_NAME, ast => {
+                    const firstNode = ast.body[0];
+                    if (firstNode &&
+                        firstNode.type === 'ExpressionStatement' &&
+                        firstNode.expression.type === 'Literal' &&
+                        firstNode.expression.value === 'use strict') {
+                        // Remove "use strict" expression. It will be added later by the renderer again.
+                        // This is necessary in order to not break the strict mode when webpack prepends code.
+                        // @see https://github.com/webpack/webpack/issues/1970
+                        const dep = new ConstDependency_1.default('', firstNode.range);
+                        dep.loc = firstNode.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        parser.state.module.buildInfo.strict = true;
+                    }
+                });
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+exports.default = UseStrictPlugin;

package/dist/plugins/WarnCaseSensitiveModulesPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class WarnCaseSensitiveModulesPlugin {
+    apply(compiler: any): void;
+}
+export default WarnCaseSensitiveModulesPlugin;

package/dist/plugins/WarnCaseSensitiveModulesPlugin.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CaseSensitiveModulesWarning_1 = __importDefault(require("@/base/errors/CaseSensitiveModulesWarning"));
+class WarnCaseSensitiveModulesPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('WarnCaseSensitiveModulesPlugin', compilation => {
+            compilation.hooks.seal.tap('WarnCaseSensitiveModulesPlugin', () => {
+                var _a;
+                const moduleWithoutCase = new Map();
+                for (const module of compilation.modules) {
+                    const identifier = module.identifier();
+                    // Ignore `data:` URLs, because it's not a real path
+                    if (((_a = module.resourceResolveData) === null || _a === void 0 ? void 0 : _a.encodedContent) !== undefined) {
+                        continue;
+                    }
+                    const lowerIdentifier = identifier.toLowerCase();
+                    let map = moduleWithoutCase.get(lowerIdentifier);
+                    if (map === undefined) {
+                        map = new Map();
+                        moduleWithoutCase.set(lowerIdentifier, map);
+                    }
+                    map.set(identifier, module);
+                }
+                for (const pair of moduleWithoutCase) {
+                    const map = pair[1];
+                    if (map.size > 1) {
+                        compilation.warnings.push(new CaseSensitiveModulesWarning_1.default(map.values(), compilation.moduleGraph));
+                    }
+                }
+            });
+        });
+    }
+}
+exports.default = WarnCaseSensitiveModulesPlugin;

package/dist/plugins/WarnDeprecatedOptionPlugin.d.ts

@@ -0,0 +1,8 @@
+declare class WarnDeprecatedOptionPlugin {
+    option: string;
+    value: string | number;
+    suggestion: string;
+    constructor(option: any, value: any, suggestion: any);
+    apply(compiler: any): void;
+}
+export default WarnDeprecatedOptionPlugin;

package/dist/plugins/WarnDeprecatedOptionPlugin.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+class WarnDeprecatedOptionPlugin {
+    constructor(option, value, suggestion) {
+        this.option = option;
+        this.value = value;
+        this.suggestion = suggestion;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('WarnDeprecatedOptionPlugin', compilation => {
+            compilation.warnings.push(new DeprecatedOptionWarning(this.option, this.value, this.suggestion));
+        });
+    }
+}
+class DeprecatedOptionWarning extends BaseError_1.default {
+    constructor(option, value, suggestion) {
+        super();
+        this.name = 'DeprecatedOptionWarning';
+        this.message =
+            '@/configuration\n' +
+                `The value '${value}' for option '${option}' is deprecated. ` +
+                `Use '${suggestion}' instead.`;
+    }
+}
+exports.default = WarnDeprecatedOptionPlugin;

package/dist/plugins/cssMinimizer/CssMinimizerMinify.js

@@ -0,0 +1,73 @@
+
+// @ts-nocheck
+const minify = async (options) => {
+    const minifyFns = Array.isArray(options.minimizer.implementation)
+        ? options.minimizer.implementation
+        : [options.minimizer.implementation];
+
+    const result = { outputs: [], warnings: [], errors: [] };
+
+    let needSourceMap = false;
+
+    for (let i = 0; i <= minifyFns.length - 1; i++) {
+        const minifyFn = minifyFns[i];
+        const minifyOptions = Array.isArray(options.minimizer.options)
+            ? options.minimizer.options[i]
+            : options.minimizer.options;
+        const prevResult =
+            result.outputs.length > 0
+                ? result.outputs[result.outputs.length - 1]
+                : { code: options.input, map: options.inputSourceMap };
+        const { code, map } = prevResult;
+        // eslint-disable-next-line no-await-in-loop
+        const minifyResult = await minifyFn(
+            { [options.name]: code },
+            map,
+            minifyOptions
+        );
+
+        if (typeof minifyResult.code !== "string") {
+            throw new Error(
+                "minimizer function doesn't return the 'code' property or result is not a string value"
+            );
+        }
+
+        if (minifyResult.map) {
+            needSourceMap = true;
+        }
+
+        if (minifyResult.errors) {
+            result.errors = result.errors.concat(minifyResult.errors);
+        }
+
+        if (minifyResult.warnings) {
+            result.warnings = result.warnings.concat(minifyResult.warnings);
+        }
+
+        result.outputs.push({ code: minifyResult.code, map: minifyResult.map });
+    }
+
+    if (!needSourceMap) {
+        result.outputs = [result.outputs[result.outputs.length - 1]];
+    }
+
+    return result;
+};
+
+async function transform(options) {
+    // 'use strict' => this === undefined (Clean Scope)
+    // Safer for possible security issues, albeit not critical at all here
+    // eslint-disable-next-line no-new-func, no-param-reassign
+    const evaluatedOptions = new Function(
+        "exports",
+        "require",
+        "module",
+        "__filename",
+        "__dirname",
+        `'use strict'\nreturn ${options}`
+    )(exports, require, module, __filename, __dirname);
+
+    return minify(evaluatedOptions);
+}
+
+module.exports = { minify, transform };

package/dist/plugins/cssMinimizer/CssMinimizerPlugin.d.ts

@@ -0,0 +1,11 @@
+declare class CssMinimizerPlugin {
+    options: any;
+    constructor(options: any);
+    static isSourceMap(input: any): boolean;
+    static buildWarning(warning: any, file: any, warningsFilter: any, sourceMap: any, requestShortener: any): any;
+    static buildError(error: any, file: any, sourceMap: any, requestShortener: any): any;
+    static getAvailableNumberOfCores(parallel: any): number;
+    optimize(compiler: any, compilation: any, assets: any, optimizeOptions: any): Promise<void>;
+    apply(compiler: any): void;
+}
+export default CssMinimizerPlugin;

package/dist/plugins/cssMinimizer/CssMinimizerPlugin.js

@@ -0,0 +1,329 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __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 os_1 = __importDefault(require("os"));
+const webpack_sources_1 = require("webpack-sources");
+const Compilation_1 = __importDefault(require("@/Compilation"));
+const ModuleFilenameHelpers = __importStar(require("@/base/ModuleFilenameHelpers"));
+const warningRegex = /\s.+:+([0-9]+):+([0-9]+)/;
+const { throttleAll, memoize, cssnanoMinify } = require('./CssMinimizerUtils');
+const { minify: minifyWorker } = require('./CssMinimizerMinify');
+const getSerializeJavascript = memoize(() => require('serialize-javascript'));
+const getTraceMapping = memoize(() => require('@jridgewell/trace-mapping'));
+class CssMinimizerPlugin {
+    constructor(options) {
+        const { minify = cssnanoMinify, minimizerOptions = {}, test = /\.css(\?.*)?$/i, warningsFilter = () => true, parallel = true, include, exclude, } = options || {};
+        this.options = {
+            test,
+            warningsFilter,
+            parallel,
+            include,
+            exclude,
+            minimizer: {
+                implementation: minify,
+                options: minimizerOptions,
+            },
+        };
+    }
+    static isSourceMap(input) {
+        // All required options for `new SourceMapConsumer(...options)`
+        // https://github.com/mozilla/source-map#new-sourcemapconsumerrawsourcemap
+        return Boolean((input === null || input === void 0 ? void 0 : input.version) &&
+            (input === null || input === void 0 ? void 0 : input.sources) &&
+            Array.isArray(input.sources) &&
+            typeof input.mappings === 'string');
+    }
+    static buildWarning(warning, file, warningsFilter, sourceMap, requestShortener) {
+        let warningMessage = typeof warning === 'string'
+            ? warning
+            : `${warning.plugin ? `[${warning.plugin}] ` : ''}${warning.text || warning.message}`;
+        let locationMessage = '';
+        let source;
+        if (sourceMap) {
+            let line;
+            let column;
+            if (typeof warning === 'string') {
+                const match = warningRegex.exec(warning);
+                if (match) {
+                    line = +match[1];
+                    column = +match[2];
+                }
+            }
+            else {
+                ;
+                ({ line, column } = warning);
+            }
+            if (line && column) {
+                const original = sourceMap &&
+                    getTraceMapping().originalPositionFor(sourceMap, {
+                        line,
+                        column,
+                    });
+                if ((original === null || original === void 0 ? void 0 : original.source) !== file && requestShortener) {
+                    ;
+                    ({ source } = original);
+                    warningMessage = `${warningMessage.replace(warningRegex, '')}`;
+                    locationMessage = `${requestShortener.shorten(original.source)}:${original.line}:${original.column}`;
+                }
+            }
+        }
+        if (warningsFilter && !warningsFilter(warning, file, source)) {
+            return;
+        }
+        const builtWarning = new Error(`${file} from Css Minimizer plugin\n${warningMessage}${locationMessage ? ` ${locationMessage}` : ''}`);
+        builtWarning.name = 'Warning';
+        builtWarning.hideStack = true;
+        builtWarning.file = file;
+        // eslint-disable-next-line consistent-return
+        return builtWarning;
+    }
+    static buildError(error, file, sourceMap, requestShortener) {
+        let builtError;
+        if (typeof error === 'string') {
+            builtError = new Error(`${file} from Css Minimizer plugin\n${error}`);
+            builtError.file = file;
+            return builtError;
+        }
+        if (error.column) {
+            const { line, column } = error;
+            const original = sourceMap && getTraceMapping().originalPositionFor(sourceMap, { line, column });
+            if ((original === null || original === void 0 ? void 0 : original.source) && requestShortener) {
+                builtError = new Error(`${file} from Css Minimizer plugin\n${error.message} [${requestShortener.shorten(original.source)}:${original.line},${original.column}][${file}:${line},${column}]${error.stack ? `\n${error.stack.split('\n').slice(1).join('\n')}` : ''}`);
+                builtError.file = file;
+                return builtError;
+            }
+            builtError = new Error(`${file} from Css Minimizer plugin\n${error.message} [${file}:${line},${column}]${error.stack ? `\n${error.stack.split('\n').slice(1).join('\n')}` : ''}`);
+            builtError.file = file;
+            return builtError;
+        }
+        if (error.stack) {
+            builtError = new Error(`${file} from Css Minimizer plugin\n${error.stack}`);
+            builtError.file = file;
+            return builtError;
+        }
+        builtError = new Error(`${file} from Css Minimizer plugin\n${error.message}`);
+        builtError.file = file;
+        return builtError;
+    }
+    static getAvailableNumberOfCores(parallel) {
+        const cpus = os_1.default.cpus() || { length: 1 };
+        return parallel === true ? cpus.length - 1 : Math.min(Number(parallel) || 0, cpus.length - 1);
+    }
+    optimize(compiler, compilation, assets, optimizeOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cache = compilation.getCache('CssMinimizerWebpackPlugin');
+            let numberOfAssetsForMinify = 0;
+            const assetsForMinify = yield Promise.all(Object.keys(typeof assets === 'undefined' ? compilation.assets : assets)
+                .filter(name => {
+                const { info } = compilation.getAsset(name);
+                if (
+                // Skip double minimize assets from child compilation
+                info.minimized) {
+                    return false;
+                }
+                if (!ModuleFilenameHelpers.matchObject.bind(undefined, this.options)(name)) {
+                    return false;
+                }
+                return true;
+            })
+                .map((name) => __awaiter(this, void 0, void 0, function* () {
+                const { info, source } = compilation.getAsset(name);
+                const eTag = cache.getLazyHashedEtag(source);
+                const cacheItem = cache.getItemCache(name, eTag);
+                const output = yield cacheItem.getPromise();
+                if (!output) {
+                    numberOfAssetsForMinify += 1;
+                }
+                return { name, info, inputSource: source, output, cacheItem };
+            })));
+            if (assetsForMinify.length === 0) {
+                return;
+            }
+            let getWorker;
+            let initializedWorker;
+            let numberOfWorkers;
+            if (optimizeOptions.availableNumberOfCores > 0) {
+                // Do not create unnecessary workers when the number of files is less than the available cores, it saves memory
+                numberOfWorkers = Math.min(numberOfAssetsForMinify, optimizeOptions.availableNumberOfCores);
+                getWorker = () => {
+                    if (initializedWorker) {
+                        return initializedWorker;
+                    }
+                    const { Worker } = require('jest-worker');
+                    initializedWorker = new Worker(require.resolve('@/plugins/cssMinimizer/CssMinimizerMinify'), {
+                        numWorkers: numberOfWorkers,
+                        enableWorkerThreads: true,
+                    });
+                    // https://github.com/facebook/jest/issues/8872#issuecomment-524822081
+                    const workerStdout = initializedWorker.getStdout();
+                    if (workerStdout) {
+                        workerStdout.on('data', chunk => process.stdout.write(chunk));
+                    }
+                    const workerStderr = initializedWorker.getStderr();
+                    if (workerStderr) {
+                        workerStderr.on('data', chunk => process.stderr.write(chunk));
+                    }
+                    return initializedWorker;
+                };
+            }
+            const scheduledTasks = [];
+            for (const asset of assetsForMinify) {
+                // @ts-ignore
+                scheduledTasks.push(() => __awaiter(this, void 0, void 0, function* () {
+                    const { name, inputSource, cacheItem } = asset;
+                    let { output } = asset;
+                    if (!output) {
+                        let input;
+                        let inputSourceMap;
+                        const { source: sourceFromInputSource, map } = inputSource.sourceAndMap();
+                        input = sourceFromInputSource;
+                        if (map) {
+                            if (!CssMinimizerPlugin.isSourceMap(map)) {
+                                compilation.warnings.push(new Error(`${name} contains invalid source map`));
+                            }
+                            else {
+                                inputSourceMap = map;
+                            }
+                        }
+                        if (Buffer.isBuffer(input)) {
+                            input = input.toString();
+                        }
+                        const options = {
+                            name,
+                            input,
+                            inputSourceMap,
+                            minimizer: {
+                                implementation: this.options.minimizer.implementation,
+                                options: this.options.minimizer.options,
+                            },
+                        };
+                        let result;
+                        try {
+                            result = yield (getWorker
+                                ? getWorker().transform(getSerializeJavascript()(options))
+                                : minifyWorker(options));
+                        }
+                        catch (error) {
+                            const hasSourceMap = inputSourceMap && CssMinimizerPlugin.isSourceMap(inputSourceMap);
+                            compilation.errors.push(CssMinimizerPlugin.buildError(error, name, hasSourceMap ? new (getTraceMapping().TraceMap)(inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined));
+                            return;
+                        }
+                        output = { warnings: [], errors: [] };
+                        for (const item of result.outputs) {
+                            if (item.map) {
+                                let originalSource;
+                                let innerSourceMap;
+                                if (output.source) {
+                                    ;
+                                    ({ source: originalSource, map: innerSourceMap } = output.source.sourceAndMap());
+                                }
+                                else {
+                                    originalSource = input;
+                                    innerSourceMap = inputSourceMap;
+                                }
+                                // TODO need API for merging source maps in `webpack-source`
+                                output.source = new webpack_sources_1.SourceMapSource(item.code, name, item.map, originalSource, innerSourceMap, true);
+                            }
+                            else {
+                                output.source = new webpack_sources_1.RawSource(item.code);
+                            }
+                        }
+                        if (result.errors && result.errors.length > 0) {
+                            const hasSourceMap = inputSourceMap && CssMinimizerPlugin.isSourceMap(inputSourceMap);
+                            for (const error of result.errors) {
+                                output.warnings.push(CssMinimizerPlugin.buildError(error, name, hasSourceMap ? new (getTraceMapping().TraceMap)(inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined));
+                            }
+                        }
+                        if (result.warnings && result.warnings.length > 0) {
+                            const hasSourceMap = inputSourceMap && CssMinimizerPlugin.isSourceMap(inputSourceMap);
+                            for (const warning of result.warnings) {
+                                const buildWarning = CssMinimizerPlugin.buildWarning(warning, name, this.options.warningsFilter, hasSourceMap ? new (getTraceMapping().TraceMap)(inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined);
+                                if (buildWarning) {
+                                    output.warnings.push(buildWarning);
+                                }
+                            }
+                        }
+                        yield cacheItem.storePromise({
+                            source: output.source,
+                            warnings: output.warnings,
+                            errors: output.errors,
+                        });
+                    }
+                    if (output.warnings && output.warnings.length > 0) {
+                        for (const warning of output.warnings) {
+                            compilation.warnings.push(warning);
+                        }
+                    }
+                    if (output.errors && output.errors.length > 0) {
+                        for (const error of output.errors) {
+                            compilation.errors.push(error);
+                        }
+                    }
+                    const newInfo = { minimized: true };
+                    const { source } = output;
+                    compilation.updateAsset(name, source, newInfo);
+                }));
+            }
+            const limit = getWorker && numberOfAssetsForMinify > 0 ? numberOfWorkers : scheduledTasks.length;
+            yield throttleAll(limit, scheduledTasks);
+            if (initializedWorker) {
+                yield initializedWorker.end();
+            }
+        });
+    }
+    apply(compiler) {
+        const pluginName = this.constructor.name;
+        const availableNumberOfCores = CssMinimizerPlugin.getAvailableNumberOfCores(this.options.parallel);
+        compiler.hooks.compilation.tap(pluginName, compilation => {
+            compilation.hooks.processAssets.tapPromise({
+                name: pluginName,
+                stage: Compilation_1.default.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                additionalAssets: true,
+            }, assets => this.optimize(compiler, compilation, assets, {
+                availableNumberOfCores,
+            }));
+            compilation.hooks.statsPrinter.tap(pluginName, stats => {
+                stats.hooks.print
+                    .for('asset.info.minimized')
+                    .tap('css-minimizer-webpack-plugin', (minimized, { green, formatFlag }) => minimized ? green(formatFlag('minimized')) : '');
+            });
+        });
+    }
+}
+// @ts-ignore
+CssMinimizerPlugin.cssnanoMinify = cssnanoMinify;
+exports.default = CssMinimizerPlugin;

package/dist/plugins/cssMinimizer/CssMinimizerUtils.js

@@ -0,0 +1,147 @@
+// @ts-nocheck
+const notSettled = Symbol(`not-settled`)
+
+function throttleAll(limit, tasks) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new TypeError(
+      `Expected \`limit\` to be a finite number > 0, got \`${limit}\` (${typeof limit})`,
+    )
+  }
+
+  if (!Array.isArray(tasks) || !tasks.every(task => typeof task === `function`)) {
+    throw new TypeError(`Expected \`tasks\` to be a list of functions returning a promise`)
+  }
+
+  return new Promise((resolve, reject) => {
+    const result = Array(tasks.length).fill(notSettled)
+    const entries = tasks.entries()
+    const next = () => {
+      const { done, value } = entries.next()
+
+      if (done) {
+        const isLast = !result.includes(notSettled)
+
+        if (isLast) resolve(result)
+
+        return
+      }
+
+      const [index, task] = value
+
+      const onFulfilled = x => {
+        result[index] = x
+        next()
+      }
+
+      task().then(onFulfilled, reject)
+    }
+
+    Array(limit).fill(0).forEach(next)
+  })
+}
+
+async function cssnanoMinify(input, sourceMap, minimizerOptions = { preset: 'default' }) {
+  const load = async module => {
+    let exports
+
+    try {
+      // eslint-disable-next-line import/no-dynamic-require, global-require
+      exports = require(module)
+
+      return exports
+    } catch (requireError) {
+      let importESM
+
+      try {
+        // eslint-disable-next-line no-new-func
+        importESM = new Function('id', 'return import(id);')
+      } catch (e) {
+        importESM = null
+      }
+
+      if (requireError.code === 'ERR_REQUIRE_ESM' && importESM) {
+        exports = await importESM(module)
+
+        return exports.default
+      }
+
+      throw requireError
+    }
+  }
+
+  const [[name, code]] = Object.entries(input)
+  const postcssOptions = {
+    from: name,
+    ...minimizerOptions.processorOptions,
+  }
+
+  if (typeof postcssOptions.parser === 'string') {
+    try {
+      postcssOptions.parser = await load(postcssOptions.parser)
+    } catch (error) {
+      throw new Error(
+        `Loading PostCSS "${postcssOptions.parser}" parser failed: ${error.message}\n\n(@${name})`,
+      )
+    }
+  }
+
+  if (typeof postcssOptions.stringifier === 'string') {
+    try {
+      postcssOptions.stringifier = await load(postcssOptions.stringifier)
+    } catch (error) {
+      throw new Error(
+        `Loading PostCSS "${postcssOptions.stringifier}" stringifier failed: ${error.message}\n\n(@${name})`,
+      )
+    }
+  }
+
+  if (typeof postcssOptions.syntax === 'string') {
+    try {
+      postcssOptions.syntax = await load(postcssOptions.syntax)
+    } catch (error) {
+      throw new Error(
+        `Loading PostCSS "${postcssOptions.syntax}" syntax failed: ${error.message}\n\n(@${name})`,
+      )
+    }
+  }
+
+  if (sourceMap) {
+    postcssOptions.map = { annotation: false }
+  }
+
+  const postcss = require('postcss').default
+  const cssnano = require('cssnano')
+  const result = await postcss([cssnano(minimizerOptions)]).process(code, postcssOptions)
+
+  return {
+    code: result.css,
+    map: result.map ? result.map.toJSON() : undefined,
+    warnings: result.warnings().map(String),
+  }
+}
+
+
+function 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
+    // eslint-disable-next-line no-undefined, no-param-reassign
+    fn = undefined
+
+    return result
+  }
+}
+
+module.exports = {
+  throttleAll,
+  memoize,
+  cssnanoMinify,
+}