Index: frontend/node_modules/terser-webpack-plugin/dist/index.js =================================================================== --- frontend/node_modules/terser-webpack-plugin/dist/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/terser-webpack-plugin/dist/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,765 @@ +"use strict"; + +const os = require("os"); +const path = require("path"); +const { + validate +} = require("schema-utils"); +const { + minify +} = require("./minify"); +const schema = require("./options.json"); +const { + cleanCssMinify, + cssnanoMinify, + cssoMinify, + esbuildMinify, + esbuildMinifyCss, + getEcmaVersion, + htmlMinifierTerser, + jsonMinify, + lightningCssMinify, + memoize, + minifyHtmlNode, + swcMinify, + swcMinifyCss, + swcMinifyHtml, + swcMinifyHtmlFragment, + terserMinify, + throttleAll, + uglifyJsMinify +} = require("./utils"); + +/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */ +/** @typedef {import("webpack").Compiler} Compiler */ +/** @typedef {import("webpack").Compilation} Compilation */ +/** @typedef {import("webpack").Asset} Asset */ +/** @typedef {import("webpack").AssetInfo} AssetInfo */ +/** @typedef {import("webpack").TemplatePath} TemplatePath */ +/** @typedef {import("jest-worker").Worker} JestWorker */ +/** @typedef {import("@jridgewell/trace-mapping").EncodedSourceMap & { sources: string[], sourcesContent?: string[], file: string }} RawSourceMap */ +/** @typedef {import("@jridgewell/trace-mapping").TraceMap} TraceMap */ + +/** @typedef {RegExp | string} Rule */ +/** @typedef {Rule[] | Rule} Rules */ + +// eslint-disable-next-line jsdoc/reject-any-type +/** @typedef {any} EXPECTED_ANY */ +// eslint-disable-next-line jsdoc/require-property +/** @typedef {object} EXPECTED_OBJECT */ + +/** + * @callback ExtractCommentsFunction + * @param {EXPECTED_ANY} astNode ast Node + * @param {{ value: string, type: "comment1" | "comment2" | "comment3" | "comment4", pos: number, line: number, col: number }} comment comment node + * @returns {boolean} true when need to extract comment, otherwise false + */ + +/** + * @typedef {boolean | "all" | "some" | RegExp | ExtractCommentsFunction} ExtractCommentsCondition + */ + +/** + * @typedef {TemplatePath} ExtractCommentsFilename + */ + +/** + * @typedef {boolean | string | ((commentsFile: string) => string)} ExtractCommentsBanner + */ + +/** + * @typedef {object} ExtractCommentsObject + * @property {ExtractCommentsCondition=} condition condition which comments need to be expected + * @property {ExtractCommentsFilename=} filename filename for extracted comments + * @property {ExtractCommentsBanner=} banner banner in filename for extracted comments + */ + +/** + * @typedef {ExtractCommentsCondition | ExtractCommentsObject} ExtractCommentsOptions + */ + +/** + * @typedef {object} ErrorObject + * @property {string} message message + * @property {number=} line line number + * @property {number=} column column number + * @property {string=} stack error stack trace + */ + +/** + * @typedef {object} MinimizedResult + * @property {string=} code code + * @property {RawSourceMap=} map source map + * @property {(Error | string)[]=} errors errors + * @property {(Error | string)[]=} warnings warnings + * @property {string[]=} extractedComments extracted comments + */ + +/** + * @typedef {{ [file: string]: string }} Input + */ + +/** + * @typedef {{ [key: string]: EXPECTED_ANY }} CustomOptions + */ + +/** + * @template T + * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType + */ + +/** + * @template T + * @typedef {T extends EXPECTED_ANY[] ? { [P in keyof T]?: T[P] & InferDefaultType } : T & InferDefaultType} MinimizerOptions + */ + +/** + * @template T + * @callback BasicMinimizerImplementation + * @param {Input} input + * @param {RawSourceMap | undefined} sourceMap + * @param {MinimizerOptions} minifyOptions + * @param {ExtractCommentsOptions | undefined} extractComments + * @returns {Promise | MinimizedResult} + */ + +/** + * @typedef {object} MinimizeFunctionHelpers + * @property {() => string | undefined=} getMinimizerVersion function that returns version of minimizer + * @property {() => boolean | undefined=} supportsWorkerThreads true when minimizer support worker threads, otherwise false + * @property {() => boolean | undefined=} supportsWorker true when minimizer support worker, otherwise false + * @property {(name: string, info?: AssetInfo) => boolean | undefined=} filter return true when the minimizer supports the asset, otherwise false. When an array of minimizers is configured, each asset is dispatched only to the minimizers whose `filter` accepts it. Assets rejected by every minimizer in the array are skipped entirely. + */ + +/** + * @template T + * @typedef {T extends EXPECTED_ANY[] ? { [P in keyof T]: BasicMinimizerImplementation & MinimizeFunctionHelpers } : BasicMinimizerImplementation & MinimizeFunctionHelpers} MinimizerImplementation + */ + +/** + * @template T + * @typedef {object} InternalOptions + * @property {string} name name + * @property {string} input input + * @property {RawSourceMap | undefined} inputSourceMap input source map + * @property {ExtractCommentsOptions | undefined} extractComments extract comments option + * @property {{ implementation: MinimizerImplementation, options: MinimizerOptions }} minimizer minimizer + * @property {boolean=} module true when code is a EC module, otherwise false + * @property {number | string=} ecma ecma version + */ + +/** + * @template T + * @typedef {JestWorker & { transform: (options: string) => Promise, minify: (options: InternalOptions) => Promise }} MinimizerWorker + */ + +/** + * @typedef {undefined | boolean | number} Parallel + */ + +/** + * @typedef {object} BasePluginOptions + * @property {Rules=} test test rule + * @property {Rules=} include include rile + * @property {Rules=} exclude exclude rule + * @property {ExtractCommentsOptions=} extractComments extract comments options + * @property {Parallel=} parallel parallel option + */ + +/** + * @template T + * @typedef {T extends import("terser").MinifyOptions ? { minify?: MinimizerImplementation | undefined, minimizerOptions?: MinimizerOptions | undefined, terserOptions?: MinimizerOptions | undefined } : { minify: MinimizerImplementation, minimizerOptions?: MinimizerOptions | undefined, terserOptions?: MinimizerOptions | undefined }} DefinedDefaultMinimizerAndOptions + */ + +/** + * @template T + * @typedef {BasePluginOptions & { minimizer: { implementation: MinimizerImplementation, options: MinimizerOptions } }} InternalPluginOptions + */ + +const getTraceMapping = memoize(() => require("@jridgewell/trace-mapping")); +const getSerializeJavascript = memoize(() => require("./serialize-javascript")); + +/** + * @template [T=import("terser").MinifyOptions] + */ +class TerserPlugin { + /** + * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions=} options options + */ + constructor(options) { + validate(/** @type {Schema} */schema, options || {}, { + name: "Terser Plugin", + baseDataPath: "options" + }); + + // TODO handle json and etc in the next major release + // TODO make `minimizer` option instead `minify` and `terserOptions` in the next major release, also rename `terserMinify` to `terserMinimize` + const { + minify = (/** @type {MinimizerImplementation} */ + /** @type {unknown} */terserMinify), + minimizerOptions, + terserOptions, + test = /\.[cm]?js(\?.*)?$/i, + extractComments = true, + parallel = true, + include, + exclude + } = options || {}; + + // `terserOptions` is a deprecated alias of `minimizerOptions`; prefer the + // new name when both are provided. + const resolvedMinimizerOptions = /** @type {MinimizerOptions} */ + + typeof minimizerOptions !== "undefined" ? minimizerOptions : terserOptions || {}; + + /** + * @private + * @type {InternalPluginOptions} + */ + this.options = { + test, + extractComments, + parallel, + include, + exclude, + minimizer: { + implementation: minify, + options: resolvedMinimizerOptions + } + }; + } + + /** + * @private + * @param {unknown} input Input to check + * @returns {boolean} Whether input is a source map + */ + static isSourceMap(input) { + // All required options for `new TraceMap(...options)` + // https://github.com/jridgewell/trace-mapping#usage + return Boolean(input && typeof input === "object" && input !== null && "version" in input && "sources" in input && Array.isArray(input.sources) && "mappings" in input && typeof input.mappings === "string"); + } + + /** + * @private + * @param {unknown} warning warning + * @param {string} file file + * @returns {Error} built warning + */ + static buildWarning(warning, file) { + /** + * @type {Error & { hideStack: true, file: string }} + */ + // @ts-expect-error + const builtWarning = new Error(warning.toString()); + builtWarning.name = "Warning"; + builtWarning.hideStack = true; + builtWarning.file = file; + return builtWarning; + } + + /** + * @private + * @param {Error | ErrorObject | string} error error + * @param {string} file file + * @param {TraceMap=} sourceMap source map + * @param {Compilation["requestShortener"]=} requestShortener request shortener + * @returns {Error} built error + */ + static buildError(error, file, sourceMap, requestShortener) { + /** + * @type {Error & { file?: string }} + */ + let builtError; + if (typeof error === "string") { + builtError = new Error(`${file} from Terser plugin\n${error}`); + builtError.file = file; + return builtError; + } + if (/** @type {ErrorObject} */error.line) { + const { + line, + column + } = /** @type {ErrorObject & { line: number, column: number }} */error; + const original = sourceMap && getTraceMapping().originalPositionFor(sourceMap, { + line, + column + }); + if (original && original.source && requestShortener) { + builtError = new Error(`${file} from Terser 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 Terser 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 Terser plugin\n${typeof error.message !== "undefined" ? error.message : ""}\n${error.stack}`); + builtError.file = file; + return builtError; + } + builtError = new Error(`${file} from Terser plugin\n${error.message}`); + builtError.file = file; + return builtError; + } + + /** + * @private + * @param {Parallel} parallel value of the `parallel` option + * @returns {number} number of cores for parallelism + */ + static getAvailableNumberOfCores(parallel) { + // In some cases cpus() returns undefined + // https://github.com/nodejs/node/issues/19022 + const cpus = + // eslint-disable-next-line n/no-unsupported-features/node-builtins + typeof os.availableParallelism === "function" ? + // eslint-disable-next-line n/no-unsupported-features/node-builtins + { + length: os.availableParallelism() + } : os.cpus() || { + length: 1 + }; + return parallel === true || typeof parallel === "undefined" ? cpus.length - 1 : Math.min(parallel || 0, cpus.length - 1); + } + + /** + * @private + * @param {Compiler} compiler compiler + * @param {Compilation} compilation compilation + * @param {Record} assets assets + * @param {{ availableNumberOfCores: number }} optimizeOptions optimize options + * @returns {Promise} + */ + async optimize(compiler, compilation, assets, optimizeOptions) { + const cache = compilation.getCache("TerserWebpackPlugin"); + let numberOfAssets = 0; + + // Normalize the implementation list to an array so dispatch and the + // worker-pool capability checks below can iterate uniformly. The + // original shape on `this.options.minimizer.implementation` is preserved + // for chunk hashing. + const implementations = Array.isArray(this.options.minimizer.implementation) ? this.options.minimizer.implementation : [this.options.minimizer.implementation]; + + /** + * Collect the indices of minimizers whose `filter` accepts `name`. + * Filters returning `undefined` are treated as accept (matches the + * convention used by `supportsWorkerThreads`). + * @param {string} name asset name + * @param {AssetInfo} info asset info + * @returns {number[]} indices into `implementations` that accept the asset + */ + const matchingMinimizers = (name, info) => { + const matched = []; + for (let i = 0; i < implementations.length; i++) { + const impl = implementations[i]; + if (typeof impl.filter !== "function" || + // eslint-disable-next-line unicorn/no-array-method-this-argument + impl.filter(name, info) !== false) { + matched.push(i); + } + } + return matched; + }; + /** @type {Map} */ + const matchedByName = new Map(); + const assetsForMinify = await Promise.all(Object.keys(assets).filter(name => { + const { + info + } = /** @type {Asset} */compilation.getAsset(name); + if ( + // Skip double minimize assets from child compilation + info.minimized || + // Skip minimizing for extracted comments assets + info.extractedComments) { + return false; + } + if (!compiler.webpack.ModuleFilenameHelpers.matchObject.bind(undefined, this.options)(name)) { + return false; + } + + // Compute the matching minimizers once and carry the result to the + // per-asset task via `matchedByName` so the regexes don't run again. + const matched = matchingMinimizers(name, info); + if (matched.length === 0) { + return false; + } + matchedByName.set(name, matched); + return true; + }).map(async name => { + const { + info, + source + } = /** @type {Asset} */ + compilation.getAsset(name); + const eTag = cache.getLazyHashedEtag(source); + const cacheItem = cache.getItemCache(name, eTag); + const output = await cacheItem.getPromise(); + if (!output) { + numberOfAssets += 1; + } + return { + name, + info, + inputSource: source, + output, + cacheItem, + matched: (/** @type {number[]} */matchedByName.get(name)) + }; + })); + if (assetsForMinify.length === 0) { + return; + } + + /** @type {undefined | (() => MinimizerWorker)} */ + let getWorker; + /** @type {undefined | MinimizerWorker} */ + let initializedWorker; + /** @type {undefined | number} */ + let numberOfWorkers; + const needCreateWorker = optimizeOptions.availableNumberOfCores > 0 && implementations.every(impl => typeof impl.supportsWorker === "undefined" || typeof impl.supportsWorker === "function" && impl.supportsWorker()); + if (needCreateWorker) { + // Do not create unnecessary workers when the number of files is less than the available cores, it saves memory + numberOfWorkers = Math.min(numberOfAssets, optimizeOptions.availableNumberOfCores); + getWorker = () => { + if (initializedWorker) { + return initializedWorker; + } + const { + Worker + } = require("jest-worker"); + initializedWorker = /** @type {MinimizerWorker} */ + + new Worker(require.resolve("./minify"), { + numWorkers: numberOfWorkers, + enableWorkerThreads: implementations.every(impl => typeof impl.supportsWorkerThreads === "undefined" || impl.supportsWorkerThreads() !== false) + }); + + // 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 { + SourceMapSource, + ConcatSource, + RawSource + } = compiler.webpack.sources; + + /** @typedef {{ extractedCommentsSource: import("webpack").sources.RawSource, commentsFilename: string }} ExtractedCommentsInfo */ + /** @type {Map} */ + const allExtractedComments = new Map(); + const scheduledTasks = []; + for (const asset of assetsForMinify) { + scheduledTasks.push(async () => { + const { + name, + inputSource, + info, + cacheItem, + matched + } = asset; + let { + output + } = asset; + if (!output) { + let input; + /** @type {RawSourceMap | undefined} */ + let inputSourceMap; + const { + source: sourceFromInputSource, + map + } = inputSource.sourceAndMap(); + input = sourceFromInputSource; + if (map) { + if (!TerserPlugin.isSourceMap(map)) { + compilation.warnings.push(new Error(`${name} contains invalid source map`)); + } else { + inputSourceMap = /** @type {RawSourceMap} */map; + } + } + if (Buffer.isBuffer(input)) { + input = input.toString(); + } + + // Dispatch to only the minimizers whose `filter` accepted this + // asset (computed once when collecting `assetsForMinify`). + // `minify.js` already normalizes a single implementation into a + // one-element array, so we always hand it the matching subset. + // Options are sliced as references — `minify.js` overlays + // `module`/`ecma` without mutating the caller's object. + const assetImplementation = /** @type {MinimizerImplementation} */ + matched.map(i => implementations[i]); + const sourceOptions = this.options.minimizer.options; + const assetMinimizerOptions = /** @type {MinimizerOptions} */ + + Array.isArray(sourceOptions) ? matched.map(i => sourceOptions[i] || {}) : sourceOptions; + + /** + * @type {InternalOptions} + */ + const options = { + name, + input, + inputSourceMap, + minimizer: { + implementation: assetImplementation, + options: assetMinimizerOptions + }, + extractComments: this.options.extractComments + }; + if (typeof info.javascriptModule !== "undefined") { + options.module = info.javascriptModule; + } else if (/\.mjs(\?.*)?$/i.test(name)) { + options.module = true; + } else if (/\.cjs(\?.*)?$/i.test(name)) { + options.module = false; + } + options.ecma = getEcmaVersion(compiler.options.output.environment); + try { + output = await (getWorker ? getWorker().transform(getSerializeJavascript()(options)) : minify(options)); + } catch (error) { + const hasSourceMap = inputSourceMap && TerserPlugin.isSourceMap(inputSourceMap); + compilation.errors.push(TerserPlugin.buildError(/** @type {Error | ErrorObject | string} */ + error, name, hasSourceMap ? new (getTraceMapping().TraceMap)(/** @type {RawSourceMap} */ + inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined)); + return; + } + if (typeof output.code === "undefined") { + compilation.errors.push(new Error(`${name} from Terser plugin\nMinimizer doesn't return result`)); + } + if (output.warnings && output.warnings.length > 0) { + output.warnings = output.warnings.map( + /** + * @param {Error | string} item a warning + * @returns {Error} built warning with extra info + */ + item => TerserPlugin.buildWarning(item, name)); + } + if (output.errors && output.errors.length > 0) { + const hasSourceMap = inputSourceMap && TerserPlugin.isSourceMap(inputSourceMap); + output.errors = output.errors.map( + /** + * @param {Error | string} item an error + * @returns {Error} built error with extra info + */ + item => TerserPlugin.buildError(item, name, hasSourceMap ? new (getTraceMapping().TraceMap)(/** @type {RawSourceMap} */ + inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined)); + } + let shebang; + + // Custom functions can return `undefined` or `null` when the + // minimizer only produced warnings, errors or extracted comments + if (typeof output.code !== "undefined" && output.code !== null) { + if (/** @type {ExtractCommentsObject} */ + this.options.extractComments.banner !== false && output.extractedComments && output.extractedComments.length > 0 && output.code.startsWith("#!")) { + const firstNewlinePosition = output.code.indexOf("\n"); + shebang = output.code.slice(0, Math.max(0, firstNewlinePosition)); + output.code = output.code.slice(Math.max(0, firstNewlinePosition + 1)); + } + if (output.map) { + output.source = new SourceMapSource(output.code, name, output.map, input, /** @type {RawSourceMap} */ + inputSourceMap, true); + } else { + output.source = new RawSource(output.code); + } + } + if (output.extractedComments && output.extractedComments.length > 0) { + const commentsFilename = /** @type {ExtractCommentsObject} */ + this.options.extractComments.filename || "[file].LICENSE.txt[query]"; + let query = ""; + let filename = name; + const querySplit = filename.indexOf("?"); + if (querySplit >= 0) { + query = filename.slice(querySplit); + filename = filename.slice(0, querySplit); + } + const lastSlashIndex = filename.lastIndexOf("/"); + const basename = lastSlashIndex === -1 ? filename : filename.slice(lastSlashIndex + 1); + const data = { + filename, + basename, + query + }; + output.commentsFilename = compilation.getPath(commentsFilename, data); + + // Banner only applies when we have a new source to prepend to + if (output.source && /** @type {ExtractCommentsObject} */ + this.options.extractComments.banner !== false) { + let banner = /** @type {ExtractCommentsObject} */ + this.options.extractComments.banner || `For license information please see ${path.relative(path.dirname(name), output.commentsFilename).replace(/\\/g, "/")}`; + if (typeof banner === "function") { + banner = banner(output.commentsFilename); + } + if (banner) { + output.source = new ConcatSource(shebang ? `${shebang}\n` : "", `/*! ${banner} */\n`, output.source); + } + } + const extractedCommentsString = output.extractedComments.sort().join("\n\n"); + output.extractedCommentsSource = new RawSource(`${extractedCommentsString}\n`); + } + await cacheItem.storePromise({ + source: output.source, + errors: output.errors, + warnings: output.warnings, + commentsFilename: output.commentsFilename, + extractedCommentsSource: output.extractedCommentsSource + }); + } + 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); + } + } + + // Emit extracted comments file even if the main asset was not + // rewritten (some minimizers only produce comments / warnings / errors) + if (output.extractedCommentsSource) { + allExtractedComments.set(name, { + extractedCommentsSource: output.extractedCommentsSource, + commentsFilename: (/** @type {string} */output.commentsFilename) + }); + } + if (!output.source) { + return; + } + + /** @type {AssetInfo} */ + const newInfo = { + minimized: true + }; + if (output.extractedCommentsSource) { + newInfo.related = { + license: (/** @type {string} */output.commentsFilename) + }; + } + compilation.updateAsset(name, output.source, newInfo); + }); + } + const limit = getWorker && numberOfAssets > 0 ? (/** @type {number} */numberOfWorkers) : scheduledTasks.length; + await throttleAll(limit, scheduledTasks); + if (initializedWorker) { + await initializedWorker.end(); + } + + /** @typedef {{ source: import("webpack").sources.Source, commentsFilename: string, from: string }} ExtractedCommentsInfoWithFrom */ + await [...allExtractedComments].sort().reduce( + /** + * @param {Promise} previousPromise previous result + * @param {[string, ExtractedCommentsInfo]} extractedComments extracted comments + * @returns {Promise} extract comments with info + */ + async (previousPromise, [from, value]) => { + const previous = /** @type {ExtractedCommentsInfoWithFrom | undefined} * */ + await previousPromise; + const { + commentsFilename, + extractedCommentsSource + } = value; + if (previous && previous.commentsFilename === commentsFilename) { + const { + from: previousFrom, + source: prevSource + } = previous; + const mergedName = `${previousFrom}|${from}`; + const name = `${commentsFilename}|${mergedName}`; + const eTag = [prevSource, extractedCommentsSource].map(item => cache.getLazyHashedEtag(item)).reduce((previousValue, currentValue) => cache.mergeEtags(previousValue, currentValue)); + let source = await cache.getPromise(name, eTag); + if (!source) { + source = new ConcatSource([...new Set([... /** @type {string} */prevSource.source().split("\n\n"), ... /** @type {string} */extractedCommentsSource.source().split("\n\n")])].join("\n\n")); + await cache.storePromise(name, eTag, source); + } + compilation.updateAsset(commentsFilename, source); + return { + source, + commentsFilename, + from: mergedName + }; + } + const existingAsset = compilation.getAsset(commentsFilename); + if (existingAsset) { + return { + source: existingAsset.source, + commentsFilename, + from: commentsFilename + }; + } + compilation.emitAsset(commentsFilename, extractedCommentsSource, { + extractedComments: true + }); + return { + source: extractedCommentsSource, + commentsFilename, + from + }; + }, /** @type {Promise} */Promise.resolve()); + } + + /** + * @param {Compiler} compiler compiler + * @returns {void} + */ + apply(compiler) { + const pluginName = this.constructor.name; + const availableNumberOfCores = TerserPlugin.getAvailableNumberOfCores(this.options.parallel); + compiler.hooks.compilation.tap(pluginName, compilation => { + const hooks = compiler.webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation); + /** + * @param {BasicMinimizerImplementation & MinimizeFunctionHelpers} impl implementation + * @returns {string} minimizer version or "0.0.0" + */ + const getVersion = impl => typeof impl.getMinimizerVersion !== "undefined" ? impl.getMinimizerVersion() || "0.0.0" : "0.0.0"; + const data = getSerializeJavascript()({ + minimizer: Array.isArray(this.options.minimizer.implementation) ? this.options.minimizer.implementation.map(getVersion) : getVersion(/** @type {BasicMinimizerImplementation & MinimizeFunctionHelpers} */ + this.options.minimizer.implementation), + options: this.options.minimizer.options + }); + hooks.chunkHash.tap(pluginName, (chunk, hash) => { + hash.update("TerserPlugin"); + hash.update(data); + }); + compilation.hooks.processAssets.tapPromise({ + name: pluginName, + stage: compiler.webpack.Compilation.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("minimizer-webpack-plugin", (minimized, { + green, + formatFlag + }) => minimized ? /** @type {(text: string) => string} */green(/** @type {(flag: string) => string} */formatFlag("minimized")) : ""); + }); + }); + } +} +TerserPlugin.terserMinify = terserMinify; +TerserPlugin.uglifyJsMinify = uglifyJsMinify; +TerserPlugin.swcMinify = swcMinify; +TerserPlugin.esbuildMinify = esbuildMinify; +TerserPlugin.jsonMinify = jsonMinify; +TerserPlugin.htmlMinifierTerser = htmlMinifierTerser; +TerserPlugin.swcMinifyHtml = swcMinifyHtml; +TerserPlugin.swcMinifyHtmlFragment = swcMinifyHtmlFragment; +TerserPlugin.minifyHtmlNode = minifyHtmlNode; +TerserPlugin.cssnanoMinify = cssnanoMinify; +TerserPlugin.cssoMinify = cssoMinify; +TerserPlugin.cleanCssMinify = cleanCssMinify; +TerserPlugin.esbuildMinifyCss = esbuildMinifyCss; +TerserPlugin.lightningCssMinify = lightningCssMinify; +TerserPlugin.swcMinifyCss = swcMinifyCss; +module.exports = TerserPlugin; Index: frontend/node_modules/terser-webpack-plugin/dist/minify.js =================================================================== --- frontend/node_modules/terser-webpack-plugin/dist/minify.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/terser-webpack-plugin/dist/minify.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,335 @@ +"use strict"; + +/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */ +/** @typedef {import("./index.js").CustomOptions} CustomOptions */ +/** @typedef {import("./index.js").RawSourceMap} RawSourceMap */ +/** + * @template T + * @typedef {import("./index.js").MinimizerOptions} MinimizerOptions + */ + +const VLQ_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +/** + * Encode a single integer as Base64 VLQ as used by the source-map spec. + * @param {number} value integer to encode + * @returns {string} encoded VLQ characters + */ +/* eslint-disable prefer-destructuring, no-eq-null, eqeqeq */ +/** + * @param {number} value integer to encode + * @returns {string} encoded VLQ characters + */ +function encodeVlq(value) { + let vlq = value < 0 ? -value << 1 | 1 : value << 1; + let out = ""; + do { + let digit = vlq & 0b11111; + vlq >>>= 5; + if (vlq > 0) { + digit |= 0b100000; + } + out += VLQ_BASE64[digit]; + } while (vlq > 0); + return out; +} + +/** + * Encode decoded source-map mappings (per-line arrays of segments) back into + * the spec's `mappings` string. + * @param {number[][][]} decoded mappings as nested arrays of segments + * @returns {string} encoded `mappings` field + */ +function encodeMappings(decoded) { + let result = ""; + let prevSourceIdx = 0; + let prevOriginalLine = 0; + let prevOriginalColumn = 0; + let prevNameIdx = 0; + for (let line = 0; line < decoded.length; line++) { + if (line > 0) { + result += ";"; + } + let prevGeneratedColumn = 0; + const segments = decoded[line]; + for (let i = 0; i < segments.length; i++) { + if (i > 0) { + result += ","; + } + const seg = segments[i]; + result += encodeVlq(seg[0] - prevGeneratedColumn); + prevGeneratedColumn = seg[0]; + if (seg.length >= 4) { + result += encodeVlq(seg[1] - prevSourceIdx); + prevSourceIdx = seg[1]; + result += encodeVlq(seg[2] - prevOriginalLine); + prevOriginalLine = seg[2]; + result += encodeVlq(seg[3] - prevOriginalColumn); + prevOriginalColumn = seg[3]; + if (seg.length >= 5) { + result += encodeVlq(seg[4] - prevNameIdx); + prevNameIdx = seg[4]; + } + } + } + } + return result; +} + +/** + * Compose a freshly-produced source map with the input source map fed to + * the minimizer. `currentMap` represents `name → step-output` and + * `prevMap` represents `original → name`; the result represents + * `original → step-output`. + * + * TODO: replace with a webpack-sources helper once one is exposed — + * `SourceMapSource` already composes one level via `innerSourceMap`, + * see https://github.com/webpack/webpack-sources for the proposal to + * expose it as a public `composeSourceMaps` (or n-step `SourceMapSource`). + * @param {RawSourceMap | undefined} currentMap map produced by the minimizer + * @param {RawSourceMap | undefined} prevMap input source map fed to the minimizer + * @param {string} name name of the asset that the current map points to + * @returns {RawSourceMap | undefined} composed map + */ +function composeSourceMaps(currentMap, prevMap, name) { + if (!currentMap || !prevMap) { + return currentMap; + } + + // Custom minimizers may return the map as a JSON string (e.g. terser's + // default output). `TraceMap` accepts both shapes, but we still hand + // back the original `currentMap` (string preserved) when the previous + // map can't be combined. + const { + TraceMap, + decodedMappings, + originalPositionFor, + sourceContentFor + } = require("@jridgewell/trace-mapping"); + const current = new TraceMap(/** @type {import("@jridgewell/trace-mapping").SourceMapInput} */ + /** @type {unknown} */currentMap); + const previous = new TraceMap(/** @type {import("@jridgewell/trace-mapping").SourceMapInput} */ + /** @type {unknown} */prevMap); + + /** @type {string[]} */ + const sources = []; + /** @type {(string | null)[]} */ + const sourcesContent = []; + /** @type {string[]} */ + const names = []; + /** @type {Map} */ + const sourceIdx = new Map(); + /** @type {Map} */ + const nameIdx = new Map(); + + /** + * @param {string | null | undefined} source source identifier + * @param {string | undefined} content source content (when available) + * @returns {number} index assigned in the composed map + */ + const getSourceIdx = (source, content) => { + const key = source || ""; + let idx = sourceIdx.get(key); + if (typeof idx === "undefined") { + idx = sources.length; + sources.push(key); + sourcesContent.push(typeof content === "string" ? content : null); + sourceIdx.set(key, idx); + } else if (typeof content === "string" && sourcesContent[idx] === null) { + sourcesContent[idx] = content; + } + return idx; + }; + + /** + * @param {string | null | undefined} value name + * @returns {number} index assigned in the composed map + */ + const getNameIdx = value => { + if (typeof value !== "string") { + return -1; + } + let idx = nameIdx.get(value); + if (typeof idx === "undefined") { + idx = names.length; + names.push(value); + nameIdx.set(value, idx); + } + return idx; + }; + const decoded = decodedMappings(current); + const currentSources = current.sources.map( + /** + * @param {string | null} source source from current map + * @returns {string} normalized source string + */ + source => source || ""); + const currentNames = current.names; + + /** @type {number[][][]} */ + const composed = []; + for (let line = 0; line < decoded.length; line++) { + /** @type {number[][]} */ + const newSegments = []; + for (const rawSeg of decoded[line]) { + const seg = /** @type {number[]} */rawSeg; + + // Single-element segment is just a generated column with no source info + if (seg.length < 4) { + newSegments.push([seg[0]]); + continue; + } + const sourceName = currentSources[seg[1]]; + const origLine = /** @type {number} */seg[2]; + const origCol = /** @type {number} */seg[3]; + const segName = seg.length >= 5 ? currentNames[seg[4]] : (/** @type {string | null} */null); + + // When the segment points back at our intermediate `name`, look up + // the original position in the previous map and emit a mapping that + // points all the way back. Otherwise keep the segment as-is. + if (sourceName === name) { + const orig = originalPositionFor(previous, { + line: origLine + 1, + column: origCol + }); + if (typeof orig.source !== "string" || orig.line == null || orig.column == null) { + continue; + } + const content = sourceContentFor(previous, orig.source) || undefined; + const newSrcIdx = getSourceIdx(orig.source, content); + const finalName = typeof orig.name === "string" && orig.name ? orig.name : segName; + if (typeof finalName === "string") { + newSegments.push([seg[0], newSrcIdx, orig.line - 1, orig.column, getNameIdx(finalName)]); + } else { + newSegments.push([seg[0], newSrcIdx, orig.line - 1, orig.column]); + } + } else { + const content = sourceContentFor(current, sourceName) || undefined; + const newSrcIdx = getSourceIdx(sourceName, content); + if (typeof segName === "string") { + newSegments.push([seg[0], newSrcIdx, origLine, origCol, getNameIdx(segName)]); + } else { + newSegments.push([seg[0], newSrcIdx, origLine, origCol]); + } + } + } + composed.push(newSegments); + } + const result = /** @type {RawSourceMap} */ + + /** @type {unknown} */{ + version: 3, + sources, + names, + mappings: encodeMappings(composed) + }; + if (currentMap.file) { + result.file = currentMap.file; + } + if (sourcesContent.some(value => typeof value === "string")) { + result.sourcesContent = /** @type {string[]} */ + /** @type {unknown} */sourcesContent; + } + return result; +} +/* eslint-enable prefer-destructuring, no-eq-null, eqeqeq */ + +/** + * @template T + * @param {import("./index.js").InternalOptions} options options + * @returns {Promise} minified result + */ +async function minify(options) { + const { + name, + input, + inputSourceMap, + extractComments, + module, + ecma + } = options; + const { + implementation, + options: minimizerOptions + } = options.minimizer; + const implementations = Array.isArray(implementation) ? implementation : [implementation]; + + /** @type {string | undefined} */ + let lastCode; + /** @type {RawSourceMap | undefined} */ + let lastMap; + /** @type {(Error | string)[]} */ + const warnings = []; + /** @type {(Error | string)[]} */ + const errors = []; + /** @type {string[]} */ + const extractedComments = []; + for (let i = 0; i < implementations.length; i++) { + const currentImplementation = /** @type {import("./index.js").BasicMinimizerImplementation & import("./index.js").MinimizeFunctionHelpers} */ + implementations[i]; + const baseOptions = /** @type {import("./index.js").MinimizerOptions & { module?: boolean, ecma?: number | string }} */ + + Array.isArray(minimizerOptions) ? minimizerOptions[i] || {} : minimizerOptions || {}; + const currentInput = typeof lastCode === "string" ? lastCode : input; + const currentMap = typeof lastCode === "string" ? lastMap : inputSourceMap; + + // Overlay `module` and `ecma` without mutating the caller's options so + // a single options object can be reused safely across assets. + const currentOptions = /** @type {import("./index.js").MinimizerOptions} */ + { + ...baseOptions, + module: baseOptions.module || module, + ecma: baseOptions.ecma || ecma + }; + const result = await currentImplementation({ + [name]: currentInput + }, currentMap, currentOptions, extractComments); + if (result.warnings && result.warnings.length > 0) { + warnings.push(...result.warnings); + } + if (result.errors && result.errors.length > 0) { + errors.push(...result.errors); + } + if (result.extractedComments && result.extractedComments.length > 0) { + extractedComments.push(...result.extractedComments); + } + if (typeof result.code === "string") { + lastCode = result.code; + // The minimizer's output map is `name → step-output`. Chain it with + // the previous accumulated map so that across an array of minimizers + // the final map points back to the original sources. + lastMap = composeSourceMaps(result.map, currentMap, name); + } + } + return { + code: lastCode, + map: lastMap, + warnings, + errors, + extractedComments + }; +} + +/** + * @param {string} options options + * @returns {Promise} minified result + */ +async function transform(options) { + // 'use strict' => this === undefined (Clean Scope) + // Safer for possible security issues, albeit not critical at all here + + const evaluatedOptions = + /** + * @template T + * @type {import("./index.js").InternalOptions} + */ + + // eslint-disable-next-line no-new-func + new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`) // eslint-disable-next-line n/exports-style + (exports, require, module, __filename, __dirname); + return minify(evaluatedOptions); +} +module.exports = { + minify, + transform +}; Index: frontend/node_modules/terser-webpack-plugin/dist/options.json =================================================================== --- frontend/node_modules/terser-webpack-plugin/dist/options.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/terser-webpack-plugin/dist/options.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,205 @@ +{ + "definitions": { + "Rule": { + "description": "Filtering rule as regex or string.", + "anyOf": [ + { + "instanceof": "RegExp", + "tsType": "RegExp" + }, + { + "type": "string", + "minLength": 1 + } + ] + }, + "Rules": { + "description": "Filtering rules.", + "anyOf": [ + { + "type": "array", + "items": { + "description": "A rule condition.", + "oneOf": [ + { + "$ref": "#/definitions/Rule" + } + ] + } + }, + { + "$ref": "#/definitions/Rule" + } + ] + } + }, + "title": "MinimizerPluginOptions", + "type": "object", + "additionalProperties": false, + "properties": { + "test": { + "description": "Include all modules that pass test assertion.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#test", + "oneOf": [ + { + "$ref": "#/definitions/Rules" + } + ] + }, + "include": { + "description": "Include all modules matching any of these conditions.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#include", + "oneOf": [ + { + "$ref": "#/definitions/Rules" + } + ] + }, + "exclude": { + "description": "Exclude all modules matching any of these conditions.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#exclude", + "oneOf": [ + { + "$ref": "#/definitions/Rules" + } + ] + }, + "minimizerOptions": { + "description": "Options for `terser` (by default) or custom `minify` function.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#minimizeroptions", + "anyOf": [ + { + "additionalProperties": true, + "type": "object" + }, + { + "type": "array", + "minItems": 1, + "items": { + "additionalProperties": true, + "type": "object" + } + } + ] + }, + "terserOptions": { + "description": "Deprecated alias for `minimizerOptions`. Options for `terser` (by default) or custom `minify` function.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#terseroptions", + "anyOf": [ + { + "additionalProperties": true, + "type": "object" + }, + { + "type": "array", + "minItems": 1, + "items": { + "additionalProperties": true, + "type": "object" + } + } + ] + }, + "extractComments": { + "description": "Whether comments shall be extracted to a separate file.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#extractcomments", + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "string", + "minLength": 1 + }, + { + "instanceof": "RegExp" + }, + { + "instanceof": "Function" + }, + { + "additionalProperties": false, + "properties": { + "condition": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "string", + "minLength": 1 + }, + { + "instanceof": "RegExp" + }, + { + "instanceof": "Function" + } + ], + "description": "Condition what comments you need extract.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#condition" + }, + "filename": { + "anyOf": [ + { + "type": "string", + "minLength": 1 + }, + { + "instanceof": "Function" + } + ], + "description": "The file where the extracted comments will be stored. Default is to append the suffix .LICENSE.txt to the original filename.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#filename" + }, + "banner": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "string", + "minLength": 1 + }, + { + "instanceof": "Function" + } + ], + "description": "The banner text that points to the extracted file and will be added on top of the original file", + "link": "https://github.com/webpack/minimizer-webpack-plugin#banner" + } + }, + "type": "object" + } + ] + }, + "parallel": { + "description": "Use multi-process parallel running to improve the build speed.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#parallel", + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "integer" + } + ] + }, + "minify": { + "description": "Allows you to override default minify function.", + "link": "https://github.com/webpack/minimizer-webpack-plugin#number", + "anyOf": [ + { + "instanceof": "Function" + }, + { + "type": "array", + "minItems": 1, + "items": { + "instanceof": "Function" + } + } + ] + } + } +} Index: frontend/node_modules/terser-webpack-plugin/dist/serialize-javascript.js =================================================================== --- frontend/node_modules/terser-webpack-plugin/dist/serialize-javascript.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/terser-webpack-plugin/dist/serialize-javascript.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,276 @@ +"use strict"; + +// @ts-nocheck + +var g = typeof globalThis !== 'undefined' ? globalThis : global; +var crypto = g.crypto || {}; +if (typeof crypto.getRandomValues !== 'function') { + var nodeCrypto = require('crypto'); + crypto.getRandomValues = function (typedArray) { + var bytes = nodeCrypto.randomBytes(typedArray.byteLength); + new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength).set(bytes); + return typedArray; + }; +} +/* +Copyright (c) 2014, Yahoo! Inc. All rights reserved. +Copyrights licensed under the New BSD License. +See the accompanying LICENSE file for terms. +*/ + +'use strict'; + +// Generate an internal UID to make the regexp pattern harder to guess. +var UID_LENGTH = 16; +var UID = generateUID(); +var PLACE_HOLDER_REGEXP = new RegExp('(\\\\)?"@__(F|R|D|M|S|A|U|I|B|L)-' + UID + '-(\\d+)__@"', 'g'); +var IS_NATIVE_CODE_REGEXP = /\{\s*\[native code\]\s*\}/g; +var IS_PURE_FUNCTION = /function.*?\(/; +var IS_ARROW_FUNCTION = /.*?=>.*?/; +var UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g; +// Regex to match and variations (case-insensitive) for XSS protection +// Matches +var SCRIPT_CLOSE_REGEXP = /<\/script[^>]*>/gi; +var RESERVED_SYMBOLS = ['*', 'async']; + +// Mapping of unsafe HTML and invalid JavaScript line terminator chars to their +// Unicode char counterparts which are safe to use in JavaScript strings. +var ESCAPED_CHARS = { + '<': '\\u003C', + '>': '\\u003E', + '/': '\\u002F', + '\u2028': '\\u2028', + '\u2029': '\\u2029' +}; +function escapeUnsafeChars(unsafeChar) { + return ESCAPED_CHARS[unsafeChar]; +} + +// Escape function body for XSS protection while preserving arrow function syntax +function escapeFunctionBody(str) { + // Escape sequences and variations (case-insensitive) - the main XSS risk + // Matches + // This must be done first before other replacements + str = str.replace(SCRIPT_CLOSE_REGEXP, function (match) { + // Escape all <, /, and > characters in the closing script tag + return match.replace(//g, '\\u003E'); + }); + // Escape line terminators (these are always unsafe) + str = str.replace(/\u2028/g, '\\u2028'); + str = str.replace(/\u2029/g, '\\u2029'); + return str; +} +function generateUID() { + var bytes = crypto.getRandomValues(new Uint8Array(UID_LENGTH)); + var result = ''; + for (var i = 0; i < UID_LENGTH; ++i) { + result += bytes[i].toString(16); + } + return result; +} +function deleteFunctions(obj) { + var functionKeys = []; + for (var key in obj) { + if (typeof obj[key] === "function") { + functionKeys.push(key); + } + } + for (var i = 0; i < functionKeys.length; i++) { + delete obj[functionKeys[i]]; + } +} +module.exports = function serialize(obj, options) { + options || (options = {}); + + // Backwards-compatibility for `space` as the second argument. + if (typeof options === 'number' || typeof options === 'string') { + options = { + space: options + }; + } + var functions = []; + var regexps = []; + var dates = []; + var maps = []; + var sets = []; + var arrays = []; + var undefs = []; + var infinities = []; + var bigInts = []; + var urls = []; + + // Returns placeholders for functions and regexps (identified by index) + // which are later replaced by their string representation. + function replacer(key, value) { + // For nested function + if (options.ignoreFunction) { + deleteFunctions(value); + } + if (!value && value !== undefined && value !== BigInt(0)) { + return value; + } + + // If the value is an object w/ a toJSON method, toJSON is called before + // the replacer runs, so we use this[key] to get the non-toJSONed value. + var origValue = this[key]; + var type = typeof origValue; + if (type === 'object') { + if (origValue instanceof RegExp) { + return '@__R-' + UID + '-' + (regexps.push(origValue) - 1) + '__@'; + } + if (origValue instanceof Date) { + return '@__D-' + UID + '-' + (dates.push(origValue) - 1) + '__@'; + } + if (origValue instanceof Map) { + return '@__M-' + UID + '-' + (maps.push(origValue) - 1) + '__@'; + } + if (origValue instanceof Set) { + return '@__S-' + UID + '-' + (sets.push(origValue) - 1) + '__@'; + } + if (Array.isArray(origValue)) { + var isSparse = Object.keys(origValue).length !== origValue.length; + if (isSparse) { + return '@__A-' + UID + '-' + (arrays.push(origValue) - 1) + '__@'; + } + } + if (origValue instanceof URL) { + return '@__L-' + UID + '-' + (urls.push(origValue) - 1) + '__@'; + } + } + if (type === 'function') { + return '@__F-' + UID + '-' + (functions.push(origValue) - 1) + '__@'; + } + if (type === 'undefined') { + return '@__U-' + UID + '-' + (undefs.push(origValue) - 1) + '__@'; + } + if (type === 'number' && !isNaN(origValue) && !isFinite(origValue)) { + return '@__I-' + UID + '-' + (infinities.push(origValue) - 1) + '__@'; + } + if (type === 'bigint') { + return '@__B-' + UID + '-' + (bigInts.push(origValue) - 1) + '__@'; + } + return value; + } + function serializeFunc(fn, options) { + var serializedFn = fn.toString(); + if (IS_NATIVE_CODE_REGEXP.test(serializedFn)) { + throw new TypeError('Serializing native function: ' + fn.name); + } + + // Escape unsafe HTML characters in function body for XSS protection + // This must preserve arrow function syntax (=>) while escaping + if (options && options.unsafe !== true) { + serializedFn = escapeFunctionBody(serializedFn); + } + + // pure functions, example: {key: function() {}} + if (IS_PURE_FUNCTION.test(serializedFn)) { + return serializedFn; + } + + // arrow functions, example: arg1 => arg1+5 + if (IS_ARROW_FUNCTION.test(serializedFn)) { + return serializedFn; + } + var argsStartsAt = serializedFn.indexOf('('); + var def = serializedFn.substr(0, argsStartsAt).trim().split(' ').filter(function (val) { + return val.length > 0; + }); + var nonReservedSymbols = def.filter(function (val) { + return RESERVED_SYMBOLS.indexOf(val) === -1; + }); + + // enhanced literal objects, example: {key() {}} + if (nonReservedSymbols.length > 0) { + return (def.indexOf('async') > -1 ? 'async ' : '') + 'function' + (def.join('').indexOf('*') > -1 ? '*' : '') + serializedFn.substr(argsStartsAt); + } + + // arrow functions + return serializedFn; + } + + // Check if the parameter is function + if (options.ignoreFunction && typeof obj === "function") { + obj = undefined; + } + // Protects against `JSON.stringify()` returning `undefined`, by serializing + // to the literal string: "undefined". + if (obj === undefined) { + return String(obj); + } + var str; + + // Creates a JSON string representation of the value. + // NOTE: Node 0.12 goes into slow mode with extra JSON.stringify() args. + if (options.isJSON && !options.space) { + str = JSON.stringify(obj); + } else { + str = JSON.stringify(obj, options.isJSON ? null : replacer, options.space); + } + + // Protects against `JSON.stringify()` returning `undefined`, by serializing + // to the literal string: "undefined". + if (typeof str !== 'string') { + return String(str); + } + + // Replace unsafe HTML and invalid JavaScript line terminator chars with + // their safe Unicode char counterpart. This _must_ happen before the + // regexps and functions are serialized and added back to the string. + if (options.unsafe !== true) { + str = str.replace(UNSAFE_CHARS_REGEXP, escapeUnsafeChars); + } + if (functions.length === 0 && regexps.length === 0 && dates.length === 0 && maps.length === 0 && sets.length === 0 && arrays.length === 0 && undefs.length === 0 && infinities.length === 0 && bigInts.length === 0 && urls.length === 0) { + return str; + } + + // Replaces all occurrences of function, regexp, date, map and set placeholders in the + // JSON string with their string representations. If the original value can + // not be found, then `undefined` is used. + return str.replace(PLACE_HOLDER_REGEXP, function (match, backSlash, type, valueIndex) { + // The placeholder may not be preceded by a backslash. This is to prevent + // replacing things like `"a\"@__R--0__@"` and thus outputting + // invalid JS. + if (backSlash) { + return match; + } + if (type === 'D') { + // Validate ISO string format to prevent code injection via spoofed toISOString() + var isoStr = String(dates[valueIndex].toISOString()); + if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(isoStr)) { + throw new TypeError('Invalid Date ISO string'); + } + return "new Date(\"" + isoStr + "\")"; + } + if (type === 'R') { + // Sanitize flags to prevent code injection (only allow valid RegExp flag characters) + var flags = String(regexps[valueIndex].flags).replace(/[^gimsuydv]/g, ''); + return "new RegExp(" + serialize(regexps[valueIndex].source) + ", \"" + flags + "\")"; + } + if (type === 'M') { + return "new Map(" + serialize(Array.from(maps[valueIndex].entries()), options) + ")"; + } + if (type === 'S') { + return "new Set(" + serialize(Array.from(sets[valueIndex].values()), options) + ")"; + } + if (type === 'A') { + return "Array.prototype.slice.call(" + serialize(Object.assign({ + length: arrays[valueIndex].length + }, arrays[valueIndex]), options) + ")"; + } + if (type === 'U') { + return 'undefined'; + } + if (type === 'I') { + return infinities[valueIndex]; + } + if (type === 'B') { + return "BigInt(\"" + bigInts[valueIndex] + "\")"; + } + if (type === 'L') { + return "new URL(" + serialize(urls[valueIndex].toString(), options) + ")"; + } + var fn = functions[valueIndex]; + return serializeFunc(fn, options); + }); +}; Index: frontend/node_modules/terser-webpack-plugin/dist/utils.js =================================================================== --- frontend/node_modules/terser-webpack-plugin/dist/utils.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/terser-webpack-plugin/dist/utils.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1597 @@ +"use strict"; + +/** @typedef {import("./index.js").ExtractCommentsOptions} ExtractCommentsOptions */ +/** @typedef {import("./index.js").ExtractCommentsFunction} ExtractCommentsFunction */ +/** @typedef {import("./index.js").ExtractCommentsCondition} ExtractCommentsCondition */ +/** @typedef {import("./index.js").Input} Input */ +/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */ +/** @typedef {import("./index.js").CustomOptions} CustomOptions */ +/** @typedef {import("./index.js").RawSourceMap} RawSourceMap */ +/** @typedef {import("./index.js").EXPECTED_OBJECT} EXPECTED_OBJECT */ + +/** + * @typedef {string[]} ExtractedComments + */ + +const JS_FILE_RE = /\.[cm]?js(\?.*)?$/i; +const JSON_FILE_RE = /\.json(\?.*)?$/i; +const HTML_FILE_RE = /\.html?(\?.*)?$/i; +const CSS_FILE_RE = /\.css(\?.*)?$/i; + +/** + * Map a webpack `output.environment` configuration to the highest + * ECMAScript version that the target is known to support. Returns `5` + * when no ES2015+ features are flagged. + * @param {NonNullable["environment"]>} environment environment + * @returns {number} ecma version (5, 2015, 2017 or 2020) + */ +function getEcmaVersion(environment) { + // ES2020 (11th edition) + if (environment.bigIntLiteral || environment.dynamicImport || environment.dynamicImportInWorker || environment.globalThis || environment.optionalChaining) { + return 2020; + } + + // ES2017 (8th edition) + if (environment.asyncFunction) { + return 2017; + } + + // ES2015 (6th edition) + if (environment.arrowFunction || environment.const || environment.destructuring || environment.forOf || environment.methodShorthand || environment.module || environment.templateLiteral) { + return 2015; + } + return 5; +} +const notSettled = Symbol("not-settled"); + +/** + * @template T + * @typedef {() => Promise} Task + */ + +/** + * Run tasks with limited concurrency. + * @template T + * @param {number} limit Limit of tasks that run at once. + * @param {Task[]} tasks List of tasks to run. + * @returns {Promise} A promise that fulfills to an array of the results + */ +function throttleAll(limit, tasks) { + return new Promise((resolve, reject) => { + const result = Array.from({ + length: 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; + + /** + * @param {T} resultValue Result value + */ + const onFulfilled = resultValue => { + result[index] = resultValue; + next(); + }; + task().then(onFulfilled, reject); + }; + for (let i = 0; i < limit; i++) { + next(); + } + }); +} + +/* istanbul ignore next */ +/** + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @param {ExtractCommentsOptions=} extractComments extract comments option + * @returns {Promise} minimized result + */ +async function terserMinify(input, sourceMap, minimizerOptions, extractComments) { + /** + * @param {unknown} value value + * @returns {value is EXPECTED_OBJECT} true when value is object or function + */ + const isObject = value => { + const type = typeof value; + + // eslint-disable-next-line no-eq-null, eqeqeq + return value != null && (type === "object" || type === "function"); + }; + + /** + * @param {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} terserOptions terser options + * @param {ExtractedComments} extractedComments extracted comments + * @returns {ExtractCommentsFunction} function to extract comments + */ + const buildComments = (terserOptions, extractedComments) => { + /** @type {{ [index: string]: ExtractCommentsCondition }} */ + const condition = {}; + let comments; + if (terserOptions.format) { + ({ + comments + } = terserOptions.format); + } else if (terserOptions.output) { + ({ + comments + } = terserOptions.output); + } + condition.preserve = typeof comments !== "undefined" ? comments : false; + if (typeof extractComments === "boolean" && extractComments) { + condition.extract = "some"; + } else if (typeof extractComments === "string" || extractComments instanceof RegExp) { + condition.extract = extractComments; + } else if (typeof extractComments === "function") { + condition.extract = extractComments; + } else if (extractComments && isObject(extractComments)) { + condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some"; + } else { + // No extract + // Preserve using "commentsOpts" or "some" + condition.preserve = typeof comments !== "undefined" ? comments : "some"; + condition.extract = false; + } + + // Ensure that both conditions are functions + for (const key of ["preserve", "extract"]) { + /** @type {undefined | string} */ + let regexStr; + /** @type {undefined | RegExp} */ + let regex; + switch (typeof condition[key]) { + case "boolean": + condition[key] = condition[key] ? () => true : () => false; + break; + case "function": + break; + case "string": + if (condition[key] === "all") { + condition[key] = () => true; + break; + } + if (condition[key] === "some") { + condition[key] = /** @type {ExtractCommentsFunction} */ + (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value); + break; + } + regexStr = /** @type {string} */condition[key]; + condition[key] = /** @type {ExtractCommentsFunction} */ + (astNode, comment) => new RegExp(/** @type {string} */regexStr).test(comment.value); + break; + default: + regex = /** @type {RegExp} */condition[key]; + condition[key] = /** @type {ExtractCommentsFunction} */ + (astNode, comment) => /** @type {RegExp} */regex.test(comment.value); + } + } + + // Redefine the comments function to extract and preserve + // comments according to the two conditions + return (astNode, comment) => { + if (/** @type {{ extract: ExtractCommentsFunction }} */ + condition.extract(astNode, comment)) { + const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`; + + // Don't include duplicate comments + if (!extractedComments.includes(commentText)) { + extractedComments.push(commentText); + } + } + return /** @type {{ preserve: ExtractCommentsFunction }} */condition.preserve(astNode, comment); + }; + }; + + /** + * @param {import("terser").MinifyOptions=} terserOptions terser options + * @returns {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & { compress: import("terser").CompressOptions } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} built terser options + */ + const buildTerserOptions = (terserOptions = {}) => ( + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + { + ...terserOptions, + compress: typeof terserOptions.compress === "boolean" ? terserOptions.compress ? {} : false : { + ...terserOptions.compress + }, + // ecma: terserOptions.ecma, + // ie8: terserOptions.ie8, + // keep_classnames: terserOptions.keep_classnames, + // keep_fnames: terserOptions.keep_fnames, + mangle: + // eslint-disable-next-line no-eq-null, eqeqeq + terserOptions.mangle == null ? true : typeof terserOptions.mangle === "boolean" ? terserOptions.mangle : { + ...terserOptions.mangle + }, + // module: terserOptions.module, + // nameCache: { ...terserOptions.toplevel }, + // the `output` option is deprecated + ...(terserOptions.format ? { + format: { + beautify: false, + ...terserOptions.format + } + } : { + output: { + beautify: false, + ...terserOptions.output + } + }), + parse: { + ...terserOptions.parse + }, + // safari10: terserOptions.safari10, + // Ignoring sourceMap from options + sourceMap: undefined + // toplevel: terserOptions.toplevel + }); + let minify; + try { + ({ + minify + } = require("terser")); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + + // Copy `terser` options + const terserOptions = buildTerserOptions(minimizerOptions); + + // Let terser generate a SourceMap. The dispatcher in `minify.js` + // chains the previous step's map onto this one. + if (sourceMap) { + terserOptions.sourceMap = { + asObject: true + }; + } + + /** @type {ExtractedComments} */ + const extractedComments = []; + if (terserOptions.output) { + terserOptions.output.comments = buildComments(terserOptions, extractedComments); + } else if (terserOptions.format) { + terserOptions.format.comments = buildComments(terserOptions, extractedComments); + } + if (terserOptions.compress) { + // More optimizations + if (typeof terserOptions.compress.ecma === "undefined") { + terserOptions.compress.ecma = terserOptions.ecma; + } + + // https://github.com/webpack/webpack/issues/16135 + if (terserOptions.ecma === 5 && typeof terserOptions.compress.arrows === "undefined") { + terserOptions.compress.arrows = false; + } + } + const [[filename, code]] = Object.entries(input); + const result = await minify({ + [filename]: code + }, terserOptions); + return { + code: (/** @type {string} * */result.code), + map: result.map ? (/** @type {RawSourceMap} * */result.map) : undefined, + extractedComments + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +terserMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("terser/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker thread is supported, false otherwise + */ +terserMinify.supportsWorkerThreads = () => true; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a JavaScript file + */ +terserMinify.filter = name => JS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @param {ExtractCommentsOptions=} extractComments extract comments option + * @returns {Promise} minimized result + */ +async function uglifyJsMinify(input, sourceMap, minimizerOptions, extractComments) { + /** + * @param {unknown} value value + * @returns {boolean} true when value is object or function + */ + const isObject = value => { + const type = typeof value; + + // eslint-disable-next-line no-eq-null, eqeqeq + return value != null && (type === "object" || type === "function"); + }; + + /** + * @param {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglifyJsOptions uglify-js options + * @param {ExtractedComments} extractedComments extracted comments + * @returns {ExtractCommentsFunction} extract comments function + */ + const buildComments = (uglifyJsOptions, extractedComments) => { + /** @type {{ [index: string]: ExtractCommentsCondition }} */ + const condition = {}; + const { + comments + } = uglifyJsOptions.output; + condition.preserve = typeof comments !== "undefined" ? comments : false; + if (typeof extractComments === "boolean" && extractComments) { + condition.extract = "some"; + } else if (typeof extractComments === "string" || extractComments instanceof RegExp) { + condition.extract = extractComments; + } else if (typeof extractComments === "function") { + condition.extract = extractComments; + } else if (extractComments && isObject(extractComments)) { + condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some"; + } else { + // No extract + // Preserve using "commentsOpts" or "some" + condition.preserve = typeof comments !== "undefined" ? comments : "some"; + condition.extract = false; + } + + // Ensure that both conditions are functions + for (const key of ["preserve", "extract"]) { + /** @type {undefined | string} */ + let regexStr; + /** @type {undefined | RegExp} */ + let regex; + switch (typeof condition[key]) { + case "boolean": + condition[key] = condition[key] ? () => true : () => false; + break; + case "function": + break; + case "string": + if (condition[key] === "all") { + condition[key] = () => true; + break; + } + if (condition[key] === "some") { + condition[key] = /** @type {ExtractCommentsFunction} */ + (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value); + break; + } + regexStr = /** @type {string} */condition[key]; + condition[key] = /** @type {ExtractCommentsFunction} */ + (astNode, comment) => new RegExp(/** @type {string} */regexStr).test(comment.value); + break; + default: + regex = /** @type {RegExp} */condition[key]; + condition[key] = /** @type {ExtractCommentsFunction} */ + (astNode, comment) => /** @type {RegExp} */regex.test(comment.value); + } + } + + // Redefine the comments function to extract and preserve + // comments according to the two conditions + return (astNode, comment) => { + if (/** @type {{ extract: ExtractCommentsFunction }} */ + condition.extract(astNode, comment)) { + const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`; + + // Don't include duplicate comments + if (!extractedComments.includes(commentText)) { + extractedComments.push(commentText); + } + } + return /** @type {{ preserve: ExtractCommentsFunction }} */condition.preserve(astNode, comment); + }; + }; + + /** + * @param {import("uglify-js").MinifyOptions & { ecma?: number | string }=} uglifyJsOptions uglify-js options + * @returns {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglify-js options + */ + const buildUglifyJsOptions = (uglifyJsOptions = {}) => { + if (typeof uglifyJsOptions.ecma !== "undefined") { + delete uglifyJsOptions.ecma; + } + if (typeof uglifyJsOptions.module !== "undefined") { + delete uglifyJsOptions.module; + } + + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + return { + ...uglifyJsOptions, + // warnings: uglifyJsOptions.warnings, + parse: { + ...uglifyJsOptions.parse + }, + compress: typeof uglifyJsOptions.compress === "boolean" ? uglifyJsOptions.compress : { + ...uglifyJsOptions.compress + }, + mangle: + // eslint-disable-next-line no-eq-null, eqeqeq + uglifyJsOptions.mangle == null ? true : typeof uglifyJsOptions.mangle === "boolean" ? uglifyJsOptions.mangle : { + ...uglifyJsOptions.mangle + }, + output: { + beautify: false, + ...uglifyJsOptions.output + }, + // Ignoring sourceMap from options + + sourceMap: undefined + // toplevel: uglifyJsOptions.toplevel + // nameCache: { ...uglifyJsOptions.toplevel }, + // ie8: uglifyJsOptions.ie8, + // keep_fnames: uglifyJsOptions.keep_fnames, + }; + }; + let minify; + try { + ({ + minify + } = require("uglify-js")); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + + // Copy `uglify-js` options + const uglifyJsOptions = buildUglifyJsOptions(minimizerOptions); + + // Let `uglify-js` generate a SourceMap. The dispatcher in `minify.js` + // chains the previous step's map onto this one. + if (sourceMap) { + uglifyJsOptions.sourceMap = true; + } + + /** @type {ExtractedComments} */ + const extractedComments = []; + + // @ts-expect-error wrong types in uglify-js + uglifyJsOptions.output.comments = buildComments(uglifyJsOptions, extractedComments); + const [[filename, code]] = Object.entries(input); + const result = await minify({ + [filename]: code + }, uglifyJsOptions); + return { + code: result.code, + map: result.map ? JSON.parse(result.map) : undefined, + errors: result.error ? [result.error] : [], + warnings: result.warnings || [], + extractedComments + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +uglifyJsMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("uglify-js/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker thread is supported, false otherwise + */ +uglifyJsMinify.supportsWorkerThreads = () => true; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a JavaScript file + */ +uglifyJsMinify.filter = name => JS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @param {ExtractCommentsOptions=} extractComments extract comments option + * @returns {Promise} minimized result + */ +async function swcMinify(input, sourceMap, minimizerOptions, extractComments) { + /** + * @param {unknown} value value + * @returns {boolean} true when value is object or function + */ + const isObject = value => { + const type = typeof value; + + // eslint-disable-next-line no-eq-null, eqeqeq + return value != null && (type === "object" || type === "function"); + }; + + /** + * @param {unknown} extractCommentsOptions extract comments option + * @returns {Error} error for unsupported extract comments option + */ + const createExtractCommentsError = extractCommentsOptions => new Error(`The 'extractComments' option for 'swcMinify' only supports booleans, "some", "all", string patterns, RegExp values without flags, or object conditions that resolve to those forms. Received: ${extractCommentsOptions instanceof RegExp ? extractCommentsOptions.toString() : typeof extractCommentsOptions}.`); + + /** + * @param {unknown} extractCommentsOptions extract comments option + * @returns {{ extractComments: false | true | "some" | "all" | { regex: string }, useDefaultPreserveComments: boolean }} normalized swc extract comments options + */ + const normalizeExtractComments = extractCommentsOptions => { + if (typeof extractCommentsOptions === "boolean") { + return { + extractComments: extractCommentsOptions, + useDefaultPreserveComments: !extractCommentsOptions + }; + } + if (typeof extractCommentsOptions === "string") { + return { + extractComments: extractCommentsOptions === "some" || extractCommentsOptions === "all" ? extractCommentsOptions : { + regex: extractCommentsOptions + }, + useDefaultPreserveComments: false + }; + } + if (extractCommentsOptions instanceof RegExp) { + if (extractCommentsOptions.flags) { + throw createExtractCommentsError(extractCommentsOptions); + } + return { + extractComments: { + regex: extractCommentsOptions.source + }, + useDefaultPreserveComments: false + }; + } + if (typeof extractCommentsOptions === "function") { + throw createExtractCommentsError(extractCommentsOptions); + } + if (extractCommentsOptions && isObject(extractCommentsOptions)) { + const { + condition = "some" + } = /** @type {{ condition?: unknown }} */ + extractCommentsOptions; + if (typeof condition === "boolean") { + return { + extractComments: condition ? "some" : false, + useDefaultPreserveComments: false + }; + } + if (typeof condition === "string") { + return { + extractComments: condition === "some" || condition === "all" ? condition : { + regex: condition + }, + useDefaultPreserveComments: false + }; + } + if (condition instanceof RegExp) { + if (condition.flags) { + throw createExtractCommentsError(condition); + } + return { + extractComments: { + regex: condition.source + }, + useDefaultPreserveComments: false + }; + } + throw createExtractCommentsError(condition); + } + return { + extractComments: false, + useDefaultPreserveComments: false + }; + }; + + /** + * @param {import("@swc/core").JsMinifyOptions=} swcOptions swc options + * @returns {import("@swc/core").JsMinifyOptions & { extractComments?: false | true | "some" | "all" | { regex: string } } & { sourceMap: undefined | boolean } & { compress: import("@swc/core").TerserCompressOptions }} built swc options + */ + const buildSwcOptions = (swcOptions = {}) => ( + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + { + ...swcOptions, + compress: typeof swcOptions.compress === "boolean" ? swcOptions.compress ? {} : false : { + ...swcOptions.compress + }, + mangle: + // eslint-disable-next-line no-eq-null, eqeqeq + swcOptions.mangle == null ? true : typeof swcOptions.mangle === "boolean" ? swcOptions.mangle : { + ...swcOptions.mangle + }, + format: { + ...swcOptions.format + }, + // ecma: swcOptions.ecma, + // keep_classnames: swcOptions.keep_classnames, + // keep_fnames: swcOptions.keep_fnames, + // module: swcOptions.module, + // safari10: swcOptions.safari10, + // toplevel: swcOptions.toplevel + + sourceMap: undefined + }); + let swc; + try { + swc = require("@swc/core"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + + // Copy `swc` options + const swcOptions = buildSwcOptions(minimizerOptions); + const normalizedExtractComments = normalizeExtractComments(extractComments); + if (!swcOptions.format) { + swcOptions.format = {}; + } + + // Let `swc` generate a SourceMap. + if (sourceMap) { + swcOptions.sourceMap = true; + } + if (normalizedExtractComments.useDefaultPreserveComments && typeof swcOptions.format.comments === "undefined") { + swcOptions.format.comments = "some"; + } + if (normalizedExtractComments.extractComments !== false) { + /** @type {import("@swc/core").JsMinifyOptions & { extractComments?: false | true | "some" | "all" | { regex: string } }} */ + swcOptions.extractComments = normalizedExtractComments.extractComments; + } + if (swcOptions.compress) { + // More optimizations + if (typeof swcOptions.compress.ecma === "undefined") { + swcOptions.compress.ecma = swcOptions.ecma; + } + + // https://github.com/webpack/webpack/issues/16135 + if (swcOptions.ecma === 5 && typeof swcOptions.compress.arrows === "undefined") { + swcOptions.compress.arrows = false; + } + } + const [[filename, code]] = Object.entries(input); + const result = /** @type {import("@swc/core").Output & { extractedComments?: string[] }} */ + await swc.minify(code, swcOptions); + let map; + if (result.map) { + map = JSON.parse(result.map); + + // TODO workaround for swc because `filename` is not preset as in `swc` signature as for `terser` + map.sources = [filename]; + delete map.sourcesContent; + } + return { + code: result.code, + map, + extractedComments: result.extractedComments || [] + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +swcMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("@swc/core/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker thread is supported, false otherwise + */ +swcMinify.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a JavaScript file + */ +swcMinify.filter = name => JS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function esbuildMinify(input, sourceMap, minimizerOptions) { + /** + * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean }=} esbuildOptions esbuild options + * @returns {import("esbuild").TransformOptions} built esbuild options + */ + const buildEsbuildOptions = (esbuildOptions = {}) => { + delete esbuildOptions.ecma; + if (esbuildOptions.module) { + esbuildOptions.format = "esm"; + } + delete esbuildOptions.module; + + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + return { + minify: true, + legalComments: "inline", + ...esbuildOptions, + sourcemap: false + }; + }; + let esbuild; + try { + esbuild = require("esbuild"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + + // Copy `esbuild` options + const esbuildOptions = buildEsbuildOptions(minimizerOptions); + + // Let `esbuild` generate a SourceMap + if (sourceMap) { + esbuildOptions.sourcemap = true; + esbuildOptions.sourcesContent = false; + } + const [[filename, code]] = Object.entries(input); + esbuildOptions.sourcefile = filename; + const result = await esbuild.transform(code, esbuildOptions); + return { + code: result.code, + map: result.map ? JSON.parse(result.map) : undefined, + warnings: result.warnings.length > 0 ? result.warnings.map(item => { + const plugin = item.pluginName ? `\nPlugin Name: ${item.pluginName}` : ""; + const location = item.location ? `\n\n${item.location.file}:${item.location.line}:${item.location.column}:\n ${item.location.line} | ${item.location.lineText}\n\nSuggestion: ${item.location.suggestion}` : ""; + const notes = item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : ""; + return `${item.text} [${item.id}]${plugin}${location}${item.detail ? `\nDetails:\n${item.detail}` : ""}${notes}`; + }) : [] + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +esbuildMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("esbuild/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker thread is supported, false otherwise + */ +esbuildMinify.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a JavaScript file + */ +esbuildMinify.filter = name => JS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function jsonMinify(input, sourceMap, minimizerOptions) { + const options = /** @type {{ replacer?: Parameters[1], space?: Parameters[2] }} */ + minimizerOptions; + const [[, code]] = Object.entries(input); + const result = JSON.stringify(JSON.parse(code), options.replacer, options.space); + return { + code: result + }; +} +jsonMinify.getMinimizerVersion = () => "1.0.0"; +jsonMinify.supportsWorker = () => false; +jsonMinify.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a JSON file + */ +jsonMinify.filter = name => JSON_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify HTML using `html-minifier-terser`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map (ignored for HTML) + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function htmlMinifierTerser(input, sourceMap, minimizerOptions) { + let htmlMinifier; + try { + htmlMinifier = require("html-minifier-terser"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[, code]] = Object.entries(input); + /** @type {import("html-minifier-terser").Options} */ + const defaultMinimizerOptions = { + caseSensitive: true, + // `collapseBooleanAttributes` is not always safe, since this can break CSS attribute selectors and not safe for XHTML + collapseWhitespace: true, + conservativeCollapse: true, + keepClosingSlash: true, + // We need ability to use cssnano, or setup own function without extra dependencies + minifyCSS: true, + minifyJS: true, + // `minifyURLs` is unsafe, because we can't guarantee what the base URL is + // `removeAttributeQuotes` is not safe in some rare cases, also HTML spec recommends against doing this + removeComments: true, + // `removeEmptyAttributes` is not safe, can affect certain style or script behavior, look at https://github.com/webpack-contrib/html-loader/issues/323 + // `removeRedundantAttributes` is not safe, can affect certain style or script behavior, look at https://github.com/webpack-contrib/html-loader/issues/323 + removeScriptTypeAttributes: true, + removeStyleLinkTypeAttributes: true + // `useShortDoctype` is not safe for XHTML + }; + const result = await htmlMinifier.minify(code, { + ...defaultMinimizerOptions, + ...(/** @type {import("html-minifier-terser").Options} */minimizerOptions) + }); + return { + code: result + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +htmlMinifierTerser.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("html-minifier-terser/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker threads are supported + */ +htmlMinifierTerser.supportsWorkerThreads = () => true; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like an HTML file + */ +htmlMinifierTerser.filter = name => HTML_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify HTML using `@minify-html/node`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map (ignored for HTML) + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function minifyHtmlNode(input, sourceMap, minimizerOptions) { + let minifyHtmlPkg; + try { + minifyHtmlPkg = require("@minify-html/node"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[, code]] = Object.entries(input); + const options = /** @type {Parameters[1]} */{ + ...minimizerOptions + }; + const result = await minifyHtmlPkg.minify(Buffer.from(code), options); + return { + code: result.toString() + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +minifyHtmlNode.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("@minify-html/node/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} false because `@minify-html/node` is a native binding + */ +minifyHtmlNode.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like an HTML file + */ +minifyHtmlNode.filter = name => HTML_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Map an `@swc/html` diagnostic to a regular `Error`. + * @param {EXPECTED_OBJECT} diagnostic diagnostic from `@swc/html` + * @returns {Error} error preserving `span` and `level` from the diagnostic + */ +function swcHtmlDiagnosticToError(diagnostic) { + const typed = /** @type {{ message: string, span?: unknown, level?: unknown }} */ + diagnostic; + /** @type {Error & { span?: unknown, level?: unknown }} */ + const error = new Error(typed.message); + error.span = typed.span; + error.level = typed.level; + return error; +} + +/* istanbul ignore next */ +/** + * Minify a complete HTML document using `@swc/html`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map (ignored for HTML) + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function swcMinifyHtml(input, sourceMap, minimizerOptions) { + let swcMinifier; + try { + swcMinifier = require("@swc/html"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[, code]] = Object.entries(input); + const options = /** @type {import("@swc/html").Options} */{ + ...minimizerOptions + }; + const result = await swcMinifier.minify(Buffer.from(code), options); + return { + code: result.code, + errors: result.errors ? result.errors.map(swcHtmlDiagnosticToError) : undefined + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +swcMinifyHtml.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("@swc/html/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} false because `@swc/html` is a native binding + */ +swcMinifyHtml.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like an HTML file + */ +swcMinifyHtml.filter = name => HTML_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify an HTML fragment using `@swc/html`. + * + * Use this for partial HTML (e.g. inside `` tags or + * HTML strings that are inserted into another document). + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map (ignored for HTML) + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function swcMinifyHtmlFragment(input, sourceMap, minimizerOptions) { + let swcMinifier; + try { + swcMinifier = require("@swc/html"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[, code]] = Object.entries(input); + const options = /** @type {import("@swc/html").FragmentOptions} */{ + ...minimizerOptions + }; + const result = await swcMinifier.minifyFragment(Buffer.from(code), options); + return { + code: result.code, + errors: result.errors ? result.errors.map(swcHtmlDiagnosticToError) : undefined + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +swcMinifyHtmlFragment.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("@swc/html/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} false because `@swc/html` is a native binding + */ +swcMinifyHtmlFragment.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like an HTML file + */ +swcMinifyHtmlFragment.filter = name => HTML_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify CSS using `cssnano` (via `postcss`). + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function cssnanoMinify(input, sourceMap, minimizerOptions = { + preset: "default" +}) { + /** + * @template T + * @param {string} mod module to load + * @returns {Promise} loaded module + */ + const load = async mod => { + let exports; + try { + exports = require(mod); + return exports; + } catch (err) { + let importESM; + try { + // eslint-disable-next-line no-new-func + importESM = new Function("id", "return import(id);"); + } catch (_err) { + importESM = null; + } + if (/** @type {Error & { code: string }} */ + err.code === "ERR_REQUIRE_ESM" && importESM) { + exports = await importESM(mod); + return exports.default; + } + throw err; + } + }; + let postcss; + let cssnano; + try { + postcss = require("postcss"); + cssnano = require("cssnano"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[name, code]] = Object.entries(input); + /** @type {import("postcss").ProcessOptions} */ + const postcssOptions = { + from: name, + ... /** @type {{ processorOptions?: import("postcss").ProcessOptions }} */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: ${ /** @type {Error} */error.message}\n\n(@${name})`, { + cause: error + }); + } + } + if (typeof postcssOptions.stringifier === "string") { + try { + postcssOptions.stringifier = await load(postcssOptions.stringifier); + } catch (error) { + throw new Error(`Loading PostCSS "${postcssOptions.stringifier}" stringifier failed: ${ /** @type {Error} */error.message}\n\n(@${name})`, { + cause: error + }); + } + } + if (typeof postcssOptions.syntax === "string") { + try { + postcssOptions.syntax = await load(postcssOptions.syntax); + } catch (error) { + throw new Error(`Loading PostCSS "${postcssOptions.syntax}" syntax failed: ${ /** @type {Error} */error.message}\n\n(@${name})`, { + cause: error + }); + } + } + if (sourceMap) { + postcssOptions.map = { + annotation: false + }; + } + const result = await postcss.default([cssnano(minimizerOptions)]).process(code, postcssOptions); + return { + code: result.css, + map: result.map ? (/** @type {RawSourceMap} */ + /** @type {unknown} */result.map.toJSON()) : undefined, + warnings: result.warnings().map(String) + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +cssnanoMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("cssnano/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker threads are supported + */ +cssnanoMinify.supportsWorkerThreads = () => true; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a CSS file + */ +cssnanoMinify.filter = name => CSS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify CSS using `csso`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function cssoMinify(input, sourceMap, minimizerOptions) { + let csso; + try { + csso = require("csso"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[filename, code]] = Object.entries(input); + const result = csso.minify(code, { + filename, + sourceMap: Boolean(sourceMap), + ...minimizerOptions + }); + return { + code: result.css, + map: result.map ? (/** @type {RawSourceMap} */ + /** @type {{ toJSON(): RawSourceMap }} */result.map.toJSON()) : undefined + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +cssoMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("csso/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker threads are supported + */ +cssoMinify.supportsWorkerThreads = () => true; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a CSS file + */ +cssoMinify.filter = name => CSS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify CSS using `clean-css`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function cleanCssMinify(input, sourceMap, minimizerOptions) { + let CleanCSS; + try { + CleanCSS = require("clean-css"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[name, code]] = Object.entries(input); + const result = await new CleanCSS({ + sourceMap: Boolean(sourceMap), + ...minimizerOptions, + returnPromise: true + }).minify({ + [name]: { + styles: code + } + }); + const generatedSourceMap = result.sourceMap ? (/** @type {RawSourceMap} */ + /** @type {{ toJSON(): RawSourceMap }} */(/** @type {unknown} */result.sourceMap).toJSON()) : undefined; + + // workaround for source maps on windows + if (generatedSourceMap) { + const isWindowsPathSep = require("path").sep === "\\"; + generatedSourceMap.sources = generatedSourceMap.sources.map( + /** + * @param {string | null} item path item + * @returns {string} normalized path + */ + item => isWindowsPathSep ? (item || "").replace(/\\/g, "/") : item || ""); + } + return { + code: result.styles, + map: generatedSourceMap, + warnings: result.warnings + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +cleanCssMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("clean-css/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} true if worker threads are supported + */ +cleanCssMinify.supportsWorkerThreads = () => true; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a CSS file + */ +cleanCssMinify.filter = name => CSS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify CSS using `esbuild` (with the CSS loader). + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function esbuildMinifyCss(input, sourceMap, minimizerOptions) { + /** + * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean }=} esbuildOptions esbuild options + * @returns {import("esbuild").TransformOptions} built esbuild options + */ + const buildEsbuildOptions = (esbuildOptions = {}) => { + // `module` and `ecma` are JavaScript-only concepts; the dispatcher + // injects them for every minimizer, but esbuild's CSS transform + // rejects unknown options. + delete esbuildOptions.ecma; + delete esbuildOptions.module; + + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + return { + loader: "css", + minify: true, + legalComments: "inline", + ...esbuildOptions, + sourcemap: false + }; + }; + let esbuild; + try { + esbuild = require("esbuild"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + + // Copy `esbuild` options + const esbuildOptions = buildEsbuildOptions(minimizerOptions); + + // Let `esbuild` generate a SourceMap + if (sourceMap) { + esbuildOptions.sourcemap = true; + esbuildOptions.sourcesContent = false; + } + const [[filename, code]] = Object.entries(input); + esbuildOptions.sourcefile = filename; + const result = await esbuild.transform(code, esbuildOptions); + return { + code: result.code, + map: result.map ? JSON.parse(result.map) : undefined, + warnings: result.warnings.length > 0 ? result.warnings.map(item => { + const plugin = item.pluginName ? `\nPlugin Name: ${item.pluginName}` : ""; + const location = item.location ? `\n\n${item.location.file}:${item.location.line}:${item.location.column}:\n ${item.location.line} | ${item.location.lineText}\n\nSuggestion: ${item.location.suggestion}` : ""; + const notes = item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : ""; + return `${item.text} [${item.id}]${plugin}${location}${item.detail ? `\nDetails:\n${item.detail}` : ""}${notes}`; + }) : [] + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +esbuildMinifyCss.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("esbuild/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} false because `esbuild` is a native binding + */ +esbuildMinifyCss.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a CSS file + */ +esbuildMinifyCss.filter = name => CSS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Minify CSS using `lightningcss`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function lightningCssMinify(input, sourceMap, minimizerOptions) { + let lightningCss; + try { + lightningCss = require("lightningcss"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[filename, code]] = Object.entries(input); + /** + * @param {Partial>=} lightningCssOptions lightning css options + * @returns {import("lightningcss").TransformOptions} built lightning css options + */ + const buildLightningCssOptions = (lightningCssOptions = {}) => ( + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + { + minify: true, + ...lightningCssOptions, + sourceMap: false, + filename, + code: new Uint8Array(Buffer.from(code)) + }); + + // Copy `lightningCss` options + const lightningCssOptions = buildLightningCssOptions(minimizerOptions); + + // Let `lightningcss` generate a SourceMap. The dispatcher in + // `minify.js` chains the previous step's map onto this one. + if (sourceMap) { + lightningCssOptions.sourceMap = true; + } + const result = lightningCss.transform(lightningCssOptions); + return { + code: result.code.toString(), + map: result.map ? JSON.parse(result.map.toString()) : undefined + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +lightningCssMinify.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("lightningcss/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} false because `lightningcss` is a native binding + */ +lightningCssMinify.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a CSS file + */ +lightningCssMinify.filter = name => CSS_FILE_RE.test(name); + +/* istanbul ignore next */ +/** + * Map a `@swc/css` diagnostic to a regular `Error`. + * @param {EXPECTED_OBJECT} diagnostic diagnostic from `@swc/css` + * @returns {Error} error preserving `span` and `level` from the diagnostic + */ +function swcCssDiagnosticToError(diagnostic) { + const typed = /** @type {{ message: string, span?: unknown, level?: unknown }} */ + diagnostic; + /** @type {Error & { span?: unknown, level?: unknown }} */ + const error = new Error(typed.message); + error.span = typed.span; + error.level = typed.level; + return error; +} + +/* istanbul ignore next */ +/** + * Minify CSS using `@swc/css`. + * @param {Input} input input + * @param {RawSourceMap=} sourceMap source map + * @param {CustomOptions=} minimizerOptions options + * @returns {Promise} minimized result + */ +async function swcMinifyCss(input, sourceMap, minimizerOptions) { + let swc; + try { + swc = require("@swc/css"); + } catch (err) { + return { + errors: [(/** @type {Error} */err)] + }; + } + const [[filename, code]] = Object.entries(input); + /** + * @param {Partial=} swcOptions swc options + * @returns {import("@swc/css").MinifyOptions} built swc options + */ + const buildSwcOptions = (swcOptions = {}) => ( + // Need deep copy objects to avoid https://github.com/terser/terser/issues/366 + { + ...swcOptions, + filename + }); + + // Copy `swc` options + const swcOptions = buildSwcOptions(minimizerOptions); + + // Let `swc` generate a SourceMap + if (sourceMap) { + swcOptions.sourceMap = true; + } + const result = await swc.minify(Buffer.from(code), swcOptions); + return { + code: result.code.toString(), + map: result.map ? JSON.parse(result.map.toString()) : undefined, + errors: result.errors ? result.errors.map(swcCssDiagnosticToError) : undefined + }; +} + +/** + * @returns {string | undefined} the minimizer version + */ +swcMinifyCss.getMinimizerVersion = () => { + let packageJson; + try { + packageJson = require("@swc/css/package.json"); + } catch (_err) { + // Ignore + } + return packageJson && packageJson.version; +}; + +/** + * @returns {boolean | undefined} false because `@swc/css` is a native binding + */ +swcMinifyCss.supportsWorkerThreads = () => false; + +/** + * @param {string} name asset name + * @returns {boolean} true if `name` looks like a CSS file + */ +swcMinifyCss.filter = name => CSS_FILE_RE.test(name); + +/** + * @template T + * @typedef {() => T} FunctionReturning + */ + +/** + * @template T + * @param {FunctionReturning} fn memorized function + * @returns {FunctionReturning} new function + */ +function memoize(fn) { + let cache = false; + /** @type {T} */ + let result; + return () => { + if (cache) { + return result; + } + result = fn(); + cache = true; + // Allow to clean up memory for fn + // and all dependent resources + /** @type {FunctionReturning | undefined} */ + fn = undefined; + return /** @type {T} */result; + }; +} +module.exports = { + cleanCssMinify, + cssnanoMinify, + cssoMinify, + esbuildMinify, + esbuildMinifyCss, + getEcmaVersion, + htmlMinifierTerser, + jsonMinify, + lightningCssMinify, + memoize, + minifyHtmlNode, + swcMinify, + swcMinifyCss, + swcMinifyHtml, + swcMinifyHtmlFragment, + terserMinify, + throttleAll, + uglifyJsMinify +};