@rspack/core 0.2.5 → 0.2.6

package/dist/stats/DefaultStatsPrinterPlugin.js

@@ -0,0 +1,1041 @@
+"use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/stats
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultStatsPrinterPlugin = void 0;
+const SizeFormatHelpers_1 = require("../util/SizeFormatHelpers");
+const DATA_URI_CONTENT_LENGTH = 16;
+const plural = (n, singular, plural) => n === 1 ? singular : plural;
+const printSizes = (sizes, { formatSize = (n) => `${n}` }) => {
+    const keys = Object.keys(sizes);
+    if (keys.length > 1) {
+        return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
+    }
+    else if (keys.length === 1) {
+        return formatSize(sizes[keys[0]]);
+    }
+};
+const getResourceName = (resource) => {
+    const dataUrl = /^data:[^,]+,/.exec(resource);
+    if (!dataUrl)
+        return resource;
+    const len = dataUrl[0].length + DATA_URI_CONTENT_LENGTH;
+    if (resource.length < len)
+        return resource;
+    return `${resource.slice(0, Math.min(resource.length - /* '..'.length */ 2, len))}..`;
+};
+const getModuleName = (name) => {
+    const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name) || [];
+    return [prefix, getResourceName(resource)];
+};
+const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
+const twoDigit = (n) => (n >= 10 ? `${n}` : `0${n}`);
+const isValidId = (id) => {
+    return typeof id === "number" || id;
+};
+const moreCount = (list, count) => {
+    return list && list.length > 0 ? `+ ${count}` : `${count}`;
+};
+const SIMPLE_PRINTERS = {
+    "compilation.summary!": (_, { type, bold, green, red, yellow, formatDateTime, formatTime, compilation: { name, hash, rspackVersion, time, builtAt, errorsCount, warningsCount } }) => {
+        const root = type === "compilation.summary!";
+        const warningsMessage = warningsCount && warningsCount > 0
+            ? yellow(`${warningsCount} ${plural(warningsCount, "warning", "warnings")}`)
+            : "";
+        const errorsMessage = errorsCount && errorsCount > 0
+            ? red(`${errorsCount} ${plural(errorsCount, "error", "errors")}`)
+            : "";
+        const timeMessage = root && time ? ` in ${formatTime(time)}` : "";
+        const hashMessage = hash ? ` (${hash})` : "";
+        const builtAtMessage = root && builtAt ? `${formatDateTime(builtAt)}: ` : "";
+        const versionMessage = root && rspackVersion ? `rspack ${rspackVersion}` : "";
+        const nameMessage = root && name
+            ? bold(name)
+            : name
+                ? `Child ${bold(name)}`
+                : root
+                    ? ""
+                    : "Child";
+        const subjectMessage = nameMessage && versionMessage
+            ? `${nameMessage} (${versionMessage})`
+            : versionMessage || nameMessage || "rspack";
+        let statusMessage;
+        if (errorsMessage && warningsMessage) {
+            statusMessage = `compiled with ${errorsMessage} and ${warningsMessage}`;
+        }
+        else if (errorsMessage) {
+            statusMessage = `compiled with ${errorsMessage}`;
+        }
+        else if (warningsMessage) {
+            statusMessage = `compiled with ${warningsMessage}`;
+        }
+        else if (errorsCount === 0 && warningsCount === 0) {
+            statusMessage = `compiled ${green("successfully")}`;
+        }
+        else {
+            statusMessage = `compiled`;
+        }
+        if (builtAtMessage ||
+            versionMessage ||
+            errorsMessage ||
+            warningsMessage ||
+            (errorsCount === 0 && warningsCount === 0) ||
+            timeMessage ||
+            hashMessage)
+            return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
+    },
+    "compilation.filteredWarningDetailsCount": count => count
+        ? `${count} ${plural(count, "warning has", "warnings have")} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+        : undefined,
+    "compilation.filteredErrorDetailsCount": (count, { yellow }) => count
+        ? yellow(`${count} ${plural(count, "error has", "errors have")} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`)
+        : undefined,
+    "compilation.env": (env, { bold }) => env
+        ? `Environment (--env): ${bold(JSON.stringify(env, null, 2))}`
+        : undefined,
+    "compilation.publicPath": (publicPath, { bold }) => `PublicPath: ${bold(publicPath || "(none)")}`,
+    "compilation.entrypoints": (entrypoints, context, printer) => Array.isArray(entrypoints)
+        ? undefined
+        : printer.print(context.type, Object.values(entrypoints), {
+            ...context,
+            chunkGroupKind: "Entrypoint"
+        }),
+    "compilation.namedChunkGroups": (namedChunkGroups, context, printer) => {
+        if (!Array.isArray(namedChunkGroups)) {
+            const { compilation: { entrypoints } } = context;
+            let chunkGroups = Object.values(namedChunkGroups);
+            if (entrypoints) {
+                chunkGroups = chunkGroups.filter(group => !Object.prototype.hasOwnProperty.call(entrypoints, group.name));
+            }
+            return printer.print(context.type, chunkGroups, {
+                ...context,
+                chunkGroupKind: "Chunk Group"
+            });
+        }
+    },
+    "compilation.assetsByChunkName": () => "",
+    "compilation.filteredModules": (filteredModules, { compilation: { modules } }) => filteredModules > 0
+        ? `${moreCount(modules, filteredModules)} ${plural(filteredModules, "module", "modules")}`
+        : undefined,
+    "compilation.filteredAssets": (filteredAssets, { compilation: { assets } }) => filteredAssets > 0
+        ? `${moreCount(assets, filteredAssets)} ${plural(filteredAssets, "asset", "assets")}`
+        : undefined,
+    // "compilation.logging": (logging, context, printer) =>
+    // 	Array.isArray(logging)
+    // 		? undefined
+    // 		: printer.print(
+    // 				context.type,
+    // 				Object.entries(logging).map(([name, value]) => ({ ...value, name })),
+    // 				context
+    // 		  ),
+    "compilation.warningsInChildren!": (_, { yellow, compilation }) => {
+        if (!compilation.children &&
+            compilation.warningsCount &&
+            compilation.warningsCount > 0 &&
+            compilation.warnings) {
+            const childWarnings = compilation.warningsCount - compilation.warnings.length;
+            if (childWarnings > 0) {
+                return yellow(`${childWarnings} ${plural(childWarnings, "WARNING", "WARNINGS")} in child compilations${compilation.children
+                    ? ""
+                    : " (Use 'stats.children: true' resp. '--stats-children' for more details)"}`);
+            }
+        }
+    },
+    "compilation.errorsInChildren!": (_, { red, compilation }) => {
+        if (!compilation.children &&
+            compilation.errorsCount &&
+            compilation.errorsCount > 0 &&
+            compilation.errors) {
+            const childErrors = compilation.errorsCount - compilation.errors.length;
+            if (childErrors > 0) {
+                return red(`${childErrors} ${plural(childErrors, "ERROR", "ERRORS")} in child compilations${compilation.children
+                    ? ""
+                    : " (Use 'stats.children: true' resp. '--stats-children' for more details)"}`);
+            }
+        }
+    },
+    "asset.type": type => type,
+    "asset.name": (name, { formatFilename, asset: { isOverSizeLimit } }) => formatFilename(name, isOverSizeLimit),
+    "asset.size": (size, { asset: { isOverSizeLimit }, yellow, green, formatSize }) => (isOverSizeLimit ? yellow(formatSize(size)) : formatSize(size)),
+    "asset.emitted": (emitted, { green, formatFlag }) => emitted ? green(formatFlag("emitted")) : undefined,
+    "asset.comparedForEmit": (comparedForEmit, { yellow, formatFlag }) => comparedForEmit ? yellow(formatFlag("compared for emit")) : undefined,
+    "asset.cached": (cached, { green, formatFlag }) => cached ? green(formatFlag("cached")) : undefined,
+    "asset.isOverSizeLimit": (isOverSizeLimit, { yellow, formatFlag }) => isOverSizeLimit ? yellow === null || yellow === void 0 ? void 0 : yellow(formatFlag("big")) : undefined,
+    "asset.info.immutable": (immutable, { green, formatFlag }) => immutable ? green(formatFlag("immutable")) : undefined,
+    "asset.info.javascriptModule": (javascriptModule, { formatFlag }) => javascriptModule ? formatFlag("javascript module") : undefined,
+    "asset.info.sourceFilename": (sourceFilename, { formatFlag }) => sourceFilename
+        ? formatFlag(sourceFilename === true
+            ? "from source file"
+            : `from: ${sourceFilename}`)
+        : undefined,
+    "asset.info.development": (development, { green, formatFlag }) => development ? green(formatFlag("dev")) : undefined,
+    "asset.info.hotModuleReplacement": (hotModuleReplacement, { green, formatFlag }) => (hotModuleReplacement ? green(formatFlag("hmr")) : undefined),
+    "asset.separator!": () => "\n",
+    "asset.filteredRelated": (filteredRelated, { asset: { related } }) => filteredRelated > 0
+        ? `${moreCount(related, filteredRelated)} related ${plural(filteredRelated, "asset", "assets")}`
+        : undefined,
+    "asset.filteredChildren": (filteredChildren, { asset: { children } }) => filteredChildren > 0
+        ? `${moreCount(children, filteredChildren)} ${plural(filteredChildren, "asset", "assets")}`
+        : undefined,
+    assetChunk: (id, { formatChunkId }) => formatChunkId(id),
+    assetChunkName: name => name,
+    assetChunkIdHint: name => name,
+    "module.type": type => (type !== "module" ? type : undefined),
+    "module.id": (id, { formatModuleId }) => isValidId(id) ? formatModuleId(id) : undefined,
+    "module.name": (name, { bold }) => {
+        const [prefix, resource] = getModuleName(name);
+        return `${prefix || ""}${bold(resource || "")}`;
+    },
+    "module.identifier": identifier => undefined,
+    "module.layer": (layer, { formatLayer }) => layer ? formatLayer(layer) : undefined,
+    "module.sizes": printSizes,
+    "module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
+    "module.depth": (depth, { formatFlag }) => depth !== null ? formatFlag(`depth ${depth}`) : undefined,
+    "module.cacheable": (cacheable, { formatFlag, red }) => cacheable === false ? red(formatFlag("not cacheable")) : undefined,
+    "module.orphan": (orphan, { formatFlag, yellow }) => orphan ? yellow(formatFlag("orphan")) : undefined,
+    "module.runtime": (runtime, { formatFlag, yellow }) => runtime ? yellow(formatFlag("runtime")) : undefined,
+    "module.optional": (optional, { formatFlag, yellow }) => optional ? yellow(formatFlag("optional")) : undefined,
+    "module.dependent": (dependent, { formatFlag, cyan }) => dependent ? cyan(formatFlag("dependent")) : undefined,
+    "module.built": (built, { formatFlag, yellow }) => built ? yellow(formatFlag("built")) : undefined,
+    "module.codeGenerated": (codeGenerated, { formatFlag, yellow }) => codeGenerated ? yellow(formatFlag("code generated")) : undefined,
+    "module.buildTimeExecuted": (buildTimeExecuted, { formatFlag, green }) => buildTimeExecuted ? green(formatFlag("build time executed")) : undefined,
+    "module.cached": (cached, { formatFlag, green }) => cached ? green(formatFlag("cached")) : undefined,
+    "module.assets": (assets, { formatFlag, magenta }) => assets && assets.length
+        ? magenta(formatFlag(`${assets.length} ${plural(assets.length, "asset", "assets")}`))
+        : undefined,
+    "module.warnings": (warnings, { formatFlag, yellow }) => warnings === true
+        ? yellow(formatFlag("warnings"))
+        : warnings
+            ? yellow(formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`))
+            : undefined,
+    "module.errors": (errors, { formatFlag, red }) => errors === true
+        ? red(formatFlag("errors"))
+        : errors
+            ? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
+            : undefined,
+    "module.providedExports": (providedExports, { formatFlag, cyan }) => {
+        if (Array.isArray(providedExports)) {
+            if (providedExports.length === 0)
+                return cyan(formatFlag("no exports"));
+            return cyan(formatFlag(`exports: ${providedExports.join(", ")}`));
+        }
+    },
+    "module.usedExports": (usedExports, { formatFlag, cyan, module }) => {
+        if (usedExports !== true) {
+            if (usedExports === null)
+                return cyan(formatFlag("used exports unknown"));
+            if (usedExports === false)
+                return cyan(formatFlag("module unused"));
+            if (Array.isArray(usedExports)) {
+                if (usedExports.length === 0)
+                    return cyan(formatFlag("no exports used"));
+                const providedExportsCount = Array.isArray(module.providedExports)
+                    ? module.providedExports.length
+                    : null;
+                if (providedExportsCount !== null &&
+                    providedExportsCount === usedExports.length) {
+                    return cyan(formatFlag("all exports used"));
+                }
+                else {
+                    return cyan(formatFlag(`only some exports used: ${usedExports.join(", ")}`));
+                }
+            }
+        }
+    },
+    "module.optimizationBailout[]": (optimizationBailout, { yellow }) => yellow(optimizationBailout),
+    "module.issuerPath": (issuerPath, { module }) => module.profile ? undefined : "",
+    "module.profile": profile => undefined,
+    "module.filteredModules": (filteredModules, { module: { modules } }) => filteredModules > 0
+        ? `${moreCount(modules, filteredModules)} nested ${plural(filteredModules, "module", "modules")}`
+        : undefined,
+    "module.filteredReasons": (filteredReasons, { module: { reasons } }) => filteredReasons > 0
+        ? `${moreCount(reasons, filteredReasons)} ${plural(filteredReasons, "reason", "reasons")}`
+        : undefined,
+    "module.filteredChildren": (filteredChildren, { module: { children } }) => filteredChildren > 0
+        ? `${moreCount(children, filteredChildren)} ${plural(filteredChildren, "module", "modules")}`
+        : undefined,
+    "module.separator!": () => "\n",
+    "moduleIssuer.id": (id, { formatModuleId }) => formatModuleId(id),
+    "moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value),
+    "moduleReason.type": type => type,
+    "moduleReason.userRequest": (userRequest, { cyan }) => cyan(getResourceName(userRequest)),
+    "moduleReason.moduleId": (moduleId, { formatModuleId }) => isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
+    "moduleReason.module": (module, { magenta }) => magenta(module),
+    "moduleReason.loc": loc => loc,
+    "moduleReason.explanation": (explanation, { cyan }) => cyan(explanation),
+    "moduleReason.active": (active, { formatFlag }) => active ? undefined : formatFlag("inactive"),
+    "moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
+    "moduleReason.filteredChildren": (filteredChildren, { moduleReason: { children } }) => filteredChildren > 0
+        ? `${moreCount(children, filteredChildren)} ${plural(filteredChildren, "reason", "reasons")}`
+        : undefined,
+    "module.profile.total": (value, { formatTime }) => formatTime(value),
+    "module.profile.resolving": (value, { formatTime }) => `resolving: ${formatTime(value)}`,
+    "module.profile.restoring": (value, { formatTime }) => `restoring: ${formatTime(value)}`,
+    "module.profile.integration": (value, { formatTime }) => `integration: ${formatTime(value)}`,
+    "module.profile.building": (value, { formatTime }) => `building: ${formatTime(value)}`,
+    "module.profile.storing": (value, { formatTime }) => `storing: ${formatTime(value)}`,
+    "module.profile.additionalResolving": (value, { formatTime }) => value ? `additional resolving: ${formatTime(value)}` : undefined,
+    "module.profile.additionalIntegration": (value, { formatTime }) => value ? `additional integration: ${formatTime(value)}` : undefined,
+    "chunkGroup.kind!": (_, { chunkGroupKind }) => chunkGroupKind,
+    "chunkGroup.separator!": () => "\n",
+    "chunkGroup.name": (name, { bold }) => bold(name),
+    "chunkGroup.isOverSizeLimit": (isOverSizeLimit, { formatFlag, yellow }) => isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
+    "chunkGroup.assetsSize": (size, { formatSize }) => size ? formatSize(size) : undefined,
+    "chunkGroup.auxiliaryAssetsSize": (size, { formatSize }) => size ? `(${formatSize(size)})` : undefined,
+    "chunkGroup.filteredAssets": (n, { chunkGroup: { assets } }) => n > 0
+        ? `${moreCount(assets, n)} ${plural(n, "asset", "assets")}`
+        : undefined,
+    "chunkGroup.filteredAuxiliaryAssets": (n, { chunkGroup: { auxiliaryAssets } }) => n > 0
+        ? `${moreCount(auxiliaryAssets, n)} auxiliary ${plural(n, "asset", "assets")}`
+        : undefined,
+    "chunkGroup.is!": () => "=",
+    "chunkGroupAsset.name": (asset, { green }) => green(asset),
+    "chunkGroupAsset.size": (size, { formatSize, chunkGroup }) => (chunkGroup.assets && chunkGroup.assets.length > 1) ||
+        (chunkGroup.auxiliaryAssets && chunkGroup.auxiliaryAssets.length > 0)
+        ? formatSize(size)
+        : undefined,
+    "chunkGroup.children": (children, context, printer) => Array.isArray(children)
+        ? undefined
+        : printer.print(context.type, Object.keys(children).map(key => ({
+            type: key,
+            children: children[key]
+        })), context),
+    "chunkGroupChildGroup.type": type => `${type}:`,
+    "chunkGroupChild.assets[]": (file, { formatFilename }) => formatFilename(file),
+    "chunkGroupChild.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
+    "chunkGroupChild.name": name => (name ? `(name: ${name})` : undefined),
+    "chunk.id": (id, { formatChunkId }) => formatChunkId(id),
+    "chunk.files[]": (file, { formatFilename }) => formatFilename(file),
+    "chunk.names[]": name => name,
+    "chunk.idHints[]": name => name,
+    "chunk.runtime[]": name => name,
+    "chunk.sizes": (sizes, context) => printSizes(sizes, context),
+    "chunk.parents[]": (parents, context) => context.formatChunkId(parents, "parent"),
+    "chunk.siblings[]": (siblings, context) => context.formatChunkId(siblings, "sibling"),
+    "chunk.children[]": (children, context) => context.formatChunkId(children, "child"),
+    "chunk.childrenByOrder": (childrenByOrder, context, printer) => Array.isArray(childrenByOrder)
+        ? undefined
+        : printer.print(context.type, Object.keys(childrenByOrder).map(key => ({
+            type: key,
+            children: childrenByOrder[key]
+        })), context),
+    "chunk.childrenByOrder[].type": type => `${type}:`,
+    "chunk.childrenByOrder[].children[]": (id, { formatChunkId }) => isValidId(id) ? formatChunkId(id) : undefined,
+    "chunk.entry": (entry, { formatFlag, yellow }) => entry ? yellow(formatFlag("entry")) : undefined,
+    "chunk.initial": (initial, { formatFlag, yellow }) => initial ? yellow(formatFlag("initial")) : undefined,
+    "chunk.rendered": (rendered, { formatFlag, green }) => rendered ? green(formatFlag("rendered")) : undefined,
+    "chunk.recorded": (recorded, { formatFlag, green }) => recorded ? green(formatFlag("recorded")) : undefined,
+    "chunk.reason": (reason, { yellow }) => (reason ? yellow(reason) : undefined),
+    "chunk.filteredModules": (filteredModules, { chunk: { modules } }) => filteredModules > 0
+        ? `${moreCount(modules, filteredModules)} chunk ${plural(filteredModules, "module", "modules")}`
+        : undefined,
+    "chunk.separator!": () => "\n",
+    "chunkOrigin.request": request => request,
+    "chunkOrigin.moduleId": (moduleId, { formatModuleId }) => isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
+    "chunkOrigin.moduleName": (moduleName, { bold }) => bold(moduleName),
+    "chunkOrigin.loc": loc => loc,
+    // Error was already formatted on the native.
+    error: error => error.formatted,
+    "loggingEntry(error).loggingEntry.message": (message, { red }) => mapLines(message, x => `<e> ${red(x)}`),
+    "loggingEntry(warn).loggingEntry.message": (message, { yellow }) => mapLines(message, x => `<w> ${yellow(x)}`),
+    "loggingEntry(info).loggingEntry.message": (message, { green }) => mapLines(message, x => `<i> ${green(x)}`),
+    "loggingEntry(log).loggingEntry.message": (message, { bold }) => mapLines(message, x => `    ${bold(x)}`),
+    "loggingEntry(debug).loggingEntry.message": message => mapLines(message, x => `    ${x}`),
+    "loggingEntry(trace).loggingEntry.message": message => mapLines(message, x => `    ${x}`),
+    "loggingEntry(status).loggingEntry.message": (message, { magenta }) => mapLines(message, x => `<s> ${magenta(x)}`),
+    "loggingEntry(profile).loggingEntry.message": (message, { magenta }) => mapLines(message, x => `<p> ${magenta(x)}`),
+    "loggingEntry(profileEnd).loggingEntry.message": (message, { magenta }) => mapLines(message, x => `</p> ${magenta(x)}`),
+    "loggingEntry(time).loggingEntry.message": (message, { magenta }) => mapLines(message, x => `<t> ${magenta(x)}`),
+    "loggingEntry(group).loggingEntry.message": (message, { cyan }) => mapLines(message, x => `<-> ${cyan(x)}`),
+    "loggingEntry(groupCollapsed).loggingEntry.message": (message, { cyan }) => mapLines(message, x => `<+> ${cyan(x)}`),
+    "loggingEntry(clear).loggingEntry": () => "    -------",
+    "loggingEntry(groupCollapsed).loggingEntry.children": () => "",
+    "loggingEntry.trace[]": trace => trace ? mapLines(trace, x => `| ${x}`) : undefined,
+    "moduleTraceItem.originName": originName => originName,
+    loggingGroup: loggingGroup => loggingGroup.entries.length === 0 ? "" : undefined,
+    "loggingGroup.debug": (flag, { red }) => (flag ? red("DEBUG") : undefined),
+    "loggingGroup.name": (name, { bold }) => bold(`LOG from ${name}`),
+    "loggingGroup.separator!": () => "\n",
+    "loggingGroup.filteredEntries": filteredEntries => filteredEntries > 0 ? `+ ${filteredEntries} hidden lines` : undefined,
+    "moduleTraceDependency.loc": loc => loc
+};
+const ITEM_NAMES = {
+    "compilation.assets[]": "asset",
+    "compilation.modules[]": "module",
+    "compilation.chunks[]": "chunk",
+    "compilation.entrypoints[]": "chunkGroup",
+    "compilation.namedChunkGroups[]": "chunkGroup",
+    "compilation.errors[]": "error",
+    "compilation.warnings[]": "error",
+    "compilation.logging[]": "loggingGroup",
+    "compilation.children[]": "compilation",
+    "asset.related[]": "asset",
+    "asset.children[]": "asset",
+    "asset.chunks[]": "assetChunk",
+    "asset.auxiliaryChunks[]": "assetChunk",
+    "asset.chunkNames[]": "assetChunkName",
+    "asset.chunkIdHints[]": "assetChunkIdHint",
+    "asset.auxiliaryChunkNames[]": "assetChunkName",
+    "asset.auxiliaryChunkIdHints[]": "assetChunkIdHint",
+    "chunkGroup.assets[]": "chunkGroupAsset",
+    "chunkGroup.auxiliaryAssets[]": "chunkGroupAsset",
+    "chunkGroupChild.assets[]": "chunkGroupAsset",
+    "chunkGroupChild.auxiliaryAssets[]": "chunkGroupAsset",
+    "chunkGroup.children[]": "chunkGroupChildGroup",
+    "chunkGroupChildGroup.children[]": "chunkGroupChild",
+    "module.modules[]": "module",
+    "module.children[]": "module",
+    "module.reasons[]": "moduleReason",
+    "moduleReason.children[]": "moduleReason",
+    "module.issuerPath[]": "moduleIssuer",
+    "chunk.origins[]": "chunkOrigin",
+    "chunk.modules[]": "module",
+    "loggingGroup.entries[]": (logEntry) => `loggingEntry(${logEntry.type}).loggingEntry`,
+    "loggingEntry.children[]": (logEntry) => `loggingEntry(${logEntry.type}).loggingEntry`,
+    "error.moduleTrace[]": "moduleTraceItem",
+    "moduleTraceItem.dependencies[]": "moduleTraceDependency"
+};
+const ERROR_PREFERRED_ORDER = [
+    "compilerPath",
+    "chunkId",
+    "chunkEntry",
+    "chunkInitial",
+    "file",
+    "separator!",
+    "moduleName",
+    "loc",
+    "separator!",
+    "message",
+    "separator!",
+    "details",
+    "separator!",
+    "stack",
+    "separator!",
+    "missing",
+    "separator!",
+    "moduleTrace"
+];
+const PREFERRED_ORDERS = {
+    compilation: [
+        "name",
+        "hash",
+        "rspackVersion",
+        "time",
+        "builtAt",
+        "env",
+        "publicPath",
+        "assets",
+        "filteredAssets",
+        "entrypoints",
+        "namedChunkGroups",
+        "chunks",
+        "modules",
+        "filteredModules",
+        "children",
+        "logging",
+        "warnings",
+        "warningsInChildren!",
+        "filteredWarningDetailsCount",
+        "errors",
+        "errorsInChildren!",
+        "filteredErrorDetailsCount",
+        "summary!",
+        "needAdditionalPass"
+    ],
+    asset: [
+        "type",
+        "name",
+        "size",
+        "chunks",
+        "auxiliaryChunks",
+        "emitted",
+        "comparedForEmit",
+        "cached",
+        "info",
+        "isOverSizeLimit",
+        "chunkNames",
+        "auxiliaryChunkNames",
+        "chunkIdHints",
+        "auxiliaryChunkIdHints",
+        "related",
+        "filteredRelated",
+        "children",
+        "filteredChildren"
+    ],
+    "asset.info": [
+        "immutable",
+        "sourceFilename",
+        "javascriptModule",
+        "development",
+        "hotModuleReplacement"
+    ],
+    chunkGroup: [
+        "kind!",
+        "name",
+        "isOverSizeLimit",
+        "assetsSize",
+        "auxiliaryAssetsSize",
+        "is!",
+        "assets",
+        "filteredAssets",
+        "auxiliaryAssets",
+        "filteredAuxiliaryAssets",
+        "separator!",
+        "children"
+    ],
+    chunkGroupAsset: ["name", "size"],
+    chunkGroupChildGroup: ["type", "children"],
+    chunkGroupChild: ["assets", "chunks", "name"],
+    module: [
+        "type",
+        "name",
+        "identifier",
+        "id",
+        "layer",
+        "sizes",
+        "chunks",
+        "depth",
+        "cacheable",
+        "orphan",
+        "runtime",
+        "optional",
+        "dependent",
+        "built",
+        "codeGenerated",
+        "cached",
+        "assets",
+        "failed",
+        "warnings",
+        "errors",
+        "children",
+        "filteredChildren",
+        "providedExports",
+        "usedExports",
+        "optimizationBailout",
+        "reasons",
+        "filteredReasons",
+        "issuerPath",
+        "profile",
+        "modules",
+        "filteredModules"
+    ],
+    moduleReason: [
+        "active",
+        "type",
+        "userRequest",
+        "moduleId",
+        "module",
+        "resolvedModule",
+        "loc",
+        "explanation",
+        "children",
+        "filteredChildren"
+    ],
+    "module.profile": [
+        "total",
+        "separator!",
+        "resolving",
+        "restoring",
+        "integration",
+        "building",
+        "storing",
+        "additionalResolving",
+        "additionalIntegration"
+    ],
+    chunk: [
+        "id",
+        "runtime",
+        "files",
+        "names",
+        "idHints",
+        "sizes",
+        "parents",
+        "siblings",
+        "children",
+        "childrenByOrder",
+        "entry",
+        "initial",
+        "rendered",
+        "recorded",
+        "reason",
+        "separator!",
+        "origins",
+        "separator!",
+        "modules",
+        "separator!",
+        "filteredModules"
+    ],
+    chunkOrigin: ["request", "moduleId", "moduleName", "loc"],
+    error: ERROR_PREFERRED_ORDER,
+    warning: ERROR_PREFERRED_ORDER,
+    "chunk.childrenByOrder[]": ["type", "children"],
+    loggingGroup: [
+        "debug",
+        "name",
+        "separator!",
+        "entries",
+        "separator!",
+        "filteredEntries"
+    ],
+    loggingEntry: ["message", "trace", "children"]
+};
+const itemsJoinOneLine = (items) => items.filter(Boolean).join(" ");
+const itemsJoinOneLineBrackets = (items) => items.length > 0 ? `(${items.filter(Boolean).join(" ")})` : undefined;
+const itemsJoinMoreSpacing = (items) => items.filter(Boolean).join("\n\n");
+const itemsJoinComma = (items) => items.filter(Boolean).join(", ");
+const itemsJoinCommaBrackets = (items) => items.length > 0 ? `(${items.filter(Boolean).join(", ")})` : undefined;
+const itemsJoinCommaBracketsWithName = (name) => (items) => items.length > 0
+    ? `(${name}: ${items.filter(Boolean).join(", ")})`
+    : undefined;
+const SIMPLE_ITEMS_JOINER = {
+    "chunk.parents": itemsJoinOneLine,
+    "chunk.siblings": itemsJoinOneLine,
+    "chunk.children": itemsJoinOneLine,
+    "chunk.names": itemsJoinCommaBrackets,
+    "chunk.idHints": itemsJoinCommaBracketsWithName("id hint"),
+    "chunk.runtime": itemsJoinCommaBracketsWithName("runtime"),
+    "chunk.files": itemsJoinComma,
+    "chunk.childrenByOrder": itemsJoinOneLine,
+    "chunk.childrenByOrder[].children": itemsJoinOneLine,
+    "chunkGroup.assets": itemsJoinOneLine,
+    "chunkGroup.auxiliaryAssets": itemsJoinOneLineBrackets,
+    "chunkGroupChildGroup.children": itemsJoinComma,
+    "chunkGroupChild.assets": itemsJoinOneLine,
+    "chunkGroupChild.auxiliaryAssets": itemsJoinOneLineBrackets,
+    "asset.chunks": itemsJoinComma,
+    "asset.auxiliaryChunks": itemsJoinCommaBrackets,
+    "asset.chunkNames": itemsJoinCommaBracketsWithName("name"),
+    "asset.auxiliaryChunkNames": itemsJoinCommaBracketsWithName("auxiliary name"),
+    "asset.chunkIdHints": itemsJoinCommaBracketsWithName("id hint"),
+    "asset.auxiliaryChunkIdHints": itemsJoinCommaBracketsWithName("auxiliary id hint"),
+    "module.chunks": itemsJoinOneLine,
+    "module.issuerPath": items => items
+        .filter(Boolean)
+        .map(item => `${item} ->`)
+        .join(" "),
+    "compilation.errors": itemsJoinMoreSpacing,
+    "compilation.warnings": itemsJoinMoreSpacing,
+    "compilation.logging": itemsJoinMoreSpacing,
+    "compilation.children": items => indent(itemsJoinMoreSpacing(items), "  "),
+    "moduleTraceItem.dependencies": itemsJoinOneLine,
+    "loggingEntry.children": items => indent(items.filter(Boolean).join("\n"), "  ", false)
+};
+const joinOneLine = (items) => items
+    .map(item => item.content)
+    .filter(Boolean)
+    .join(" ");
+const joinInBrackets = (items) => {
+    const res = [];
+    let mode = 0;
+    for (const item of items) {
+        if (item.element === "separator!") {
+            switch (mode) {
+                case 0:
+                case 1:
+                    mode += 2;
+                    break;
+                case 4:
+                    res.push(")");
+                    mode = 3;
+                    break;
+            }
+        }
+        if (!item.content)
+            continue;
+        switch (mode) {
+            case 0:
+                mode = 1;
+                break;
+            case 1:
+                res.push(" ");
+                break;
+            case 2:
+                res.push("(");
+                mode = 4;
+                break;
+            case 3:
+                res.push(" (");
+                mode = 4;
+                break;
+            case 4:
+                res.push(", ");
+                break;
+        }
+        res.push(item.content);
+    }
+    if (mode === 4)
+        res.push(")");
+    return res.join("");
+};
+const indent = (str, prefix, noPrefixInFirstLine) => {
+    const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+    if (noPrefixInFirstLine)
+        return rem;
+    const ind = str[0] === "\n" ? "" : prefix;
+    return ind + rem;
+};
+const joinExplicitNewLine = (items, indenter) => {
+    let firstInLine = true;
+    let first = true;
+    return items
+        .map(item => {
+        if (!item || !item.content)
+            return;
+        let content = indent(item.content, first ? "" : indenter, !firstInLine);
+        if (firstInLine) {
+            content = content.replace(/^\n+/, "");
+        }
+        if (!content)
+            return;
+        first = false;
+        const noJoiner = firstInLine || content.startsWith("\n");
+        firstInLine = content.endsWith("\n");
+        return noJoiner ? content : " " + content;
+    })
+        .filter(Boolean)
+        .join("")
+        .trim();
+};
+const joinError = error => (items, { red, yellow }) => `${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(items, "")}`;
+const SIMPLE_ELEMENT_JOINERS = {
+    compilation: items => {
+        const result = [];
+        let lastNeedMore = false;
+        for (const item of items) {
+            if (!item.content)
+                continue;
+            const needMoreSpace = [
+                "warnings",
+                "filteredWarningDetailsCount",
+                "errors",
+                "filteredErrorDetailsCount",
+                "logging"
+            ].includes(item.element);
+            if (result.length !== 0) {
+                result.push(needMoreSpace || lastNeedMore ? "\n\n" : "\n");
+            }
+            result.push(item.content);
+            lastNeedMore = needMoreSpace;
+        }
+        if (lastNeedMore)
+            result.push("\n");
+        return result.join("");
+    },
+    asset: items => joinExplicitNewLine(items.map(item => {
+        if ((item.element === "related" || item.element === "children") &&
+            item.content) {
+            return {
+                ...item,
+                content: `\n${item.content}\n`
+            };
+        }
+        return item;
+    }), "  "),
+    "asset.info": joinOneLine,
+    module: (items, { module }) => {
+        let hasName = false;
+        return joinExplicitNewLine(items.map(item => {
+            switch (item.element) {
+                case "id":
+                    if (module && module.id === module.name) {
+                        if (hasName)
+                            return false;
+                        if (item.content)
+                            hasName = true;
+                    }
+                    break;
+                case "name":
+                    if (hasName)
+                        return false;
+                    if (item.content)
+                        hasName = true;
+                    break;
+                case "providedExports":
+                case "usedExports":
+                case "optimizationBailout":
+                case "reasons":
+                case "issuerPath":
+                case "profile":
+                case "children":
+                case "modules":
+                    if (item.content) {
+                        return {
+                            ...item,
+                            content: `\n${item.content}\n`
+                        };
+                    }
+                    break;
+            }
+            return item;
+        }), "  ");
+    },
+    chunk: items => {
+        let hasEntry = false;
+        return ("chunk " +
+            joinExplicitNewLine(items.filter(item => {
+                switch (item.element) {
+                    case "entry":
+                        if (item.content)
+                            hasEntry = true;
+                        break;
+                    case "initial":
+                        if (hasEntry)
+                            return false;
+                        break;
+                }
+                return true;
+            }), "  "));
+    },
+    "chunk.childrenByOrder[]": items => `(${joinOneLine(items)})`,
+    chunkGroup: items => joinExplicitNewLine(items, "  "),
+    chunkGroupAsset: joinOneLine,
+    chunkGroupChildGroup: joinOneLine,
+    chunkGroupChild: joinOneLine,
+    moduleReason: (items, { moduleReason }) => {
+        let hasName = false;
+        return joinExplicitNewLine(items.map(item => {
+            switch (item.element) {
+                case "moduleId":
+                    if (moduleReason &&
+                        moduleReason.moduleId === moduleReason.module &&
+                        item.content)
+                        hasName = true;
+                    break;
+                case "module":
+                    if (hasName)
+                        return false;
+                    break;
+                case "resolvedModule":
+                    if (moduleReason &&
+                        moduleReason.module === moduleReason.resolvedModule)
+                        return false;
+                    break;
+                case "children":
+                    if (item.content) {
+                        return {
+                            ...item,
+                            content: `\n${item.content}\n`
+                        };
+                    }
+                    break;
+            }
+            return item;
+        }), "  ");
+    },
+    "module.profile": joinInBrackets,
+    moduleIssuer: joinOneLine,
+    chunkOrigin: items => "> " + joinOneLine(items),
+    "errors[].error": joinError(true),
+    "warnings[].error": joinError(false),
+    loggingGroup: items => joinExplicitNewLine(items, "").trimEnd(),
+    moduleTraceItem: items => " @ " + joinOneLine(items),
+    moduleTraceDependency: joinOneLine
+};
+const AVAILABLE_COLORS = {
+    bold: "\u001b[1m",
+    yellow: "\u001b[1m\u001b[33m",
+    red: "\u001b[1m\u001b[31m",
+    green: "\u001b[1m\u001b[32m",
+    cyan: "\u001b[1m\u001b[36m",
+    magenta: "\u001b[1m\u001b[35m"
+};
+const AVAILABLE_FORMATS = {
+    formatChunkId: (id, { yellow }, direction) => {
+        switch (direction) {
+            case "parent":
+                return `<{${yellow(id)}}>`;
+            case "sibling":
+                return `={${yellow(id)}}=`;
+            case "child":
+                return `>{${yellow(id)}}<`;
+            default:
+                return `{${yellow(id)}}`;
+        }
+    },
+    formatModuleId: id => `[${id}]`,
+    formatFilename: (filename, { green, yellow }, oversize) => (oversize ? yellow : green)(filename),
+    formatFlag: (flag) => `[${flag}]`,
+    formatLayer: layer => `(in ${layer})`,
+    formatSize: SizeFormatHelpers_1.formatSize,
+    formatDateTime: (dateTime, { bold }) => {
+        const d = new Date(dateTime);
+        const x = twoDigit;
+        const date = `${d.getFullYear()}-${x(d.getMonth() + 1)}-${x(d.getDate())}`;
+        const time = `${x(d.getHours())}:${x(d.getMinutes())}:${x(d.getSeconds())}`;
+        return `${date} ${bold(time)}`;
+    },
+    formatTime: (time, { timeReference, bold, green, yellow, red }, boldQuantity) => {
+        const unit = " ms";
+        if (timeReference && time !== timeReference) {
+            const times = [
+                timeReference / 2,
+                timeReference / 4,
+                timeReference / 8,
+                timeReference / 16
+            ];
+            if (time < times[3])
+                return `${time}${unit}`;
+            else if (time < times[2])
+                return bold(`${time}${unit}`);
+            else if (time < times[1])
+                return green(`${time}${unit}`);
+            else if (time < times[0])
+                return yellow(`${time}${unit}`);
+            else
+                return red(`${time}${unit}`);
+        }
+        else {
+            return `${boldQuantity ? bold(time.toString()) : time}${unit}`;
+        }
+    },
+    formatError: (msg, { green, yellow, red }) => {
+        let message = msg;
+        if (message.includes("\u001b["))
+            return message;
+        const highlights = [
+            { regExp: /(Did you mean .+)/g, format: green },
+            {
+                regExp: /(Set 'mode' option to 'development' or 'production')/g,
+                format: green
+            },
+            { regExp: /(\(module has no exports\))/g, format: red },
+            { regExp: /\(possible exports: (.+)\)/g, format: green },
+            { regExp: /(?:^|\n)(.* doesn't exist)/g, format: red },
+            { regExp: /('\w+' option has not been set)/g, format: red },
+            {
+                regExp: /(Emitted value instead of an instance of Error)/g,
+                format: yellow
+            },
+            { regExp: /(Used? .+ instead)/gi, format: yellow },
+            { regExp: /\b(deprecated|must|required)\b/g, format: yellow },
+            {
+                regExp: /\b(BREAKING CHANGE)\b/gi,
+                format: red
+            },
+            {
+                regExp: /\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
+                format: red
+            }
+        ];
+        for (const { regExp, format } of highlights) {
+            message = message.replace(regExp, (match, content) => {
+                return match.replace(content, format(content));
+            });
+        }
+        return message;
+    }
+};
+const RESULT_MODIFIER = {
+    "module.modules": (result) => {
+        return indent(result, "| ");
+    }
+};
+const createOrder = (array, preferredOrder) => {
+    const originalArray = array.slice();
+    const set = new Set(array);
+    const usedSet = new Set();
+    array.length = 0;
+    for (const element of preferredOrder) {
+        if (element.endsWith("!") || set.has(element)) {
+            array.push(element);
+            usedSet.add(element);
+        }
+    }
+    for (const element of originalArray) {
+        if (!usedSet.has(element)) {
+            array.push(element);
+        }
+    }
+    return array;
+};
+class DefaultStatsPrinterPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap("DefaultStatsPrinterPlugin", compilation => {
+            compilation.hooks.statsPrinter.tap("DefaultStatsPrinterPlugin", (stats, options) => {
+                // Put colors into context
+                stats.hooks.print.for("compilation").tap("DefaultStatsPrinterPlugin", 
+                // @ts-expect-error
+                (compilation, context) => {
+                    for (const color of Object.keys(AVAILABLE_COLORS)) {
+                        let start;
+                        if (options.colors) {
+                            if (typeof options.colors === "object" &&
+                                typeof options.colors[color] === "string") {
+                                start = options.colors[color];
+                            }
+                            else {
+                                // @ts-expect-error
+                                start = AVAILABLE_COLORS[color];
+                            }
+                        }
+                        if (start) {
+                            context[color] = (str) => `${start}${typeof str === "string"
+                                ? str.replace(/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g, `$1${start}`)
+                                : str}\u001b[39m\u001b[22m`;
+                        }
+                        else {
+                            context[color] = (str) => str;
+                        }
+                    }
+                    for (const format of Object.keys(AVAILABLE_FORMATS)) {
+                        // @ts-ignore
+                        context[format] = (content, ...args) => 
+                        // @ts-ignore
+                        AVAILABLE_FORMATS[format](content, context, ...args);
+                    }
+                    context.timeReference = compilation.time;
+                });
+                for (const key of Object.keys(SIMPLE_PRINTERS)) {
+                    stats.hooks.print
+                        .for(key)
+                        .tap("DefaultStatsPrinterPlugin", (obj, ctx) => 
+                    // @ts-expect-error
+                    SIMPLE_PRINTERS[key](obj, ctx, stats));
+                }
+                for (const key of Object.keys(PREFERRED_ORDERS)) {
+                    const preferredOrder = PREFERRED_ORDERS[key];
+                    stats.hooks.sortElements
+                        .for(key)
+                        .tap("DefaultStatsPrinterPlugin", elements => {
+                        createOrder(elements, preferredOrder);
+                    });
+                }
+                for (const key of Object.keys(ITEM_NAMES)) {
+                    const itemName = ITEM_NAMES[key];
+                    stats.hooks.getItemName
+                        .for(key)
+                        .tap("DefaultStatsPrinterPlugin", typeof itemName === "string" ? () => itemName : itemName);
+                }
+                for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
+                    const joiner = SIMPLE_ITEMS_JOINER[key];
+                    stats.hooks.printItems
+                        .for(key)
+                        // @ts-expect-error
+                        .tap("DefaultStatsPrinterPlugin", joiner);
+                }
+                for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
+                    const joiner = SIMPLE_ELEMENT_JOINERS[key];
+                    stats.hooks.printElements
+                        .for(key)
+                        // @ts-expect-error
+                        .tap("DefaultStatsPrinterPlugin", joiner);
+                }
+                for (const key of Object.keys(RESULT_MODIFIER)) {
+                    const modifier = RESULT_MODIFIER[key];
+                    stats.hooks.result
+                        .for(key)
+                        .tap("DefaultStatsPrinterPlugin", modifier);
+                }
+            });
+        });
+    }
+}
+exports.DefaultStatsPrinterPlugin = DefaultStatsPrinterPlugin;
+//# sourceMappingURL=DefaultStatsPrinterPlugin.js.map