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

package/dist/node/NodeEnvironmentPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { Compiler } from "..";
+import type { InfrastructureLogging } from "../config";
+export interface NodeEnvironmentPluginOptions {
+    infrastructureLogging: InfrastructureLogging;
+}
+export default class NodeEnvironmentPlugin {
+    options: NodeEnvironmentPluginOptions;
+    constructor(options: NodeEnvironmentPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/node/NodeTemplatePlugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/NodeTemplatePlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler } from "../Compiler";
+export type NodeTemplatePluginOptions = {
+    asyncChunkLoading?: boolean;
+};
+export default class NodeTemplatePlugin {
+    private _options;
+    constructor(_options?: NodeTemplatePluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/node/NodeWatchFileSystem.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/NodeWatchFileSystem.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type Watchpack from "watchpack";
+import type { FileSystemInfoEntry, InputFileSystem, Watcher, WatchFileSystem } from "../util/fs";
+export default class NodeWatchFileSystem implements WatchFileSystem {
+    inputFileSystem: InputFileSystem;
+    watcherOptions: Watchpack.WatchOptions;
+    watcher?: Watchpack;
+    constructor(inputFileSystem: InputFileSystem);
+    watch(files: Iterable<string>, directories: Iterable<string>, missing: Iterable<string>, startTime: number, options: Watchpack.WatchOptions, callback: (error: Error | null, fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, changedFiles: Set<string>, removedFiles: Set<string>) => void, callbackUndelayed: (fileName: string, changeTime: number) => void): Watcher;
+}

package/dist/node/nodeConsole.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/nodeConsole.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { LoggerConsole } from "../logging/createConsoleLogger";
+export default function ({ colors, appendOnly, stream }: {
+    colors?: boolean;
+    appendOnly?: boolean;
+    stream: NodeJS.WritableStream;
+}): LoggerConsole;

package/dist/rspack.d.ts

@@ -0,0 +1,16 @@
+import type { Callback } from "@rspack/lite-tapable";
+import { Compiler } from "./Compiler";
+import { type RspackOptions } from "./config";
+import { MultiCompiler, type MultiRspackOptions } from "./MultiCompiler";
+import MultiStats from "./MultiStats";
+import { Stats } from "./Stats";
+declare function createMultiCompiler(options: MultiRspackOptions): MultiCompiler;
+declare function createCompiler(userOptions: RspackOptions): Compiler;
+declare function rspack(options: MultiRspackOptions): MultiCompiler;
+declare function rspack(options: RspackOptions): Compiler;
+declare function rspack(options: MultiRspackOptions | RspackOptions): MultiCompiler | Compiler;
+declare function rspack(options: MultiRspackOptions, callback?: Callback<Error, MultiStats>): null | MultiCompiler;
+declare function rspack(options: RspackOptions, callback?: Callback<Error, Stats>): null | Compiler;
+declare function rspack(options: MultiRspackOptions | RspackOptions, callback?: Callback<Error, MultiStats | Stats>): null | MultiCompiler | Compiler;
+export { createCompiler, createMultiCompiler, MultiStats, rspack, Stats };
+export default rspack;

package/dist/rspack.wasi-browser.js

@@ -0,0 +1,125 @@
+import {
+  createOnMessage as __wasmCreateOnMessageForFsProxy,
+  getDefaultContext as __emnapiGetDefaultContext,
+  instantiateNapiModule as __emnapiInstantiateNapiModule,
+  WASI as __WASI,
+} from '@napi-rs/wasm-runtime'
+import { memfs, Buffer } from '@napi-rs/wasm-runtime/fs'
+
+
+export const { fs: __fs, vol: __volume } = memfs()
+
+const __wasi = new __WASI({
+  version: 'preview1',
+  fs: __fs,
+  preopens: {
+    '/': '/',
+  },
+})
+
+const __wasmUrl = window.RSPACK_WASM_URL || new URL('./rspack.wasm32-wasi.wasm', import.meta.url).href
+const __emnapiContext = __emnapiGetDefaultContext()
+__emnapiContext.feature.Buffer = Buffer
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 16384,
+  maximum: 65536,
+  shared: true,
+})
+
+const __wasmFile = await fetch(__wasmUrl).then((res) => res.arrayBuffer())
+
+const {
+  instance: __napiInstance,
+  module: __wasiModule,
+  napiModule: __napiModule,
+} = await __emnapiInstantiateNapiModule(__wasmFile, {
+  context: __emnapiContext,
+  asyncWorkPoolSize: 4,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(URL.createObjectURL(new Blob([`importScripts("${new URL('./wasi-worker-browser.mjs', import.meta.url)}")`], { type: 'text/javascript' })), {
+      type: 'classic',
+    })
+    worker.addEventListener('message', __wasmCreateOnMessageForFsProxy(__fs))
+
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+export default __napiModule.exports
+export const Assets = __napiModule.exports.Assets
+export const AsyncDependenciesBlock = __napiModule.exports.AsyncDependenciesBlock
+export const Chunk = __napiModule.exports.Chunk
+export const ChunkGraph = __napiModule.exports.ChunkGraph
+export const ChunkGroup = __napiModule.exports.ChunkGroup
+export const Chunks = __napiModule.exports.Chunks
+export const CodeGenerationResult = __napiModule.exports.CodeGenerationResult
+export const CodeGenerationResults = __napiModule.exports.CodeGenerationResults
+export const ConcatenatedModule = __napiModule.exports.ConcatenatedModule
+export const ContextModule = __napiModule.exports.ContextModule
+export const Dependency = __napiModule.exports.Dependency
+export const Diagnostics = __napiModule.exports.Diagnostics
+export const EntryDataDto = __napiModule.exports.EntryDataDto
+export const EntryDataDTO = __napiModule.exports.EntryDataDTO
+export const EntryDependency = __napiModule.exports.EntryDependency
+export const EntryOptionsDto = __napiModule.exports.EntryOptionsDto
+export const EntryOptionsDTO = __napiModule.exports.EntryOptionsDTO
+export const ExternalModule = __napiModule.exports.ExternalModule
+export const JsCompilation = __napiModule.exports.JsCompilation
+export const JsCompiler = __napiModule.exports.JsCompiler
+export const JsContextModuleFactoryAfterResolveData = __napiModule.exports.JsContextModuleFactoryAfterResolveData
+export const JsContextModuleFactoryBeforeResolveData = __napiModule.exports.JsContextModuleFactoryBeforeResolveData
+export const JsDependencies = __napiModule.exports.JsDependencies
+export const JsEntries = __napiModule.exports.JsEntries
+export const JsExportsInfo = __napiModule.exports.JsExportsInfo
+export const JsModuleGraph = __napiModule.exports.JsModuleGraph
+export const JsResolver = __napiModule.exports.JsResolver
+export const JsResolverFactory = __napiModule.exports.JsResolverFactory
+export const JsStats = __napiModule.exports.JsStats
+export const KnownBuildInfo = __napiModule.exports.KnownBuildInfo
+export const Module = __napiModule.exports.Module
+export const ModuleGraphConnection = __napiModule.exports.ModuleGraphConnection
+export const NativeWatcher = __napiModule.exports.NativeWatcher
+export const NativeWatchResult = __napiModule.exports.NativeWatchResult
+export const NormalModule = __napiModule.exports.NormalModule
+export const RawExternalItemFnCtx = __napiModule.exports.RawExternalItemFnCtx
+export const ReadonlyResourceData = __napiModule.exports.ReadonlyResourceData
+export const ResolverFactory = __napiModule.exports.ResolverFactory
+export const Sources = __napiModule.exports.Sources
+export const VirtualFileStore = __napiModule.exports.VirtualFileStore
+export const JsVirtualFileStore = __napiModule.exports.JsVirtualFileStore
+export const async = __napiModule.exports.async
+export const BuiltinPluginName = __napiModule.exports.BuiltinPluginName
+export const cleanupGlobalTrace = __napiModule.exports.cleanupGlobalTrace
+export const EnforceExtension = __napiModule.exports.EnforceExtension
+export const EXPECTED_RSPACK_CORE_VERSION = __napiModule.exports.EXPECTED_RSPACK_CORE_VERSION
+export const formatDiagnostic = __napiModule.exports.formatDiagnostic
+export const JsLoaderState = __napiModule.exports.JsLoaderState
+export const JsRspackSeverity = __napiModule.exports.JsRspackSeverity
+export const loadBrowserslist = __napiModule.exports.loadBrowserslist
+export const minify = __napiModule.exports.minify
+export const minifySync = __napiModule.exports.minifySync
+export const RawJavascriptParserCommonjsExports = __napiModule.exports.RawJavascriptParserCommonjsExports
+export const RawRuleSetConditionType = __napiModule.exports.RawRuleSetConditionType
+export const registerGlobalTrace = __napiModule.exports.registerGlobalTrace
+export const RegisterJsTapKind = __napiModule.exports.RegisterJsTapKind
+export const sync = __napiModule.exports.sync
+export const syncTraceEvent = __napiModule.exports.syncTraceEvent
+export const transform = __napiModule.exports.transform
+export const transformSync = __napiModule.exports.transformSync

package/dist/rspackOptionsApply.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler, RspackOptionsNormalized } from ".";
+export declare class RspackOptionsApply {
+    process(options: RspackOptionsNormalized, compiler: Compiler): void;
+}

package/dist/runtime/cssExtractHmr.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeUrl(url: string): string;
+declare function noop(): void;
+declare function cssReload(moduleId: string, options: Record<string, any>): typeof noop;
+export { cssReload };

package/dist/runtime/moduleFederationDefaultRuntime.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): void;
+export = _exports;

package/dist/sharing/ConsumeSharedPlugin.d.ts

@@ -0,0 +1,41 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+import type { Compiler } from "../Compiler";
+export type ConsumeSharedPluginOptions = {
+    consumes: Consumes;
+    shareScope?: string;
+    enhanced?: boolean;
+};
+export type Consumes = (ConsumesItem | ConsumesObject)[] | ConsumesObject;
+export type ConsumesItem = string;
+export type ConsumesObject = {
+    [k: string]: ConsumesConfig | ConsumesItem;
+};
+export type ConsumesConfig = {
+    eager?: boolean;
+    import?: false | ConsumesItem;
+    packageName?: string;
+    requiredVersion?: false | string;
+    shareKey?: string;
+    shareScope?: string;
+    singleton?: boolean;
+    strictVersion?: boolean;
+};
+export declare class ConsumeSharedPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _options: {
+        consumes: [string, {
+            import: string | undefined;
+            shareScope: string;
+            shareKey: string;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean;
+            packageName: string | undefined;
+            singleton: boolean;
+            eager: boolean;
+        }][];
+        enhanced: boolean;
+    };
+    constructor(options: ConsumeSharedPluginOptions);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

package/dist/sharing/ProvideSharedPlugin.d.ts

@@ -0,0 +1,34 @@
+import { type BuiltinPlugin, BuiltinPluginName, type RawProvideOptions } from "../binding";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+import type { Compiler } from "../Compiler";
+export type ProvideSharedPluginOptions<Enhanced extends boolean = false> = {
+    provides: Provides<Enhanced>;
+    shareScope?: string;
+    enhanced?: Enhanced;
+};
+export type Provides<Enhanced extends boolean> = (ProvidesItem | ProvidesObject<Enhanced>)[] | ProvidesObject<Enhanced>;
+export type ProvidesItem = string;
+export type ProvidesObject<Enhanced extends boolean> = {
+    [k: string]: ProvidesConfig<Enhanced> | ProvidesItem;
+};
+export type ProvidesConfig<Enhanced extends boolean> = Enhanced extends true ? ProvidesEnhancedConfig : ProvidesV1Config;
+type ProvidesV1Config = {
+    eager?: boolean;
+    shareKey: string;
+    shareScope?: string;
+    version?: false | string;
+};
+type ProvidesEnhancedConfig = ProvidesV1Config & ProvidesEnhancedExtraConfig;
+type ProvidesEnhancedExtraConfig = {
+    singleton?: boolean;
+    strictVersion?: boolean;
+    requiredVersion?: false | string;
+};
+export declare class ProvideSharedPlugin<Enhanced extends boolean = false> extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _provides: [string, Omit<RawProvideOptions, "key">][];
+    _enhanced?: Enhanced;
+    constructor(options: ProvideSharedPluginOptions<Enhanced>);
+    raw(compiler: Compiler): BuiltinPlugin;
+}
+export {};

package/dist/sharing/SharePlugin.d.ts

@@ -0,0 +1,51 @@
+import type { Compiler } from "../Compiler";
+export type SharePluginOptions = {
+    shareScope?: string;
+    shared: Shared;
+    enhanced: boolean;
+};
+export type Shared = (SharedItem | SharedObject)[] | SharedObject;
+export type SharedItem = string;
+export type SharedObject = {
+    [k: string]: SharedConfig | SharedItem;
+};
+export type SharedConfig = {
+    eager?: boolean;
+    import?: false | SharedItem;
+    packageName?: string;
+    requiredVersion?: false | string;
+    shareKey?: string;
+    shareScope?: string;
+    singleton?: boolean;
+    strictVersion?: boolean;
+    version?: false | string;
+};
+export declare class SharePlugin {
+    _shareScope: string | undefined;
+    _consumes: {
+        [x: string]: {
+            import: string | false | undefined;
+            shareKey: string;
+            shareScope: string | undefined;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean | undefined;
+            singleton: boolean | undefined;
+            packageName: string | undefined;
+            eager: boolean | undefined;
+        };
+    }[];
+    _provides: {
+        [x: string]: {
+            shareKey: string;
+            shareScope: string | undefined;
+            version: string | false | undefined;
+            eager: boolean | undefined;
+            singleton: boolean | undefined;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean | undefined;
+        };
+    }[];
+    _enhanced: boolean;
+    constructor(options: SharePluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/sharing/ShareRuntimePlugin.d.ts

@@ -0,0 +1,9 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+import type { Compiler } from "../Compiler";
+export declare class ShareRuntimePlugin extends RspackBuiltinPlugin {
+    private enhanced;
+    name: BuiltinPluginName;
+    constructor(enhanced?: boolean);
+    raw(compiler: Compiler): BuiltinPlugin | undefined;
+}

package/dist/sharing/utils.d.ts

@@ -0,0 +1 @@
+export declare function isRequiredVersion(str: string): boolean;

package/dist/stats/DefaultStatsFactoryPlugin.d.ts

@@ -0,0 +1,20 @@
+import type { Compiler } from "../Compiler";
+export declare const SHARED_ITEM_NAMES: {
+    "compilation.children[]": string;
+    "compilation.modules[]": string;
+    "compilation.entrypoints[]": string;
+    "compilation.namedChunkGroups[]": string;
+    "compilation.errors[]": string;
+    "chunk.modules[]": string;
+    "chunk.origins[]": string;
+    "compilation.chunks[]": string;
+    "compilation.assets[]": string;
+    "asset.related[]": string;
+    "module.issuerPath[]": string;
+    "module.reasons[]": string;
+    "module.modules[]": string;
+    "module.children[]": string;
+};
+export declare class DefaultStatsFactoryPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/stats/DefaultStatsPresetPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from "../Compiler";
+export declare class DefaultStatsPresetPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/stats/DefaultStatsPrinterPlugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+import type { Compiler } from "../Compiler";
+export declare class DefaultStatsPrinterPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/stats/StatsFactory.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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
+ */
+import type { JsStats, JsStatsCompilation, JsStatsError } from "../binding";
+import { HookMap, SyncBailHook, SyncWaterfallHook } from "@rspack/lite-tapable";
+import type { Compilation } from "../Compilation";
+import { type GroupConfig } from "../util/smartGrouping";
+export type KnownStatsFactoryContext = {
+    type: string;
+    makePathsRelative?: ((arg0: string) => string) | undefined;
+    compilation: Compilation;
+    cachedGetErrors?: ((arg0: Compilation) => JsStatsError[]) | undefined;
+    cachedGetWarnings?: ((arg0: Compilation) => JsStatsError[]) | undefined;
+    getStatsCompilation: (compilation: Compilation) => JsStatsCompilation;
+    getInner: (compilation: Compilation) => JsStats;
+};
+export type StatsFactoryContext = KnownStatsFactoryContext & Record<string, any>;
+type Hooks = Readonly<{
+    extract: HookMap<SyncBailHook<[Object, any, StatsFactoryContext], undefined>>;
+    filter: HookMap<SyncBailHook<[any, StatsFactoryContext, number, number], undefined>>;
+    filterSorted: HookMap<SyncBailHook<[any, StatsFactoryContext, number, number], undefined>>;
+    groupResults: HookMap<SyncBailHook<[GroupConfig<any>[], StatsFactoryContext], undefined>>;
+    filterResults: HookMap<SyncBailHook<[any, StatsFactoryContext, number, number], undefined>>;
+    sort: HookMap<SyncBailHook<[
+        ((arg1: any, arg2: any) => number)[],
+        StatsFactoryContext
+    ], undefined>>;
+    sortResults: HookMap<SyncBailHook<[
+        ((arg1: any, arg2: any) => number)[],
+        StatsFactoryContext
+    ], undefined>>;
+    result: HookMap<SyncWaterfallHook<[any[], StatsFactoryContext]>>;
+    merge: HookMap<SyncBailHook<[any[], StatsFactoryContext], undefined>>;
+    getItemName: HookMap<SyncBailHook<[any, StatsFactoryContext], string | undefined>>;
+    getItemFactory: HookMap<SyncBailHook<[any, StatsFactoryContext], undefined>>;
+}>;
+type CacheHookMap = Map<string, SyncBailHook<[any[], StatsFactoryContext], any>[]>;
+type CallFn = (...args: any[]) => any;
+export declare class StatsFactory {
+    hooks: Hooks;
+    private _caches;
+    private _inCreate;
+    constructor();
+    _getAllLevelHooks(hookMap: HookMap<any>, cache: CacheHookMap, type: string): any[];
+    _forEachLevel(hookMap: HookMap<any>, cache: CacheHookMap, type: string, fn: CallFn): any;
+    _forEachLevelWaterfall(hookMap: HookMap<any>, cache: CacheHookMap, type: string, data: any, fn: CallFn): any;
+    _forEachLevelFilter(hookMap: HookMap<any>, cache: CacheHookMap, type: string, items: any[], fn: CallFn, forceClone: boolean): any[];
+    create(type: string, data: any, baseContext: Omit<StatsFactoryContext, "type">): any;
+    private _create;
+}
+export {};

package/dist/stats/StatsPrinter.d.ts

@@ -0,0 +1,57 @@
+import { HookMap, SyncBailHook, SyncWaterfallHook } from "@rspack/lite-tapable";
+import type { StatsAsset, StatsChunk, StatsChunkGroup, StatsCompilation, StatsModule, StatsModuleReason } from "./statsFactoryUtils";
+type PrintedElement = {
+    element: string;
+    content: string;
+};
+type KnownStatsPrinterContext = {
+    type?: string;
+    compilation?: StatsCompilation;
+    chunkGroup?: StatsChunkGroup;
+    asset?: StatsAsset;
+    module?: StatsModule;
+    chunk?: StatsChunk;
+    moduleReason?: StatsModuleReason;
+    bold?: (str: string) => string;
+    yellow?: (str: string) => string;
+    red?: (str: string) => string;
+    green?: (str: string) => string;
+    magenta?: (str: string) => string;
+    cyan?: (str: string) => string;
+    formatFilename?: (file: string, oversize?: boolean) => string;
+    formatModuleId?: (id: string) => string;
+    formatChunkId?: ((id: string, direction?: "parent" | "child" | "sibling") => string) | undefined;
+    formatSize?: (size: number) => string;
+    formatDateTime?: (dateTime: number) => string;
+    formatFlag?: (flag: string) => string;
+    formatTime?: (time: number, boldQuantity?: boolean) => string;
+    chunkGroupKind?: string;
+};
+export type StatsPrinterContext = KnownStatsPrinterContext & Record<string, any>;
+export declare class StatsPrinter {
+    private _levelHookCache;
+    private _inPrint;
+    hooks: Readonly<{
+        sortElements: HookMap<SyncBailHook<[string[], StatsPrinterContext], true | void>>;
+        printElements: HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string>>;
+        sortItems: HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>;
+        getItemName: HookMap<SyncBailHook<[any, StatsPrinterContext], string>>;
+        printItems: HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>;
+        print: HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>;
+        result: HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>;
+    }>;
+    constructor();
+    /**
+     * get all level hooks
+     */
+    private _getAllLevelHooks;
+    private _forEachLevel;
+    private _forEachLevelWaterfall;
+    print(type: string, object: {
+        [key: string]: any;
+    }, baseContext?: {
+        [key: string]: any;
+    }): string;
+    private _print;
+}
+export {};