@rspack-debug/browser 0.0.0-alpha.0 → 1.6.2

package/dist/stats/statsFactoryUtils.d.ts

@@ -0,0 +1,341 @@
+import type binding from "../binding";
+import type { JsOriginRecord } from "../binding";
+import type { Compilation } from "../Compilation";
+import type { StatsOptions } from "../config";
+import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
+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?: {
+        preload?: string[];
+        prefetch?: string[];
+    };
+    isOverSizeLimit?: boolean;
+};
+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;
+    copied?: boolean;
+    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;
+    cached: boolean;
+    related?: StatsAsset[];
+    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 StatsAsset = KnownStatsAsset & Record<string, any>;
+export type StatsChunk = KnownStatsChunk & Record<string, any>;
+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 | number | null;
+    issuerId?: string | number | null;
+    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 = {
+    total: number;
+    resolving: number;
+    building: number;
+};
+export type StatsModule = KnownStatsModule & Record<string, any>;
+export type KnownStatsModuleIssuer = {
+    identifier?: string;
+    name?: string;
+    id?: string | number | null;
+};
+export type StatsModuleIssuer = KnownStatsModuleIssuer & Record<string, any>;
+export declare enum StatsErrorCode {
+    /**
+     * Warning generated when either builtin `SwcJsMinimizer` or `LightningcssMinimizer` fails to minify the code.
+     */
+    ChunkMinificationError = "ChunkMinificationError",
+    /**
+     * Warning generated when either builtin `SwcJsMinimizer` or `LightningcssMinimizer` fails to minify the code.
+     */
+    ChunkMinificationWarning = "ChunkMinificationWarning",
+    /**
+     * Error generated when a module is failed to be parsed
+     */
+    ModuleParseError = "ModuleParseError",
+    /**
+     * Warning generated when a module is failed to be parsed
+     */
+    ModuleParseWarning = "ModuleParseWarning",
+    /**
+     * Error generated when a module is failed to be built (i.e being built by a
+     * loader)
+     */
+    ModuleBuildError = "ModuleBuildError"
+}
+export type KnownStatsError = {
+    message: string;
+    code?: StatsErrorCode | string;
+    chunkName?: string;
+    chunkEntry?: boolean;
+    chunkInitial?: boolean;
+    /**
+     * A custom filename associated with this error/warning.
+     */
+    file?: string;
+    /**
+     * The identifier of the module related to this error/warning.
+     * Usually an absolute path, may include inline loader requests.
+     * @example
+     * - `/path/to/project/src/index.js`
+     * - `!builtin:react-refresh-loader!/path/to/project/src/index.css`
+     */
+    moduleIdentifier?: string;
+    /**
+     * The readable name of the module related to this error/warning.
+     * Usually a relative path, no inline loader requests.
+     * @example
+     * - `"./src/index.js"`
+     * - `"./src/index.css"`
+     */
+    moduleName?: string;
+    loc?: string;
+    chunkId?: string | number;
+    moduleId?: string | number | null;
+    moduleTrace?: StatsModuleTraceItem[];
+    details?: any;
+    stack?: string;
+};
+export type StatsError = KnownStatsError & Record<string, any>;
+export type StatsModuleTraceItem = {
+    originIdentifier?: string;
+    originName?: string;
+    moduleIdentifier?: string;
+    moduleName?: string;
+    originId?: string | number | null;
+    moduleId?: string | number | null;
+    dependencies?: StatsModuleTraceDependency[];
+};
+export type StatsModuleTraceDependency = KnownStatsModuleTraceDependency & Record<string, any>;
+export type KnownStatsModuleTraceDependency = {
+    loc: string;
+};
+export type KnownStatsModuleReason = {
+    moduleIdentifier?: string;
+    module?: string;
+    moduleName?: string;
+    resolvedModuleIdentifier?: string;
+    resolvedModule?: string;
+    type?: string;
+    active: boolean;
+    explanation?: string;
+    userRequest?: string;
+    loc?: string;
+    moduleId?: string | number | null;
+    resolvedModuleId?: string | number | null;
+};
+export type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
+export type KnownStatsChunkOrigin = {
+    module: string;
+    moduleIdentifier: string;
+    moduleName: string;
+    loc: string;
+    request: string;
+    moduleId?: string | number | null;
+};
+export type StatsChunkOrigin = KnownStatsChunkOrigin & Record<string, any>;
+export type KnownStatsCompilation = {
+    /**
+     * webpack version.
+     * this is a hack to be compatible with plugin which detect webpack's version
+     */
+    version?: string;
+    /** rspack version */
+    rspackVersion?: string;
+    name?: string;
+    hash?: string;
+    time?: number;
+    builtAt?: number;
+    publicPath?: string;
+    outputPath?: string;
+    assets?: StatsAsset[];
+    assetsByChunkName?: Record<string, string[]>;
+    chunks?: StatsChunk[];
+    modules?: StatsModule[];
+    entrypoints?: Record<string, StatsChunkGroup>;
+    namedChunkGroups?: Record<string, StatsChunkGroup>;
+    errors?: StatsError[];
+    errorsCount?: number;
+    warnings?: StatsError[];
+    warningsCount?: number;
+    filteredModules?: number;
+    children?: StatsCompilation[];
+    logging?: Record<string, StatsLogging>;
+};
+export type StatsCompilation = KnownStatsCompilation & Record<string, any>;
+export type StatsLogging = KnownStatsLogging & Record<string, any>;
+export type KnownStatsLogging = {
+    entries: StatsLoggingEntry[];
+    filteredEntries: number;
+    debug: boolean;
+};
+export type StatsLoggingEntry = KnownStatsLoggingEntry & Record<string, any>;
+export type KnownStatsLoggingEntry = {
+    type: string;
+    message: string;
+    trace?: string[] | undefined;
+    children?: StatsLoggingEntry[] | undefined;
+    args?: any[] | undefined;
+    time?: number | undefined;
+};
+type ExtractorsByOption<T, O> = {
+    [x: string]: (object: O, data: T, context: StatsFactoryContext, options: any, factory: StatsFactory) => void;
+};
+export type PreprocessedAsset = binding.JsStatsAsset & {
+    type: string;
+    related: PreprocessedAsset[];
+    info: binding.JsStatsAssetInfo;
+};
+export type SimpleExtractors = {
+    compilation: ExtractorsByOption<Compilation, StatsCompilation>;
+    asset$visible: ExtractorsByOption<PreprocessedAsset, StatsAsset>;
+    asset: ExtractorsByOption<PreprocessedAsset, StatsAsset>;
+    chunkGroup: ExtractorsByOption<{
+        name: string;
+        chunkGroup: binding.JsStatsChunkGroup;
+    }, StatsChunkGroup>;
+    module: ExtractorsByOption<binding.JsStatsModule, StatsModule>;
+    module$visible: ExtractorsByOption<binding.JsStatsModule, StatsModule>;
+    moduleIssuer: ExtractorsByOption<binding.JsStatsModuleIssuer, StatsModuleIssuer>;
+    profile: ExtractorsByOption<binding.JsStatsModuleProfile, StatsProfile>;
+    moduleReason: ExtractorsByOption<binding.JsStatsModuleReason, StatsModuleReason>;
+    chunk: ExtractorsByOption<binding.JsStatsChunk, KnownStatsChunk>;
+    chunkOrigin: ExtractorsByOption<JsOriginRecord, StatsChunkOrigin>;
+    error: ExtractorsByOption<binding.JsStatsError, StatsError>;
+    warning: ExtractorsByOption<binding.JsStatsError, StatsError>;
+    moduleTraceItem: ExtractorsByOption<binding.JsStatsModuleTrace, StatsModuleTraceItem>;
+    moduleTraceDependency: ExtractorsByOption<binding.JsStatsModuleTraceDependency, StatsModuleTraceDependency>;
+};
+export declare const iterateConfig: (config: Record<string, Record<string, Function>>, options: StatsOptions, fn: (a1: string, a2: Function) => void) => void;
+type Child = {
+    children?: ItemChildren;
+    filteredChildren?: number;
+};
+type ItemChildren = Child[];
+export declare const collapse: (children: ItemChildren) => Child[];
+export declare const spaceLimited: (itemsAndGroups: ItemChildren, max: number, filteredChildrenLineReserved?: boolean) => {
+    children: any;
+    filteredChildren: any;
+};
+export declare const countWithChildren: (compilation: Compilation, getItems: (compilation: Compilation, key: string) => any[]) => number;
+export declare const sortByField: (field: string) => ((a1: Object, a2: Object) => number);
+export declare const assetGroup: (children: StatsAsset[]) => {
+    size: number;
+};
+export declare const moduleGroup: (children: {
+    size: number;
+    sizes: Record<string, number>;
+}[]) => {
+    size: number;
+    sizes: Record<string, number>;
+};
+export declare const mergeToObject: (items: {
+    [key: string]: any;
+    name: string;
+}[]) => Object;
+export declare const errorsSpaceLimit: (errors: StatsError[], max: number) => {
+    errors: StatsError[];
+    filtered: number;
+};
+export declare const warningFromStatsWarning: (warning: binding.JsStatsError) => Error;
+export {};

package/dist/swc.d.ts

@@ -0,0 +1,7 @@
+import type { TransformOutput } from "./binding";
+import type { JsMinifyOptions, Options as TransformOptions } from "@swc/types";
+export type { TransformOutput, TransformOptions, JsMinifyOptions };
+export declare function minify(source: string, options?: JsMinifyOptions): Promise<TransformOutput>;
+export declare function minifySync(source: string, options?: JsMinifyOptions): TransformOutput;
+export declare function transform(source: string, options?: TransformOptions): Promise<TransformOutput>;
+export declare function transformSync(source: string, options?: TransformOptions): TransformOutput;

package/dist/taps/compilation.d.ts

@@ -0,0 +1,8 @@
+import binding from "../binding";
+import type { CreatePartialRegisters } from "./types";
+export declare class CodeGenerationResult {
+    #private;
+    constructor(result: binding.JsCodegenerationResult);
+    get(sourceType: string): string;
+}
+export declare const createCompilationHooksRegisters: CreatePartialRegisters<`Compilation`>;

package/dist/taps/compiler.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePartialRegisters } from "./types";
+export declare const createCompilerHooksRegisters: CreatePartialRegisters<`Compiler`>;

package/dist/taps/contextModuleFactory.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePartialRegisters } from "./types";
+export declare const createContextModuleFactoryHooksRegisters: CreatePartialRegisters<`ContextModuleFactory`>;

package/dist/taps/index.d.ts

@@ -0,0 +1,6 @@
+export { createHtmlPluginHooksRegisters } from "../builtin-plugin/html-plugin/taps";
+export { createCompilationHooksRegisters } from "./compilation";
+export { createCompilerHooksRegisters } from "./compiler";
+export { createContextModuleFactoryHooksRegisters } from "./contextModuleFactory";
+export { createJavaScriptModulesHooksRegisters } from "./javascriptModules";
+export { createNormalModuleFactoryHooksRegisters } from "./normalModuleFactory";

package/dist/taps/javascriptModules.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePartialRegisters } from "./types";
+export declare const createJavaScriptModulesHooksRegisters: CreatePartialRegisters<`JavascriptModules`>;

package/dist/taps/normalModuleFactory.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePartialRegisters } from "./types";
+export declare const createNormalModuleFactoryHooksRegisters: CreatePartialRegisters<`NormalModuleFactory`>;

package/dist/taps/types.d.ts

@@ -0,0 +1,11 @@
+import type binding from "../binding";
+import type * as liteTapable from "@rspack/lite-tapable";
+import type { Compiler } from "../Compiler";
+type CreateHookMapRegisterTaps = <H extends liteTapable.Hook<any, any, any>>(registerKind: binding.RegisterJsTapKind, getHookMap: () => liteTapable.HookMap<H>, createTap: (queried: liteTapable.QueriedHookMap<H>) => any) => (stages: number[]) => binding.JsTap[];
+type CreateHookRegisterTaps = <T, R, A>(registerKind: binding.RegisterJsTapKind, getHook: () => liteTapable.Hook<T, R, A>, createTap: (queried: liteTapable.QueriedHook<T, R, A>) => any) => (stages: number[]) => binding.JsTap[];
+type RegisterTapKeys<T, L extends string> = T extends keyof binding.RegisterJsTaps ? (T extends L ? T : never) : never;
+type PartialRegisters<L extends string> = {
+    [K in RegisterTapKeys<keyof binding.RegisterJsTaps, `register${L}${string}Taps`>]: binding.RegisterJsTaps[K];
+};
+export type CreatePartialRegisters<L extends string> = (getCompiler: () => Compiler, createTap: CreateHookRegisterTaps, createMapTap: CreateHookMapRegisterTaps) => PartialRegisters<L>;
+export {};

package/dist/trace/index.d.ts

@@ -0,0 +1,46 @@
+export interface ChromeEvent {
+    name: string;
+    trackName?: string;
+    ph: "b" | "e" | "X" | "P";
+    processName?: string;
+    categories?: string[];
+    uuid: number;
+    ts: bigint;
+    args?: {
+        [key: string]: any;
+    };
+}
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PartialChromeEvent = MakeOptional<ChromeEvent, "ts" | "ph">;
+export declare class JavaScriptTracer {
+    static state: "uninitialized" | "on" | "off";
+    static startTime: bigint;
+    static events: ChromeEvent[];
+    static layer: string;
+    static output: string;
+    static session: import("node:inspector").Session;
+    private static counter;
+    /**
+     * only first call take effects, subsequent calls will be ignored
+     * @param layer tracing layer
+     * @param output tracing output file path
+     */
+    static initJavaScriptTrace(layer: string, output: string): Promise<void>;
+    static uuid(): number;
+    static initCpuProfiler(): void;
+    /**
+     * only first call take effects, subsequent calls will be ignored
+     * @param isEnd true means we are at the end of tracing,and can append ']' to close the json
+     * @returns
+     */
+    static cleanupJavaScriptTrace(): Promise<void>;
+    static getTs(): bigint;
+    static getCommonEv(): {
+        ts: bigint;
+        cat: string;
+    };
+    static pushEvent(event: ChromeEvent): void;
+    static startAsync(events: PartialChromeEvent): void;
+    static endAsync(events: PartialChromeEvent): void;
+}
+export {};

package/dist/trace/traceHookPlugin.d.ts

@@ -0,0 +1,5 @@
+import type { Compiler } from "../exports";
+export declare class TraceHookPlugin {
+    name: string;
+    apply(compiler: Compiler): void;
+}

package/dist/util/ArrayQueue.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/ArrayQueue.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/**
+ * @template T
+ */
+declare class ArrayQueue<T> {
+    _list: T[];
+    _listReversed: T[];
+    constructor(items?: T[]);
+    /**
+     * Returns the number of elements in this queue.
+     * @returns {number} The number of elements in this queue.
+     */
+    get length(): number;
+    /**
+     * Empties the queue.
+     */
+    clear(): void;
+    /**
+     * Appends the specified element to this queue.
+     * @param {T} item The element to add.
+     * @returns {void}
+     */
+    enqueue(item: T): void;
+    /**
+     * Retrieves and removes the head of this queue.
+     * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+     */
+    dequeue(): T | undefined;
+    /**
+     * Finds and removes an item
+     * @param {T} item the item
+     * @returns {void}
+     */
+    delete(item: T): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}
+export default ArrayQueue;

package/dist/util/AsyncTask.d.ts

@@ -0,0 +1,7 @@
+type TaskCallback<Ret> = (err: Error | null, ret: Ret | null) => void;
+export declare class AsyncTask<Param, Ret> {
+    #private;
+    constructor(task: (param: Param[], callback: (results: [Error | null, Ret | null][]) => void) => void);
+    exec(param: Param, callback: TaskCallback<Ret>): void;
+}
+export {};

package/dist/util/MergeCaller.d.ts

@@ -0,0 +1,10 @@
+type CallFn<D> = (args: D[]) => void;
+export default class MergeCaller<D> {
+    private callArgs;
+    private callFn;
+    constructor(fn: CallFn<D>);
+    private finalCall;
+    pendingData(): D[];
+    push(...data: D[]): void;
+}
+export {};

package/dist/util/SizeFormatHelpers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/util
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+export declare const formatSize: (size: unknown) => string;

package/dist/util/SplitChunkSize.d.ts

@@ -0,0 +1,5 @@
+import type { RawSplitChunkSizes } from "../binding";
+declare class JsSplitChunkSizes {
+    static __to_binding(sizes?: number | Record<string, number>): number | RawSplitChunkSizes | undefined;
+}
+export { JsSplitChunkSizes };

package/dist/util/assertNotNil.d.ts

@@ -0,0 +1 @@
+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/asyncLib.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The following code is modified based on
+ * https://github.com/suguru03/neo-async/blob/master/lib/async.js
+ *
+ * MIT Licensed
+ * Author Suguru Motegi
+ * Copyright (c) 2014-2018 Suguru Motegi
+ * https://github.com/suguru03/neo-async/blob/master/LICENSE
+ */
+export interface Dictionary<T> {
+    [key: string]: T;
+}
+export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>;
+export type ErrorCallback<E = Error> = (err?: E | null) => void;
+export type AsyncIterator<T, E = Error> = (item: T, callback: ErrorCallback<E>) => void;
+/**
+ * @example
+ *
+ * // array
+ * var order = [];
+ * var array = [1, 3, 2];
+ * var iterator = function(num, done) {
+ *   setTimeout(function() {
+ *     order.push(num);
+ *     done();
+ *   }, num * 10);
+ * };
+ * asyncLib.each(array, iterator, function(err, res) {
+ *   console.log(res); // undefined
+ *   console.log(order); // [1, 2, 3]
+ * });
+ *
+ * @example
+ *
+ * // break
+ * var order = [];
+ * var array = [1, 3, 2];
+ * var iterator = function(num, done) {
+ *   setTimeout(function() {
+ *     order.push(num);
+ *     done(null, num !== 2);
+ *   }, num * 10);
+ * };
+ * asyncLib.each(array, iterator, function(err, res) {
+ *   console.log(res); // undefined
+ *   console.log(order); // [1, 2]
+ * });
+ *
+ */
+declare function each<T, E = Error>(collection: IterableCollection<T>, iterator: AsyncIterator<T, E>, originalCallback: ErrorCallback<E>): void;
+declare const _default: {
+    each: typeof each;
+};
+export default _default;

package/dist/util/bindingVersionCheck.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check if these version matches:
+ * `@rspack/core`, Binding version
+ */
+export declare const checkVersion: () => Error | null | undefined;

package/dist/util/cleverMerge.d.ts

@@ -0,0 +1,24 @@
+export declare const DELETE: unique symbol;
+/**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param first first object
+ * @param second second object
+ * @returns  merged object of first and second object
+ */
+export declare const cachedCleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * Arrays might reference the old value with "...".
+ * Non-object values take preference over object values.
+ * @param first first object
+ * @param second second object
+ * @returns merged object of first and second object
+ */
+export declare const cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);

package/dist/util/comparators.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/util
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+export type Comparator = <T>(arg0: T, arg1: T) => -1 | 0 | 1;
+type Selector<A, B> = (input: A) => B;
+export declare const concatComparators: (...comps: Comparator[]) => Comparator;
+export declare const compareIds: <T = string | number>(a: T, b: T) => -1 | 0 | 1;
+export declare const compareSelect: <T, R>(getter: Selector<T, R>, comparator: Comparator) => Comparator;
+export declare const compareNumbers: (a: number, b: number) => 0 | 1 | -1;
+export {};

package/dist/util/createHash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/createHash.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import Hash from "./hash";
+/**
+ * Creates a hash by name or function
+ * @param algorithm the algorithm name or a constructor creating a hash
+ * @returns the hash
+ */
+export declare const createHash: (algorithm: "debug" | "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => Hash)) => Hash;

package/dist/util/createReadonlyMap.d.ts

@@ -0,0 +1 @@
+export declare function createReadonlyMap<T>(obj: Pick<ReadonlyMap<string, T>, "get" | "keys">): ReadonlyMap<string, Readonly<T>>;

package/dist/util/fake.d.ts

@@ -0,0 +1,9 @@
+export type FakeHook<T> = T & {
+    _fakeHook: true;
+};
+export declare function createFakeCompilationDependencies(getDeps: () => string[], addDeps: (deps: string[]) => void): {
+    [Symbol.iterator](): Generator<string, void, unknown>;
+    has(dep: string): boolean;
+    add: (dep: string) => void;
+    addAll: (deps: Iterable<string>) => void;
+};