@rspack/core 0.7.6-canary-1a0d77d-20240627143904 → 1.0.0-alpha.1

package/dist/stats/DefaultStatsPrinterPlugin.js

@@ -357,13 +357,13 @@ const SIMPLE_PRINTERS = {
     // 	chunkEntry ? formatFlag("entry") : undefined,
     // "error.chunkInitial": (chunkInitial, { formatFlag }) =>
     // 	chunkInitial ? formatFlag("initial") : undefined,
-    // "error.file": (file, { bold }) => bold(file),
+    "error.file": (file, { bold }) => bold(file),
     "error.moduleName": (moduleName, { bold }) => {
         return moduleName.includes("!")
             ? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})`
             : `${bold(moduleName)}`;
     },
-    // "error.loc": (loc, { green }) => green(loc),
+    "error.loc": (loc, { green }) => green(loc),
     "error.message": (message, { bold, formatError }) => message.includes("\u001b[") ? message : bold(formatError(message)),
     // "error.details": (details, { formatError }) => formatError(details),
     // "error.stack": stack => stack,

package/dist/stats/StatsFactory.d.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import { JsStats, JsStatsError, JsStatsWarning } from "@rspack/binding";
-import { HookMap, SyncBailHook, SyncWaterfallHook } from "tapable";
+import { HookMap, SyncBailHook, SyncWaterfallHook } from "@rspack/lite-tapable";
 import type { Compilation } from "../Compilation";
 import { GroupConfig } from "../util/smartGrouping";
 export type KnownStatsFactoryContext = {
@@ -34,7 +34,7 @@ type Hooks = Readonly<{
         ((arg1: any, arg2: any) => number)[],
         StatsFactoryContext
     ], undefined>>;
-    result: HookMap<SyncWaterfallHook<[any[], 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>>;

package/dist/stats/StatsFactory.js

@@ -1,39 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsFactory = void 0;
-const tapable_1 = require("tapable");
+const lite_tapable_1 = require("@rspack/lite-tapable");
 const comparators_1 = require("../util/comparators");
 const smartGrouping_1 = require("../util/smartGrouping");
 class StatsFactory {
     constructor() {
         this.hooks = Object.freeze({
-            extract: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            extract: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "object",
                 "data",
                 "context"
             ])),
-            filter: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(["item", "context", "index", "unfilteredIndex"])),
-            sort: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(["comparators", "context"])),
-            filterSorted: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(["item", "context", "index", "unfilteredIndex"])),
-            groupResults: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            filter: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook(["item", "context", "index", "unfilteredIndex"])),
+            sort: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook(["comparators", "context"])),
+            filterSorted: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook(["item", "context", "index", "unfilteredIndex"])),
+            groupResults: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "groupConfigs",
                 "context"
             ])),
-            sortResults: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(["comparators", "context"])),
-            filterResults: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(["item", "context", "index", "unfilteredIndex"])),
-            merge: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            sortResults: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook(["comparators", "context"])),
+            filterResults: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook(["item", "context", "index", "unfilteredIndex"])),
+            merge: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "items",
                 "context"
             ])),
-            result: new tapable_1.HookMap(() => new tapable_1.SyncWaterfallHook([
+            result: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncWaterfallHook([
                 "result",
                 "context"
             ])),
-            getItemName: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            getItemName: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "item",
                 "context"
             ])),
-            getItemFactory: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            getItemFactory: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "item",
                 "context"
             ]))

package/dist/stats/StatsPrinter.d.ts

@@ -1,4 +1,4 @@
-import { HookMap, SyncBailHook, SyncWaterfallHook } from "tapable";
+import { HookMap, SyncBailHook, SyncWaterfallHook } from "@rspack/lite-tapable";
 import type { StatsAsset, StatsChunk, StatsChunkGroup, StatsCompilation, StatsModule, StatsModuleReason } from "./statsFactoryUtils";
 type PrintedElement = {
     element: string;

package/dist/stats/StatsPrinter.js

@@ -1,35 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsPrinter = void 0;
-const tapable_1 = require("tapable");
+const lite_tapable_1 = require("@rspack/lite-tapable");
 class StatsPrinter {
     constructor() {
         this.hooks = Object.freeze({
-            sortElements: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            sortElements: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "elements",
                 "context"
             ])),
-            printElements: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            printElements: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "printedElements",
                 "context"
             ])),
-            sortItems: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            sortItems: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "items",
                 "context"
             ])),
-            getItemName: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            getItemName: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "item",
                 "context"
             ])),
-            printItems: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            printItems: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "printedItems",
                 "context"
             ])),
-            print: new tapable_1.HookMap(() => new tapable_1.SyncBailHook([
+            print: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncBailHook([
                 "object",
                 "context"
             ])),
-            result: new tapable_1.HookMap(() => new tapable_1.SyncWaterfallHook([
+            result: new lite_tapable_1.HookMap(() => new lite_tapable_1.SyncWaterfallHook([
                 "result",
                 "context"
             ]))

package/dist/stats/statsFactoryUtils.d.ts

@@ -3,9 +3,16 @@ import type { Compilation, NormalizedStatsOptions } from "../Compilation";
 import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
 export type KnownStatsChunkGroup = binding.JsStatsChunkGroup;
-export type KnownStatsChunk = binding.JsStatsChunk;
+export type KnownStatsChunk = Omit<binding.JsStatsChunk, "sizes"> & {
+    sizes: Record<string, number>;
+};
+export type KnownStatsAssetInfo = Omit<binding.JsStatsAssetInfo, "related"> & {
+    related: Record<string, string[]>;
+};
 export type StatsChunkGroup = binding.JsStatsChunkGroup & Record<string, any>;
-export type KnownStatsAsset = binding.JsStatsAsset;
+export type KnownStatsAsset = Omit<binding.JsStatsAsset, "info"> & {
+    info: KnownStatsAssetInfo;
+};
 export type StatsAsset = KnownStatsAsset & Record<string, any>;
 export type StatsChunk = KnownStatsChunk & Record<string, any>;
 export type KnownStatsModule = Omit<binding.JsStatsModule, "usedExports" | "providedExports" | "optimizationBailout" | "sizes"> & {
@@ -14,12 +21,13 @@ export type KnownStatsModule = Omit<binding.JsStatsModule, "usedExports" | "prov
     providedExports?: null | string[];
     optimizationBailout?: null | string[];
     sizes: Record<string, number>;
+    index?: number;
+    index2?: number;
 };
 export type StatsProfile = KnownStatsProfile & Record<string, any>;
 export type KnownStatsProfile = {
     total: number;
     resolving: number;
-    integration: number;
     building: number;
 };
 export type StatsModule = KnownStatsModule & Record<string, any>;
@@ -85,6 +93,7 @@ type ExtractorsByOption<T, O> = {
 type PreprocessedAsset = StatsAsset & {
     type: string;
     related: PreprocessedAsset[];
+    info: binding.JsStatsAssetInfo;
 };
 export type SimpleExtractors = {
     compilation: ExtractorsByOption<Compilation, StatsCompilation>;
@@ -95,7 +104,7 @@ export type SimpleExtractors = {
     moduleIssuer: ExtractorsByOption<binding.JsStatsModuleIssuer, StatsModuleIssuer>;
     profile: ExtractorsByOption<binding.JsStatsModuleProfile, StatsProfile>;
     moduleReason: ExtractorsByOption<binding.JsStatsModuleReason, StatsModuleReason>;
-    chunk: ExtractorsByOption<StatsChunk, KnownStatsChunk>;
+    chunk: ExtractorsByOption<binding.JsStatsChunk, KnownStatsChunk>;
 };
 export declare const uniqueArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>) => I[];
 export declare const uniqueOrderedArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>, comparator: Comparator) => I[];

package/dist/util/SplitChunkSize.d.ts

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

package/dist/util/SplitChunkSize.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsSplitChunkSizes = void 0;
+class JsSplitChunkSizes {
+    static __to_binding(sizes) {
+        if (typeof sizes === "number") {
+            return sizes;
+        }
+        else if (sizes && typeof sizes === "object") {
+            const chunkSizes = {
+                sizes: sizes
+            };
+            return chunkSizes;
+        }
+        return sizes;
+    }
+}
+exports.JsSplitChunkSizes = JsSplitChunkSizes;

package/dist/util/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { JsStatsError } from "@rspack/binding";
+import type { JsRspackError, JsStatsError } from "@rspack/binding";
 import { LoaderObject } from "../loader-runner";
 export declare function mapValues(record: Record<string, string>, fn: (key: string) => string): {
     [k: string]: string;
@@ -10,7 +10,7 @@ export declare const toObject: (input: string | Buffer | object) => object;
 export declare function serializeObject(map: string | object | undefined | null): Buffer | undefined;
 export declare function isPromiseLike(value: unknown): value is Promise<any>;
 export declare function isJsStatsError(err: any): err is JsStatsError;
-export declare function concatErrorMsgAndStack(err: Error | JsStatsError | string): string;
+export declare function concatErrorMsgAndStack(err: Error | JsRspackError | string): JsRspackError;
 export declare function indent(str: string, prefix: string): string;
 export declare function stringifyLoaderObject(o: LoaderObject): string;
 export declare function asArray<T>(item: T[]): T[];

package/dist/util/index.js

@@ -61,12 +61,13 @@ function isJsStatsError(err) {
 exports.isJsStatsError = isJsStatsError;
 function concatErrorMsgAndStack(err) {
     if (typeof err === "string") {
-        return err;
+        return new Error(err);
     }
     if ("stack" in err) {
-        return err.stack || err.message;
+        err.message = err.stack || err.message;
+        return err;
     }
-    return err.message;
+    return err;
 }
 exports.concatErrorMsgAndStack = concatErrorMsgAndStack;
 function indent(str, prefix) {

package/dist/util/memoize.js

@@ -37,7 +37,11 @@ function memoizeValue(fn) {
     const getValue = (0, exports.memoize)(fn);
     return new Proxy({}, {
         get(_, property) {
-            return getValue()[property];
+            let res = getValue()[property];
+            if (typeof res === "function") {
+                res = res.bind(getValue());
+            }
+            return res;
         },
         set(_, property, newValue) {
             getValue()[property] = newValue;

package/dist/util/source.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { JsCompatSource } from "@rspack/binding";
-import { Source } from "webpack-sources";
+import { Source } from "../../compiled/webpack-sources";
 declare class JsSource extends Source {
     static __from_binding(source: JsCompatSource): Source;
     static __to_binding(source: Source): {

package/dist/util/source.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsSource = void 0;
-const webpack_sources_1 = require("webpack-sources");
+const webpack_sources_1 = require("../../compiled/webpack-sources");
 const index_1 = require("./index");
 class JsSource extends webpack_sources_1.Source {
     static __from_binding(source) {

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@rspack/core",
-  "version": "0.7.6-canary-1a0d77d-20240627143904",
+  "version": "1.0.0-alpha.1",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "exports": {
     ".": {
       "default": "./dist/index.js"
@@ -72,17 +76,17 @@
     "tsc-alias": "^1.8.8",
     "wast-loader": "^1.11.4",
     "watchpack": "^2.4.0",
+    "webpack-sources": "3.2.3",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1",
-    "@rspack/core": "0.7.6-canary-1a0d77d-20240627143904",
-    "@rspack/plugin-minify": "^0.7.6-canary-1a0d77d-20240627143904"
+    "@rspack/core": "1.0.0-alpha.1",
+    "@rspack/plugin-minify": "^1.0.0-alpha.1"
   },
   "dependencies": {
-    "@module-federation/runtime-tools": "0.1.6",
+    "@module-federation/runtime-tools": "0.2.3",
     "caniuse-lite": "^1.0.30001616",
-    "tapable": "2.2.1",
-    "webpack-sources": "3.2.3",
-    "@rspack/binding": "0.7.6-canary-1a0d77d-20240627143904"
+    "@rspack/binding": "1.0.0-alpha.1",
+    "@rspack/lite-tapable": "1.0.0-alpha.1"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"
@@ -93,9 +97,10 @@
     }
   },
   "scripts": {
-    "build": "prebundle && tsc -b ./tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "build:force": "prebundle && tsc -b ./tsconfig.build.json --force && tsc-alias -p tsconfig.build.json",
+    "build": "prebundle && tsc -b ./tsconfig.build.json && tsc-alias -p tsconfig.build.json && npm run prepare-container-runtime",
+    "build:force": "prebundle && tsc -b ./tsconfig.build.json --force && tsc-alias -p tsconfig.build.json && npm run prepare-container-runtime",
     "dev": "prebundle && tsc -w",
+    "prepare-container-runtime": "node ./scripts/prepare-container-runtime.js",
     "doc-coverage": "node scripts/check-documentation-coverage.mjs",
     "api-extractor": "api-extractor run --verbose",
     "api-extractor:ci": "api-extractor run --verbose || diff temp/api.md etc/api.md"

package/dist/builtin-loader/swc/emotion.d.ts

@@ -1,17 +0,0 @@
-type EmotionConfigImportMap = {
-    [packageName: string]: {
-        [exportName: string]: {
-            canonicalImport?: [string, string];
-        };
-    };
-};
-type EmotionConfig = {
-    sourceMap?: boolean;
-    autoLabel?: "never" | "dev-only" | "always";
-    labelFormat?: string;
-    importMap?: EmotionConfigImportMap;
-};
-type EmotionOptions = boolean | EmotionConfig | undefined;
-declare function resolveEmotion(emotion: EmotionOptions, isProduction: boolean): EmotionConfig | undefined;
-export { resolveEmotion };
-export type { EmotionOptions };

package/dist/builtin-loader/swc/emotion.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEmotion = void 0;
-function resolveEmotion(emotion, isProduction) {
-    if (!emotion) {
-        return undefined;
-    }
-    if (emotion === true) {
-        emotion = {};
-    }
-    const autoLabel = emotion?.autoLabel ?? "dev-only";
-    const emotionConfig = {
-        enabled: true,
-        // @ts-expect-error autoLabel is string for JavaScript interface, however is boolean for Rust interface
-        autoLabel: autoLabel === "dev-only" ? !isProduction : autoLabel === "always",
-        importMap: emotion?.importMap,
-        labelFormat: emotion?.labelFormat ?? "[local]",
-        sourcemap: isProduction ? false : emotion?.sourceMap ?? true
-    };
-    return emotionConfig;
-}
-exports.resolveEmotion = resolveEmotion;

package/dist/builtin-loader/swc/relay.d.ts

@@ -1,5 +0,0 @@
-import type { RawRelayConfig } from "@rspack/binding";
-type RelayOptions = boolean | RawRelayConfig | undefined;
-declare function resolveRelay(relay: RelayOptions, rootDir: string): RawRelayConfig | undefined;
-export { resolveRelay };
-export type { RelayOptions };

package/dist/builtin-loader/swc/relay.js

@@ -1,48 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveRelay = void 0;
-const path_1 = __importDefault(require("path"));
-function getRelayConfigFromProject(rootDir) {
-    for (const configName of [
-        "relay.config.json",
-        "relay.config.js",
-        "package.json"
-    ]) {
-        const configPath = path_1.default.join(rootDir, configName);
-        try {
-            let config = require(configPath);
-            let finalConfig;
-            if (configName === "package.json") {
-                finalConfig = config?.relay;
-            }
-            else {
-                finalConfig = config;
-            }
-            if (finalConfig) {
-                return {
-                    language: finalConfig.language,
-                    artifactDirectory: finalConfig.artifactDirectory
-                };
-            }
-        }
-        catch (_) { }
-    }
-}
-function resolveRelay(relay, rootDir) {
-    if (!relay) {
-        return undefined;
-    }
-    // Search relay config based on
-    if (relay === true) {
-        return (getRelayConfigFromProject(rootDir) || {
-            language: "javascript"
-        });
-    }
-    else {
-        return relay;
-    }
-}
-exports.resolveRelay = resolveRelay;

package/dist/container/default.runtime.d.ts

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

package/dist/lite-tapable/index.d.ts

@@ -1,146 +0,0 @@
-type FixedSizeArray<T extends number, U> = T extends 0 ? void[] : ReadonlyArray<U> & {
-    0: U;
-    length: T;
-};
-type Measure<T extends number> = T extends 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 ? T : never;
-type Append<T extends any[], U> = {
-    0: [U];
-    1: [T[0], U];
-    2: [T[0], T[1], U];
-    3: [T[0], T[1], T[2], U];
-    4: [T[0], T[1], T[2], T[3], U];
-    5: [T[0], T[1], T[2], T[3], T[4], U];
-    6: [T[0], T[1], T[2], T[3], T[4], T[5], U];
-    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], U];
-    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], U];
-}[Measure<T["length"]>];
-export type AsArray<T> = T extends any[] ? T : [T];
-export type Fn<T, R> = (...args: AsArray<T>) => R;
-export type FnWithCallback<T, R> = (...args: Append<AsArray<T>, InnerCallback<Error, R>>) => void;
-declare class UnsetAdditionalOptions {
-    _UnsetAdditionalOptions: true;
-}
-type IfSet<X> = X extends UnsetAdditionalOptions ? {} : X;
-type Callback<E, T> = (error: E | null, result?: T) => void;
-type InnerCallback<E, T> = (error?: E | null | false, result?: T) => void;
-type FullTap = Tap & {
-    type: "sync" | "async" | "promise";
-    fn: Function;
-};
-type Tap = TapOptions & {
-    name: string;
-};
-type TapOptions = {
-    before?: string;
-    stage?: number;
-};
-export type Options<AdditionalOptions = UnsetAdditionalOptions> = string | (Tap & IfSet<AdditionalOptions>);
-export interface HookInterceptor<T, R, AdditionalOptions = UnsetAdditionalOptions> {
-    name?: string;
-    tap?: (tap: FullTap & IfSet<AdditionalOptions>) => void;
-    call?: (...args: any[]) => void;
-    loop?: (...args: any[]) => void;
-    error?: (err: Error) => void;
-    result?: (result: R) => void;
-    done?: () => void;
-    register?: (tap: FullTap & IfSet<AdditionalOptions>) => FullTap & IfSet<AdditionalOptions>;
-}
-type ArgumentNames<T extends any[]> = FixedSizeArray<T["length"], string>;
-export declare class Hook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
-    args?: ArgumentNames<AsArray<T>>;
-    name?: string;
-    taps: (FullTap & IfSet<AdditionalOptions>)[];
-    interceptors: HookInterceptor<T, R, AdditionalOptions>[];
-    constructor(args?: ArgumentNames<AsArray<T>>, name?: string);
-    intercept(interceptor: HookInterceptor<T, R, AdditionalOptions>): void;
-    _runRegisterInterceptors(options: FullTap & IfSet<AdditionalOptions>): FullTap & IfSet<AdditionalOptions>;
-    _runCallInterceptors(...args: any[]): void;
-    _runErrorInterceptors(e: Error): void;
-    _runTapInterceptors(tap: FullTap & IfSet<AdditionalOptions>): void;
-    _runDoneInterceptors(): void;
-    _runResultInterceptors(r: R): void;
-    isUsed(): boolean;
-    queryStageRange(stageRange: StageRange): QueriedHook<T, R, AdditionalOptions>;
-    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    callAsync(...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    promiseStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): Promise<R>;
-    promise(...args: AsArray<T>): Promise<R>;
-    tap(options: Options<AdditionalOptions>, fn: Fn<T, R>): void;
-    _tap(type: "sync" | "async" | "promise", options: Options<AdditionalOptions>, fn: Function): void;
-    _insert(item: FullTap & IfSet<AdditionalOptions>): void;
-}
-export type StageRange = readonly [number, number];
-export declare const minStage: number;
-export declare const maxStage: number;
-export declare const safeStage: (stage: number) => number;
-export declare class QueriedHook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
-    stageRange: StageRange;
-    hook: Hook<T, R, AdditionalOptions>;
-    tapsInRange: (FullTap & IfSet<AdditionalOptions>)[];
-    constructor(stageRange: StageRange, hook: Hook<T, R, AdditionalOptions>);
-    isUsed(): boolean;
-    call(...args: AsArray<T>): R;
-    callAsync(...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    promise(...args: AsArray<T>): Promise<R>;
-}
-export declare class SyncHook<T, R = void, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
-    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    call(...args: AsArray<T>): R;
-    callStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): R;
-    tapAsync(): never;
-    tapPromise(): never;
-}
-export declare class SyncBailHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
-    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    call(...args: AsArray<T>): R;
-    callStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): R;
-    tapAsync(): never;
-    tapPromise(): never;
-}
-export declare class AsyncParallelHook<T, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, void, AdditionalOptions> {
-    callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
-    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
-    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
-}
-export declare class AsyncSeriesHook<T, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, void, AdditionalOptions> {
-    callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
-    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
-    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
-}
-export declare class AsyncSeriesBailHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
-    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
-    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
-}
-export declare class AsyncSeriesWaterfallHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
-    constructor(args?: ArgumentNames<AsArray<T>>, name?: string);
-    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
-    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
-}
-export type HookMapKey = any;
-export type HookFactory<H> = (key: HookMapKey, hook?: H) => H;
-export interface HookMapInterceptor<H> {
-    factory?: HookFactory<H>;
-}
-export declare class HookMap<H extends Hook<any, any, any>> {
-    _map: Map<HookMapKey, H>;
-    _factory: HookFactory<H>;
-    name?: string;
-    _interceptors: HookMapInterceptor<H>[];
-    constructor(factory: HookFactory<H>, name?: string);
-    get(key: HookMapKey): H | undefined;
-    for(key: HookMapKey): H;
-    intercept(interceptor: HookMapInterceptor<H>): void;
-    isUsed(): boolean;
-    queryStageRange(stageRange: StageRange): QueriedHookMap<H>;
-}
-export declare class QueriedHookMap<H extends Hook<any, any, any>> {
-    stageRange: StageRange;
-    hookMap: HookMap<H>;
-    constructor(stageRange: StageRange, hookMap: HookMap<H>);
-    get(key: HookMapKey): QueriedHook<any, any, any> | undefined;
-    for(key: HookMapKey): QueriedHook<any, any, any>;
-    isUsed(): boolean;
-}
-export {};