@rspack-debug/core 1.3.14

package/compiled/zod/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/compiled/zod/package.json

@@ -0,0 +1 @@
+{"name":"zod","author":"Colin McDonnell <zod@colinhacks.com>","version":"3.25.50","funding":"https://github.com/sponsors/colinhacks","license":"MIT","types":"./dist/types/index.d.ts","type":"commonjs"}

package/compiled/zod/v3/index.d.ts

@@ -0,0 +1,3 @@
+export * from "../dist/types/v3/index.js";
+import z from "../dist/types/v3/index.js";
+export default z;

package/compiled/zod/v4/core/index.d.ts

@@ -0,0 +1 @@
+export * from "../../dist/types/v4/core/index.js";

package/compiled/zod/v4/index.d.ts

@@ -0,0 +1,3 @@
+import z from "../dist/types/v4/index.js";
+export * from "../dist/types/v4/index.js";
+export default z;

package/compiled/zod/v4/locales/en.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/types/v4/locales/en.d.ts";
+export { default } from "../../dist/types/v4/locales/en.d.ts";

package/compiled/zod/v4/locales/index.d.ts

@@ -0,0 +1 @@
+export * from "../../dist/types/v4/locales/index.js";

package/compiled/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../dist/types/v4/mini/index.js";

package/dist/Chunk.d.ts

@@ -0,0 +1,35 @@
+import type { JsChunk } from "@rspack/binding";
+import { ChunkGroup } from "./ChunkGroup";
+import type { EntryOptions } from "./exports";
+export declare class Chunk {
+    #private;
+    readonly name?: string;
+    readonly id?: string;
+    readonly ids: ReadonlyArray<string>;
+    readonly idNameHints: ReadonlyArray<string>;
+    readonly filenameTemplate?: string;
+    readonly cssFilenameTemplate?: string;
+    readonly files: ReadonlySet<string>;
+    readonly runtime: ReadonlySet<string>;
+    readonly hash?: string;
+    readonly contentHash: Readonly<Record<string, string>>;
+    readonly renderedHash?: string;
+    readonly chunkReason?: string;
+    readonly auxiliaryFiles: ReadonlySet<string>;
+    static __from_binding(binding: JsChunk): Chunk;
+    static __to_binding(chunk: Chunk): JsChunk;
+    constructor(binding: JsChunk);
+    isOnlyInitial(): boolean;
+    canBeInitial(): boolean;
+    hasRuntime(): boolean;
+    get groupsIterable(): ReadonlySet<ChunkGroup>;
+    getChunkMaps(realHash: boolean): {
+        hash: Record<string | number, string>;
+        contentHash: Record<string | number, Record<string, string>>;
+        name: Record<string | number, string>;
+    };
+    getAllAsyncChunks(): ReadonlySet<Chunk>;
+    getAllInitialChunks(): ReadonlySet<Chunk>;
+    getAllReferencedChunks(): ReadonlySet<Chunk>;
+    getEntryOptions(): Readonly<EntryOptions> | undefined;
+}

package/dist/ChunkGraph.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncDependenciesBlock, JsChunkGraph } from "@rspack/binding";
+import type { RuntimeSpec } from "./util/runtime";
+import { Chunk } from "./Chunk";
+import { ChunkGroup } from "./ChunkGroup";
+import type { Module } from "./Module";
+export declare class ChunkGraph {
+    #private;
+    static __from_binding(binding: JsChunkGraph): ChunkGraph;
+    constructor(binding: JsChunkGraph);
+    hasChunkEntryDependentChunks(chunk: Chunk): boolean;
+    getChunkModules(chunk: Chunk): ReadonlyArray<Module>;
+    getChunkModulesIterable(chunk: Chunk): Iterable<Module>;
+    getOrderedChunkModulesIterable(chunk: Chunk, compareFn: (a: Module, b: Module) => number): Iterable<Module>;
+    getChunkEntryModulesIterable(chunk: Chunk): Iterable<Module>;
+    getNumberOfEntryModules(chunk: Chunk): number;
+    getChunkEntryDependentChunksIterable(chunk: Chunk): Iterable<Chunk>;
+    getChunkModulesIterableBySourceType(chunk: Chunk, sourceType: string): Iterable<Module>;
+    getModuleChunks(module: Module): Chunk[];
+    getModuleChunksIterable(module: Module): Iterable<Chunk>;
+    getModuleId(module: Module): string | number | null;
+    getModuleHash(module: Module, runtime: RuntimeSpec): string | null;
+    getBlockChunkGroup(depBlock: AsyncDependenciesBlock): ChunkGroup | null;
+}

package/dist/ChunkGroup.d.ts

@@ -0,0 +1,33 @@
+import type { JsChunkGroup } from "@rspack/binding";
+import { Chunk } from "./Chunk";
+import type { Module } from "./Module";
+export declare class ChunkGroup {
+    #private;
+    readonly chunks: ReadonlyArray<Chunk>;
+    readonly index?: number;
+    readonly name?: string;
+    readonly origins: ReadonlyArray<ChunkGroupOrigin>;
+    readonly childrenIterable: Set<ChunkGroup>;
+    static __from_binding(binding: JsChunkGroup): ChunkGroup;
+    protected constructor(inner: JsChunkGroup);
+    getFiles(): ReadonlyArray<string>;
+    getParents(): ReadonlyArray<ChunkGroup>;
+    isInitial(): boolean;
+    getModulePreOrderIndex(module: Module): number | null;
+    getModulePostOrderIndex(module: Module): number | null;
+}
+interface ChunkGroupOrigin {
+    module?: Module;
+    request?: string;
+    loc?: {
+        start: {
+            line: number;
+            column: number;
+        };
+        end?: {
+            line: number;
+            column: number;
+        };
+    } | string;
+}
+export {};

package/dist/Chunks.d.ts

@@ -0,0 +1,13 @@
+import { Chunks } from "@rspack/binding";
+import { Chunk } from "./Chunk";
+declare module "@rspack/binding" {
+    interface Chunks {
+        [Symbol.iterator](): SetIterator<Chunk>;
+        entries(): SetIterator<[Chunk, Chunk]>;
+        values(): SetIterator<Chunk>;
+        keys(): SetIterator<Chunk>;
+        forEach(callbackfn: (value: Chunk, value2: Chunk, set: ReadonlySet<Chunk>) => void, thisArg?: any): void;
+        has(value: Chunk): boolean;
+    }
+}
+export default Chunks;

package/dist/CodeGenerationResults.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Compilation.d.ts

@@ -0,0 +1,411 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/Compilation.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import * as binding from "@rspack/binding";
+import type { AssetInfo, Dependency, ExternalObject, JsCompilation, JsRuntimeModule } from "@rspack/binding";
+export type { AssetInfo } from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type { Source } from "../compiled/webpack-sources";
+import { Chunk } from "./Chunk";
+import { ChunkGraph } from "./ChunkGraph";
+import { ChunkGroup } from "./ChunkGroup";
+import type { Compiler } from "./Compiler";
+import type { ContextModuleFactory } from "./ContextModuleFactory";
+import { Entrypoint } from "./Entrypoint";
+import type { Module } from "./Module";
+import ModuleGraph from "./ModuleGraph";
+import type { NormalModuleCompilationHooks } from "./NormalModule";
+import type { NormalModuleFactory } from "./NormalModuleFactory";
+import type { ResolverFactory } from "./ResolverFactory";
+import type { RspackError } from "./RspackError";
+import { RuntimeModule } from "./RuntimeModule";
+import { Stats, type StatsAsset, type StatsError, type StatsModule } from "./Stats";
+import type { EntryOptions, EntryPlugin } from "./builtin-plugin";
+import type { OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
+import WebpackError from "./lib/WebpackError";
+import { Logger } from "./logging/Logger";
+import { StatsFactory } from "./stats/StatsFactory";
+import { StatsPrinter } from "./stats/StatsPrinter";
+import type { InputFileSystem } from "./util/fs";
+import type Hash from "./util/hash";
+import "./Chunks";
+import "./CodeGenerationResults";
+import type { CodeGenerationResult } from "./taps/compilation";
+export type Assets = Record<string, Source>;
+export interface Asset {
+    name: string;
+    source: Source;
+    info: AssetInfo;
+}
+export type PathDataChunkLike = {
+    id?: string;
+    name?: string;
+    hash?: string;
+    contentHash?: Record<string, string>;
+};
+export type PathData = {
+    filename?: string;
+    hash?: string;
+    contentHash?: string;
+    runtime?: string;
+    url?: string;
+    id?: string;
+    chunk?: Chunk | PathDataChunkLike;
+    contentHashType?: string;
+};
+export interface LogEntry {
+    type: string;
+    args: any[];
+    time?: number;
+    trace?: string[];
+}
+export interface CompilationParams {
+    normalModuleFactory: NormalModuleFactory;
+    contextModuleFactory: ContextModuleFactory;
+}
+export interface KnownCreateStatsOptionsContext {
+    forToString?: boolean;
+}
+export interface ExecuteModuleArgument {
+    codeGenerationResult: CodeGenerationResult;
+    moduleObject: {
+        id: string;
+        exports: any;
+        loaded: boolean;
+        error?: Error;
+    };
+}
+export interface ExecuteModuleContext {
+    __webpack_require__: (id: string) => any;
+}
+export interface KnownNormalizedStatsOptions {
+    context: string;
+    chunksSort: string;
+    modulesSort: string;
+    chunkModulesSort: string;
+    nestedModulesSort: string;
+    assetsSort: string;
+    ids: boolean;
+    cachedAssets: boolean;
+    groupAssetsByEmitStatus: boolean;
+    groupAssetsByPath: boolean;
+    groupAssetsByExtension: boolean;
+    assetsSpace: number;
+    excludeAssets: ((value: string, asset: StatsAsset) => boolean)[];
+    excludeModules: ((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[];
+    warningsFilter: ((warning: StatsError, textValue: string) => boolean)[];
+    cachedModules: boolean;
+    orphanModules: boolean;
+    dependentModules: boolean;
+    runtimeModules: boolean;
+    groupModulesByCacheStatus: boolean;
+    groupModulesByLayer: boolean;
+    groupModulesByAttributes: boolean;
+    groupModulesByPath: boolean;
+    groupModulesByExtension: boolean;
+    groupModulesByType: boolean;
+    entrypoints: boolean | "auto";
+    chunkGroups: boolean;
+    chunkGroupAuxiliary: boolean;
+    chunkGroupChildren: boolean;
+    chunkGroupMaxAssets: number;
+    modulesSpace: number;
+    chunkModulesSpace: number;
+    nestedModulesSpace: number;
+    logging: false | "none" | "error" | "warn" | "info" | "log" | "verbose";
+    loggingDebug: ((value: string) => boolean)[];
+    loggingTrace: boolean;
+    chunkModules: boolean;
+    chunkRelations: boolean;
+    reasons: boolean;
+    moduleAssets: boolean;
+    nestedModules: boolean;
+    source: boolean;
+    usedExports: boolean;
+    providedExports: boolean;
+    optimizationBailout: boolean;
+    depth: boolean;
+    assets: boolean;
+    chunks: boolean;
+    errors: boolean;
+    errorsCount: boolean;
+    hash: boolean;
+    modules: boolean;
+    warnings: boolean;
+    warningsCount: boolean;
+}
+export type CreateStatsOptionsContext = KnownCreateStatsOptionsContext & Record<string, any>;
+export type NormalizedStatsOptions = KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>;
+export declare const checkCompilation: (compilation: Compilation) => void;
+export declare class Compilation {
+    #private;
+    hooks: Readonly<{
+        processAssets: liteTapable.AsyncSeriesHook<Assets>;
+        afterProcessAssets: liteTapable.SyncHook<Assets>;
+        childCompiler: liteTapable.SyncHook<[Compiler, string, number]>;
+        log: liteTapable.SyncBailHook<[string, LogEntry], true>;
+        additionalAssets: any;
+        optimizeModules: liteTapable.SyncBailHook<Iterable<Module>, void>;
+        afterOptimizeModules: liteTapable.SyncHook<Iterable<Module>, void>;
+        optimizeTree: liteTapable.AsyncSeriesHook<[
+            Iterable<Chunk>,
+            Iterable<Module>
+        ]>;
+        optimizeChunkModules: liteTapable.AsyncSeriesBailHook<[
+            Iterable<Chunk>,
+            Iterable<Module>
+        ], void>;
+        finishModules: liteTapable.AsyncSeriesHook<[Iterable<Module>], void>;
+        chunkHash: liteTapable.SyncHook<[Chunk, Hash], void>;
+        chunkAsset: liteTapable.SyncHook<[Chunk, string], void>;
+        processWarnings: liteTapable.SyncWaterfallHook<[Error[]]>;
+        succeedModule: liteTapable.SyncHook<[Module], void>;
+        stillValidModule: liteTapable.SyncHook<[Module], void>;
+        statsPreset: liteTapable.HookMap<liteTapable.SyncHook<[
+            Partial<StatsOptions>,
+            CreateStatsOptionsContext
+        ], void>>;
+        statsNormalize: liteTapable.SyncHook<[
+            Partial<StatsOptions>,
+            CreateStatsOptionsContext
+        ], void>;
+        statsFactory: liteTapable.SyncHook<[StatsFactory, StatsOptions], void>;
+        statsPrinter: liteTapable.SyncHook<[StatsPrinter, StatsOptions], void>;
+        buildModule: liteTapable.SyncHook<[Module]>;
+        executeModule: liteTapable.SyncHook<[
+            ExecuteModuleArgument,
+            ExecuteModuleContext
+        ]>;
+        additionalTreeRuntimeRequirements: liteTapable.SyncHook<[
+            Chunk,
+            Set<string>
+        ], void>;
+        runtimeRequirementInTree: liteTapable.HookMap<liteTapable.SyncBailHook<[Chunk, Set<string>], void>>;
+        runtimeModule: liteTapable.SyncHook<[JsRuntimeModule, Chunk], void>;
+        seal: liteTapable.SyncHook<[], void>;
+        afterSeal: liteTapable.AsyncSeriesHook<[], void>;
+        needAdditionalPass: liteTapable.SyncBailHook<[], boolean>;
+    }>;
+    name?: string;
+    startTime?: number;
+    endTime?: number;
+    compiler: Compiler;
+    resolverFactory: ResolverFactory;
+    inputFileSystem: InputFileSystem | null;
+    options: RspackOptionsNormalized;
+    outputOptions: OutputNormalized;
+    logging: Map<string, LogEntry[]>;
+    childrenCounters: Record<string, number>;
+    children: Compilation[];
+    chunkGraph: ChunkGraph;
+    moduleGraph: ModuleGraph;
+    fileSystemInfo: {
+        createSnapshot(): null;
+    };
+    needAdditionalPass: boolean;
+    [binding.COMPILATION_HOOKS_MAP_SYMBOL]: WeakMap<Compilation, NormalModuleCompilationHooks>;
+    constructor(compiler: Compiler, inner: JsCompilation);
+    get hash(): Readonly<string | null>;
+    get fullHash(): Readonly<string | null>;
+    /**
+     * Get a map of all assets.
+     */
+    get assets(): Record<string, Source>;
+    /**
+     * Get a map of all entrypoints.
+     */
+    get entrypoints(): ReadonlyMap<string, Entrypoint>;
+    get chunkGroups(): ReadonlyArray<ChunkGroup>;
+    /**
+     * Get the named chunk groups.
+     *
+     * Note: This is a proxy for webpack internal API, only method `get`, `keys`, `values` and `entries` are supported now.
+     */
+    get namedChunkGroups(): ReadonlyMap<string, Readonly<ChunkGroup>>;
+    get modules(): ReadonlySet<Module>;
+    get builtModules(): ReadonlySet<Module>;
+    get chunks(): ReadonlySet<Chunk>;
+    /**
+     * Get the named chunks.
+     *
+     * Note: This is a proxy for webpack internal API, only method `get`, `keys`, `values` and `entries` are supported now.
+     */
+    get namedChunks(): ReadonlyMap<string, Readonly<Chunk>>;
+    get entries(): Map<string, EntryData>;
+    get codeGenerationResults(): binding.CodeGenerationResults;
+    getCache(name: string): import("./lib/CacheFacade").CacheFacade;
+    createStatsOptions(statsValue: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
+    createStatsFactory(options: StatsOptions): StatsFactory;
+    createStatsPrinter(options: StatsOptions): StatsPrinter;
+    /**
+     * Update an existing asset. Trying to update an asset that doesn't exist will throw an error.
+     */
+    updateAsset(filename: string, newSourceOrFunction: Source | ((source: Source) => Source), assetInfoUpdateOrFunction?: AssetInfo | ((assetInfo: AssetInfo) => AssetInfo | undefined)): void;
+    /**
+     * Emit an not existing asset. Trying to emit an asset that already exists will throw an error.
+     *
+     * @param file - file name
+     * @param source - asset source
+     * @param assetInfo - extra asset information
+     */
+    emitAsset(filename: string, source: Source, assetInfo?: AssetInfo): void;
+    deleteAsset(filename: string): void;
+    renameAsset(filename: string, newFilename: string): void;
+    /**
+     * Get an array of Asset
+     */
+    getAssets(): ReadonlyArray<Asset>;
+    getAsset(name: string): Readonly<Asset> | void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushRspackDiagnostic(diagnostic: binding.JsRspackDiagnostic): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushDiagnostic(diagnostic: ExternalObject<"Diagnostic">): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushDiagnostics(diagnostics: ExternalObject<"Diagnostic[]">): void;
+    get errors(): RspackError[];
+    set errors(errors: RspackError[]);
+    get warnings(): RspackError[];
+    set warnings(warnings: RspackError[]);
+    getPath(filename: string, data?: PathData): string;
+    getPathWithInfo(filename: string, data?: PathData): binding.PathWithInfo;
+    getAssetPath(filename: string, data?: PathData): string;
+    getAssetPathWithInfo(filename: string, data?: PathData): binding.PathWithInfo;
+    getLogger(name: string | (() => string)): Logger;
+    fileDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    contextDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    missingDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    buildDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    getStats(): Stats;
+    createChildCompiler(name: string, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
+    rebuildModule(module: Module, f: (err: Error | null, module: Module | null) => void): void;
+    addRuntimeModule(chunk: Chunk, runtimeModule: RuntimeModule): void;
+    addInclude(context: string, dependency: ReturnType<typeof EntryPlugin.createDependency>, options: EntryOptions, callback: (err?: null | WebpackError, module?: Module) => void): void;
+    addEntry(context: string, dependency: ReturnType<typeof EntryPlugin.createDependency>, optionsOrName: EntryOptions | string, callback: (err?: null | WebpackError, module?: Module) => void): void;
+    /**
+     * Get the `Source` of a given asset filename.
+     *
+     * Note: This is not a webpack public API, maybe removed in the future.
+     *
+     * @internal
+     */
+    __internal__getAssetSource(filename: string): Source | void;
+    /**
+     * Set the `Source` of an given asset filename.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__setAssetSource(filename: string, source: Source): void;
+    /**
+     * Delete the `Source` of an given asset filename.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__deleteAssetSource(filename: string): void;
+    /**
+     * Get a list of asset filenames.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__getAssetFilenames(): string[];
+    /**
+     * Test if an asset exists.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__hasAsset(name: string): boolean;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal_getInner(): binding.JsCompilation;
+    get __internal__shutdown(): boolean;
+    set __internal__shutdown(shutdown: boolean);
+    seal(): void;
+    unseal(): void;
+    static PROCESS_ASSETS_STAGE_ADDITIONAL: number;
+    static PROCESS_ASSETS_STAGE_PRE_PROCESS: number;
+    static PROCESS_ASSETS_STAGE_DERIVED: number;
+    static PROCESS_ASSETS_STAGE_ADDITIONS: number;
+    static PROCESS_ASSETS_STAGE_NONE: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: number;
+    static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: number;
+    static PROCESS_ASSETS_STAGE_SUMMARIZE: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;
+    static PROCESS_ASSETS_STAGE_ANALYSE: number;
+    static PROCESS_ASSETS_STAGE_REPORT: number;
+}
+export declare class EntryData {
+    dependencies: Dependency[];
+    includeDependencies: Dependency[];
+    options: binding.JsEntryOptions;
+    static __from_binding(binding: binding.JsEntryData): EntryData;
+    private constructor();
+}
+export declare class Entries implements Map<string, EntryData> {
+    #private;
+    constructor(data: binding.JsEntries);
+    clear(): void;
+    forEach(callback: (value: EntryData, key: string, map: Map<string, EntryData>) => void, thisArg?: any): void;
+    get size(): number;
+    entries(): ReturnType<Map<string, EntryData>["entries"]>;
+    values(): ReturnType<Map<string, EntryData>["values"]>;
+    [Symbol.iterator](): ReturnType<Map<string, EntryData>["entries"]>;
+    get [Symbol.toStringTag](): string;
+    has(key: string): boolean;
+    set(key: string, value: EntryData): this;
+    delete(key: string): boolean;
+    get(key: string): EntryData | undefined;
+    keys(): ReturnType<Map<string, EntryData>["keys"]>;
+}