@rspack/core 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/stats/DefaultStatsPrinterPlugin.js

@@ -206,7 +206,7 @@ const SIMPLE_PRINTERS = {
     "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
+    "module.assets": (assets, { formatFlag, magenta }) => assets?.length
         ? magenta(formatFlag(`${assets.length} ${plural(assets.length, "asset", "assets")}`))
         : undefined,
     "module.warnings": (warnings, { formatFlag, yellow }) => warnings === true
@@ -700,7 +700,7 @@ const joinInBrackets = (items) => {
     return res.join("");
 };
 const indent = (str, prefix, noPrefixInFirstLine) => {
-    const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+    const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
     if (noPrefixInFirstLine)
         return rem;
     const ind = str[0] === "\n" ? "" : prefix;
@@ -722,7 +722,7 @@ const joinExplicitNewLine = (items, indenter) => {
         first = false;
         const noJoiner = firstInLine || content.startsWith("\n");
         firstInLine = content.endsWith("\n");
-        return noJoiner ? content : " " + content;
+        return noJoiner ? content : ` ${content}`;
     })
         .filter(Boolean)
         .join("")
@@ -803,20 +803,19 @@ const SIMPLE_ELEMENT_JOINERS = {
     },
     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;
-            }), "  "));
+        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, "  "),
@@ -856,11 +855,11 @@ const SIMPLE_ELEMENT_JOINERS = {
     },
     "module.profile": joinInBrackets,
     moduleIssuer: joinOneLine,
-    chunkOrigin: items => "> " + joinOneLine(items),
+    chunkOrigin: items => `> ${joinOneLine(items)}`,
     "errors[].error": joinError(true),
     "warnings[].error": joinError(false),
     loggingGroup: items => joinExplicitNewLine(items, "").trimEnd(),
-    moduleTraceItem: items => " @ " + joinOneLine(items),
+    moduleTraceItem: items => ` @ ${joinOneLine(items)}`,
     moduleTraceDependency: joinOneLine
 };
 const AVAILABLE_COLORS = {

package/dist/stats/StatsFactory.d.ts

@@ -7,7 +7,7 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import type { JsStats, JsStatsError, JsStatsWarning } from "@rspack/binding";
+import type { JsStats, JsStatsCompilation, JsStatsError, JsStatsWarning } from "@rspack/binding";
 import { HookMap, SyncBailHook, SyncWaterfallHook } from "@rspack/lite-tapable";
 import type { Compilation } from "../Compilation";
 import { type GroupConfig } from "../util/smartGrouping";
@@ -17,6 +17,7 @@ export type KnownStatsFactoryContext = {
     compilation?: Compilation | undefined;
     cachedGetErrors?: ((arg0: Compilation) => JsStatsError[]) | undefined;
     cachedGetWarnings?: ((arg0: Compilation) => JsStatsWarning[]) | undefined;
+    getStatsCompilation: (compilation: Compilation) => JsStatsCompilation;
     getInner: (compilation: Compilation) => JsStats;
 };
 export type StatsFactoryContext = KnownStatsFactoryContext & Record<string, any>;

package/dist/stats/StatsFactory.js

@@ -71,10 +71,9 @@ class StatsFactory {
         }
     }
     _forEachLevelWaterfall(hookMap, cache, type, data, fn) {
-        for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-            data = fn(hook, data);
-        }
-        return data;
+        return this._getAllLevelHooks(hookMap, cache, type).reduce((data, hook) => {
+            return fn(hook, data);
+        }, data);
     }
     _forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
         const hooks = this._getAllLevelHooks(hookMap, cache, type);
@@ -121,9 +120,7 @@ class StatsFactory {
             const comparators = [];
             this._forEachLevel(this.hooks.sort, this._caches.sort, type, h => h.call(comparators, context));
             if (comparators.length > 0) {
-                items.sort(
-                // @ts-expect-error number of arguments is correct
-                (0, comparators_1.concatComparators)(...comparators));
+                items.sort((0, comparators_1.concatComparators)(...comparators));
             }
             // run filter on sorted items
             const items2 = this._forEachLevelFilter(this.hooks.filterSorted, this._caches.filterSorted, type, items, (h, r, idx, i) => h.call(r, context, idx, i), false);
@@ -147,9 +144,7 @@ class StatsFactory {
             const comparators2 = [];
             this._forEachLevel(this.hooks.sortResults, this._caches.sortResults, type, h => h.call(comparators2, context));
             if (comparators2.length > 0) {
-                resultItems.sort(
-                // @ts-expect-error number of arguments is correct
-                (0, comparators_1.concatComparators)(...comparators2));
+                resultItems.sort((0, comparators_1.concatComparators)(...comparators2));
             }
             // group result items
             const groupConfigs = [];

package/dist/stats/StatsPrinter.js

@@ -71,10 +71,9 @@ class StatsPrinter {
         }
     }
     _forEachLevelWaterfall(hookMap, type, data, fn) {
-        for (const hook of this._getAllLevelHooks(hookMap, type)) {
-            data = fn(hook, data);
-        }
-        return data;
+        return this._getAllLevelHooks(hookMap, type).reduce((data, hook) => {
+            return fn(hook, data);
+        }, data);
     }
     print(type, object, baseContext) {
         if (this._inPrint) {

package/dist/stats/statsFactoryUtils.d.ts

@@ -1,27 +1,126 @@
+/// <reference types="node" />
 import type * as binding from "@rspack/binding";
 import type { Compilation, NormalizedStatsOptions } from "../Compilation";
 import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
-type Writable<T> = {
-    -readonly [K in keyof T]: T[K];
+export type KnownStatsChunkGroup = {
+    name?: string;
+    chunks?: (string | number)[];
+    assets?: {
+        name: string;
+        size?: number;
+    }[];
+    filteredAssets?: number;
+    assetsSize?: number;
+    auxiliaryAssets?: {
+        name: string;
+        size?: number;
+    }[];
+    filteredAuxiliaryAssets?: number;
+    auxiliaryAssetsSize?: number;
+    children?: {
+        preload?: StatsChunkGroup[];
+        prefetch?: StatsChunkGroup[];
+    };
+    childAssets?: {
+        [index: string]: string[];
+    };
 };
-export type KnownStatsChunkGroup = binding.JsStatsChunkGroup;
-export type KnownStatsChunk = Omit<Writable<binding.JsStatsChunk>, "sizes"> & {
-    sizes: Record<string, number>;
+export type KnownStatsChunk = {
+    type: string;
+    rendered: boolean;
+    initial: boolean;
+    entry: boolean;
+    reason?: string;
+    size: number;
+    sizes?: Record<string, number>;
+    names?: string[];
+    idHints?: string[];
+    runtime?: string[];
+    files?: string[];
+    auxiliaryFiles?: string[];
+    hash?: string;
+    childrenByOrder?: Record<string, (string | number)[]>;
+    id?: string | number;
+    siblings?: (string | number)[];
+    parents?: (string | number)[];
+    children?: (string | number)[];
+    modules?: StatsModule[];
+    filteredModules?: number;
+    origins?: StatsChunkOrigin[];
+};
+export type KnownAssetInfo = {
+    immutable?: boolean;
+    minimized?: boolean;
+    fullhash?: string | string[];
+    chunkhash?: string | string[];
+    contenthash?: string | string[];
+    sourceFilename?: string;
+    size?: number;
+    development?: boolean;
+    hotModuleReplacement?: boolean;
+    javascriptModule?: boolean;
+    related?: Record<string, string | string[]>;
+};
+export type AssetInfo = KnownAssetInfo & Record<string, any>;
+export type StatsChunkGroup = KnownStatsChunkGroup & Record<string, any>;
+export type KnownStatsAsset = {
+    type: string;
+    name: string;
+    info: AssetInfo;
+    size: number;
+    emitted: boolean;
+    chunkNames?: (string | number)[];
+    chunkIdHints?: (string | number)[];
+    chunks?: (string | null | undefined)[];
+    auxiliaryChunkNames?: (string | number)[];
+    auxiliaryChunks?: (string | null | undefined)[];
+    auxiliaryChunkIdHints?: (string | number)[];
+    filteredRelated?: number;
+    isOverSizeLimit?: boolean;
 };
-export type KnownStatsAssetInfo = Omit<binding.JsStatsAssetInfo, "related">;
-export type StatsChunkGroup = binding.JsStatsChunkGroup & Record<string, any>;
-export type KnownStatsAsset = Omit<binding.JsStatsAsset, "info">;
 export type StatsAsset = KnownStatsAsset & Record<string, any>;
 export type StatsChunk = KnownStatsChunk & Record<string, any>;
-export type KnownStatsModule = Omit<Writable<binding.JsStatsModule>, "usedExports" | "providedExports" | "optimizationBailout" | "sizes"> & {
-    profile?: StatsProfile;
-    usedExports?: null | string[] | boolean;
-    providedExports?: null | string[];
-    optimizationBailout?: null | string[];
-    sizes: Record<string, number>;
+export type KnownStatsModule = {
+    type: string;
+    moduleType: string;
+    layer?: string;
+    identifier?: string;
+    name?: string;
+    nameForCondition?: string;
     index?: number;
     index2?: number;
+    preOrderIndex?: number;
+    postOrderIndex?: number;
+    size: number;
+    sizes: Record<string, number>;
+    cacheable?: boolean;
+    built: boolean;
+    codeGenerated: boolean;
+    buildTimeExecuted: boolean;
+    cached: boolean;
+    optional?: boolean;
+    orphan?: boolean;
+    id?: string;
+    issuerId?: string;
+    chunks?: string[];
+    assets?: string[];
+    dependent?: boolean;
+    issuer?: string;
+    issuerName?: string;
+    issuerPath?: StatsModuleIssuer[];
+    failed?: boolean;
+    errors?: number;
+    warnings?: number;
+    profile?: StatsProfile;
+    reasons?: StatsModuleReason[];
+    usedExports?: boolean | string[] | null;
+    providedExports?: string[] | null;
+    optimizationBailout?: string[] | null;
+    depth?: number;
+    modules?: StatsModule[];
+    filteredModules?: number;
+    source?: string | Buffer;
 };
 export type StatsProfile = KnownStatsProfile & Record<string, any>;
 export type KnownStatsProfile = {
@@ -30,9 +129,28 @@ export type KnownStatsProfile = {
     building: number;
 };
 export type StatsModule = KnownStatsModule & Record<string, any>;
-export type StatsModuleIssuer = binding.JsStatsModuleIssuer & Record<string, any>;
-export type StatsError = binding.JsStatsError & Record<string, any>;
-export type StatsWarnings = binding.JsStatsWarning & Record<string, any>;
+export type KnownStatsModuleIssuer = {
+    identifier?: string;
+    name?: string;
+    id?: string | number;
+};
+export type StatsModuleIssuer = KnownStatsModuleIssuer & Record<string, any>;
+export type KnownStatsError = {
+    message: string;
+    chunkName?: string;
+    chunkEntry?: boolean;
+    chunkInitial?: boolean;
+    file?: string;
+    moduleIdentifier?: string;
+    moduleName?: string;
+    loc?: string;
+    chunkId?: string | number;
+    moduleId?: string | number;
+    moduleTrace?: StatsModuleTraceItem[];
+    details?: any;
+    stack?: string;
+};
+export type StatsError = KnownStatsError & Record<string, any>;
 export type StatsModuleTraceItem = {
     originIdentifier?: string;
     originName?: string;
@@ -41,7 +159,24 @@ export type StatsModuleTraceItem = {
     originId?: string;
     moduleId?: string;
 };
-export type StatsModuleReason = Writable<binding.JsStatsModuleReason> & Record<string, any>;
+export type KnownStatsModuleReason = {
+    moduleIdentifier?: string;
+    module?: string;
+    moduleName?: string;
+    type?: string;
+    userRequest?: string;
+    moduleId?: string | null;
+};
+export type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
+export type KnownStatsChunkOrigin = {
+    module: string;
+    moduleIdentifier: string;
+    moduleName: string;
+    loc: string;
+    request: string;
+    moduleId?: string;
+};
+export type StatsChunkOrigin = KnownStatsChunkOrigin & Record<string, any>;
 export type KnownStatsCompilation = {
     /**
      * webpack version.
@@ -64,7 +199,7 @@ export type KnownStatsCompilation = {
     namedChunkGroups?: Record<string, StatsChunkGroup>;
     errors?: StatsError[];
     errorsCount?: number;
-    warnings?: StatsWarnings[];
+    warnings?: StatsError[];
     warningsCount?: number;
     filteredModules?: number;
     children?: StatsCompilation[];
@@ -86,18 +221,10 @@ export type KnownStatsLoggingEntry = {
     args?: any[] | undefined;
     time?: number | undefined;
 };
-export type KnownStatsChunkOrigin = {
-    module?: string | undefined;
-    moduleIdentifier?: string | undefined;
-    moduleName?: string | undefined;
-    loc?: string | undefined;
-    request?: string | undefined;
-    moduleId?: (string | number) | undefined;
-};
 type ExtractorsByOption<T, O> = {
     [x: string]: (object: O, data: T, context: StatsFactoryContext, options: any, factory: StatsFactory) => void;
 };
-export type PreprocessedAsset = StatsAsset & {
+export type PreprocessedAsset = binding.JsStatsAsset & {
     type: string;
     related: PreprocessedAsset[];
     info: binding.JsStatsAssetInfo;

package/dist/util/SizeFormatHelpers.js

@@ -19,6 +19,6 @@ const formatSize = (size) => {
     }
     const abbreviations = ["bytes", "KiB", "MiB", "GiB"];
     const index = Math.floor(Math.log(size) / Math.log(1024));
-    return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${abbreviations[index]}`;
+    return `${+(size / 1024 ** index).toPrecision(3)} ${abbreviations[index]}`;
 };
 exports.formatSize = formatSize;

package/dist/util/assertNotNil.d.ts

@@ -1 +1 @@
-export declare function assertNotNill(value: any): asserts value;
+export declare function assertNotNill(value: unknown): asserts value;

package/dist/util/assetCondition.d.ts

@@ -0,0 +1,2 @@
+export type AssetCondition = string | RegExp;
+export type AssetConditions = AssetCondition | AssetCondition[];

package/dist/util/assetCondition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/bindingVersionCheck.js

@@ -64,12 +64,12 @@ const getAddonPlatformArchAbi = () => {
     const abi = NodePlatformArchToAbi[platform][arch];
     if (abi === undefined)
         return new Error(`unsupported cpu arch: ${arch}`);
-    binding += "-" + arch;
+    binding += `-${arch}`;
     if (typeof abi === "string") {
-        binding += abi.length ? "-" + abi : "";
+        binding += abi.length ? `-${abi}` : "";
     }
     else if (typeof abi === "object") {
-        binding += "-" + abi[isMusl() ? "musl" : "gnu"];
+        binding += `-${abi[isMusl() ? "musl" : "gnu"]}`;
     }
     else {
         return new Error(`unsupported abi: ${abi}`);

package/dist/util/cleverMerge.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveByProperty = exports.removeOperations = exports.cleverMerge = exports.cachedSetProperty = exports.cachedCleverMerge = exports.DELETE = void 0;
+const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 const mergeCache = new WeakMap();
 const setPropertyCache = new WeakMap();
 exports.DELETE = Symbol("DELETE");
-const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 /**
  * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
  * @example
@@ -247,11 +247,12 @@ const _cleverMerge = (first, second, internalCaching = false) => {
         : parseObject(first);
     const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
     // If the first argument has a dynamic part we modify the dynamic part to merge the second argument
+    let secondObj = second;
     if (firstDynamicInfo !== undefined) {
         let { byProperty, fn } = firstDynamicInfo;
         const fnInfo = fn[DYNAMIC_INFO];
         if (fnInfo) {
-            second = internalCaching
+            secondObj = internalCaching
                 ? (0, exports.cachedCleverMerge)(fnInfo[1], second)
                 : (0, exports.cleverMerge)(fnInfo[1], second);
             fn = fnInfo[0];
@@ -259,10 +260,10 @@ const _cleverMerge = (first, second, internalCaching = false) => {
         const newFn = (...args) => {
             const fnResult = fn(...args);
             return internalCaching
-                ? (0, exports.cachedCleverMerge)(fnResult, second)
-                : (0, exports.cleverMerge)(fnResult, second);
+                ? (0, exports.cachedCleverMerge)(fnResult, secondObj)
+                : (0, exports.cleverMerge)(fnResult, secondObj);
         };
-        newFn[DYNAMIC_INFO] = [fn, second];
+        newFn[DYNAMIC_INFO] = [fn, secondObj];
         return serializeObject(firstObject.static, { byProperty, fn: newFn });
     }
     // If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
@@ -299,7 +300,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
             // second value override everything
             // = second.base + second.byProperty
             return secondEntry;
-        case VALUE_TYPE_UNDEFINED:
+        case VALUE_TYPE_UNDEFINED: {
             if (!firstEntry.byProperty) {
                 // = first.base + second.byProperty
                 return {
@@ -323,6 +324,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
                 byProperty: firstEntry.byProperty,
                 byValues: newByValues
             };
+        }
         default: {
             if (!firstEntry.byProperty) {
                 // The simple case

package/dist/util/comparators.d.ts

@@ -11,7 +11,7 @@ import type { JsStatsChunk as Chunk } from "@rspack/binding";
 import type { ChunkGroup } from "../ChunkGroup";
 export type Comparator = <T>(arg0: T, arg1: T) => -1 | 0 | 1;
 type Selector<A, B> = (input: A) => B;
-export declare const concatComparators: (c1: Comparator, c2: Comparator, ...cRest: Comparator[]) => Comparator;
+export declare const concatComparators: (...comps: Array<Comparator>) => Comparator;
 export declare const compareIds: (a: string | number, b: string | number) => -1 | 0 | 1;
 export declare const compareChunksById: (a: Chunk, b: Chunk) => -1 | 0 | 1;
 export declare const compareChunkGroupsByIndex: (a: ChunkGroup, b: ChunkGroup) => -1 | 0 | 1;

package/dist/util/comparators.js

@@ -31,14 +31,15 @@ class TwoKeyWeakMap {
     }
 }
 const concatComparatorsCache = new TwoKeyWeakMap();
-const concatComparators = (c1, c2, ...cRest) => {
+const concatComparators = (...comps) => {
+    const [c1, c2, ...cRest] = comps;
+    if (c2 === undefined) {
+        return c1;
+    }
     if (cRest.length > 0) {
         const [c3, ...cRest2] = cRest;
         return (0, exports.concatComparators)(c1, (0, exports.concatComparators)(c2, c3, ...cRest2));
     }
-    if (c2 === undefined) {
-        return c1;
-    }
     const cacheEntry = concatComparatorsCache.get(c1, c2);
     if (cacheEntry !== undefined)
         return cacheEntry;

package/dist/util/createHash.js

@@ -113,12 +113,17 @@ class DebugHash extends hash_1.default {
      * @returns updated hash
      */
     update(data, _inputEncoding) {
-        if (typeof data !== "string")
-            data = data.toString("utf-8");
-        if (data.startsWith("debug-digest-")) {
-            data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
+        let normalizedData;
+        if (typeof data !== "string") {
+            normalizedData = data.toString("utf-8");
         }
-        this.string += `[${data}](${new Error().stack?.split("\n", 3)[2]})\n`;
+        else {
+            normalizedData = data;
+        }
+        if (normalizedData.startsWith("debug-digest-")) {
+            normalizedData = Buffer.from(normalizedData.slice("debug-digest-".length), "hex").toString();
+        }
+        this.string += `[${normalizedData}](${new Error().stack?.split("\n", 3)[2]})\n`;
         return this;
     }
     /**
@@ -127,7 +132,7 @@ class DebugHash extends hash_1.default {
      * @returns digest
      */
     digest(encoding) {
-        return ("debug-digest-" + Buffer.from(this.string).toString(encoding || "hex"));
+        return `debug-digest-${Buffer.from(this.string).toString(encoding || "hex")}`;
     }
 }
 /**

package/dist/util/fs.js

@@ -56,7 +56,7 @@ function rmrf(fs, p, callback) {
 }
 exports.rmrf = rmrf;
 const join = (fs, rootPath, filename) => {
-    if (fs && fs.join) {
+    if (fs?.join) {
         return fs.join(rootPath, filename);
     }
     if (node_path_1.default.posix.isAbsolute(rootPath)) {
@@ -68,7 +68,7 @@ const join = (fs, rootPath, filename) => {
     throw new Error(`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`);
 };
 const dirname = (fs, absPath) => {
-    if (fs && fs.dirname) {
+    if (fs?.dirname) {
         return fs.dirname(absPath);
     }
     if (node_path_1.default.posix.isAbsolute(absPath)) {

package/dist/util/hash/wasm-hash.js

@@ -43,11 +43,12 @@ class WasmHash {
      */
     update(data, encoding) {
         if (typeof data === "string") {
-            while (data.length > exports.MAX_SHORT_STRING) {
-                this._updateWithShortString(data.slice(0, exports.MAX_SHORT_STRING), encoding);
-                data = data.slice(exports.MAX_SHORT_STRING);
+            let normalizedData = data;
+            while (normalizedData.length > exports.MAX_SHORT_STRING) {
+                this._updateWithShortString(normalizedData.slice(0, exports.MAX_SHORT_STRING), encoding);
+                normalizedData = normalizedData.slice(exports.MAX_SHORT_STRING);
             }
-            this._updateWithShortString(data, encoding);
+            this._updateWithShortString(normalizedData, encoding);
             return this;
         }
         this._updateWithBuffer(data);

package/dist/util/identifier.d.ts

@@ -70,10 +70,10 @@ export declare const parseResourceWithoutFragment: {
     bindCache(associatedObjectForCache: object): (str: string) => ParsedResourceWithoutFragment;
 };
 /**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ * @param filename the filename which should be undone
+ * @param outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param enforceRelative true returns ./ for empty paths
+ * @returns repeated ../ to leave the directory of the provided filename to be back on output dir
  */
 export declare const getUndoPath: (filename: string, outputPath: string, enforceRelative: boolean) => string;
 export {};

package/dist/util/identifier.js

@@ -293,28 +293,28 @@ const _parseResourceWithoutFragment = (str) => {
 };
 exports.parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragment);
 /**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ * @param filename the filename which should be undone
+ * @param outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param enforceRelative true returns ./ for empty paths
+ * @returns repeated ../ to leave the directory of the provided filename to be back on output dir
  */
 const getUndoPath = (filename, outputPath, enforceRelative) => {
     let depth = -1;
     let append = "";
-    outputPath = outputPath.replace(/[\\/]$/, "");
+    let path = outputPath.replace(/[\\/]$/, "");
     for (const part of filename.split(/[/\\]+/)) {
         if (part === "..") {
             if (depth > -1) {
                 depth--;
             }
             else {
-                const i = outputPath.lastIndexOf("/");
-                const j = outputPath.lastIndexOf("\\");
+                const i = path.lastIndexOf("/");
+                const j = path.lastIndexOf("\\");
                 const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
                 if (pos < 0)
-                    return outputPath + "/";
-                append = outputPath.slice(pos + 1) + "/" + append;
-                outputPath = outputPath.slice(0, pos);
+                    return `${path}/`;
+                append = `${path.slice(pos + 1)}/${append}`;
+                path = path.slice(0, pos);
             }
         }
         else if (part !== ".") {

package/dist/util/index.js

@@ -73,7 +73,7 @@ function concatErrorMsgAndStack(err) {
 }
 exports.concatErrorMsgAndStack = concatErrorMsgAndStack;
 function indent(str, prefix) {
-    const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+    const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
     return prefix + rem;
 }
 exports.indent = indent;

package/dist/util/memoize.js

@@ -3,19 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.memoizeValue = exports.memoizeFn = exports.memoize = void 0;
 const memoize = (fn) => {
     let cache = false;
-    // @ts-expect-error
-    let result = undefined;
+    let result;
+    let callback = fn;
     return () => {
         if (cache) {
-            // @ts-expect-error
             return result;
         }
-        result = fn();
+        result = callback();
         cache = true;
         // Allow to clean up memory for fn
         // and all dependent resources
-        // @ts-expect-error
-        fn = undefined;
+        callback = undefined;
         return result;
     };
 };