@rspack/core 1.0.0-alpha.5 → 1.0.0-beta.1

package/dist/config/zod.js

@@ -4,6 +4,11 @@ exports.rspackOptions = exports.externalsType = void 0;
 const zod_1 = require("../../compiled/zod");
 const Chunk_1 = require("../Chunk");
 const Module_1 = require("../Module");
+const filenameTemplate = zod_1.z.string();
+const filename = filenameTemplate.or(zod_1.z
+    .function()
+    .args(zod_1.z.custom(), zod_1.z.custom().optional())
+    .returns(zod_1.z.string()));
 //#region Name
 const name = zod_1.z.string();
 //#endregion
@@ -26,8 +31,7 @@ const falsy = zod_1.z.union([
 ]);
 //#endregion
 //#region Entry
-const rawPublicPath = zod_1.z.string();
-const publicPath = zod_1.z.literal("auto").or(rawPublicPath);
+const publicPath = zod_1.z.literal("auto").or(filename);
 const baseUri = zod_1.z.string();
 const chunkLoadingType = zod_1.z
     .enum(["jsonp", "import-scripts", "require", "async-node", "import"])
@@ -89,12 +93,8 @@ const libraryOptions = zod_1.z.strictObject({
     umdNamedDefine: umdNamedDefine.optional()
 });
 const library = libraryName.or(libraryOptions).optional();
-const filenameTemplate = zod_1.z.string();
-const filename = filenameTemplate.or(zod_1.z
-    .function()
-    .args(zod_1.z.custom(), zod_1.z.custom().optional())
-    .returns(zod_1.z.string()));
-const entryFilename = filenameTemplate;
+const layer = zod_1.z.string().or(zod_1.z.null());
+const entryFilename = filename;
 const entryRuntime = zod_1.z.literal(false).or(zod_1.z.string());
 const entryItem = zod_1.z.string().or(zod_1.z.array(zod_1.z.string()));
 const entryDependOn = zod_1.z.string().or(zod_1.z.array(zod_1.z.string()));
@@ -108,7 +108,8 @@ const entryDescription = zod_1.z.strictObject({
     wasmLoading: wasmLoading.optional(),
     filename: entryFilename.optional(),
     library: libraryOptions.optional(),
-    dependOn: entryDependOn.optional()
+    dependOn: entryDependOn.optional(),
+    layer: layer.optional()
 });
 const entryUnnamed = entryItem;
 const entryObject = zod_1.z.record(entryItem.or(entryDescription));
@@ -139,6 +140,7 @@ const strictModuleErrorHandling = zod_1.z.boolean();
 const globalObject = zod_1.z.string();
 const enabledWasmLoadingTypes = zod_1.z.array(wasmLoadingType);
 const importFunctionName = zod_1.z.string();
+const importMetaName = zod_1.z.string();
 const iife = zod_1.z.boolean();
 const enabledChunkLoadingTypes = zod_1.z.array(chunkLoadingType);
 const chunkFormat = zod_1.z.literal(false).or(zod_1.z.string());
@@ -200,6 +202,7 @@ const output = zod_1.z.strictObject({
     strictModuleErrorHandling: strictModuleErrorHandling.optional(),
     globalObject: globalObject.optional(),
     importFunctionName: importFunctionName.optional(),
+    importMetaName: importMetaName.optional(),
     iife: iife.optional(),
     wasmLoading: wasmLoading.optional(),
     enabledWasmLoadingTypes: enabledWasmLoadingTypes.optional(),
@@ -221,6 +224,8 @@ const output = zod_1.z.strictObject({
     devtoolNamespace: devtoolNamespace.optional(),
     devtoolModuleFilenameTemplate: devtoolModuleFilenameTemplate.optional(),
     devtoolFallbackModuleFilenameTemplate: devtoolFallbackModuleFilenameTemplate.optional(),
+    chunkLoadTimeout: zod_1.z.number().optional(),
+    charset: zod_1.z.boolean().optional(),
     environment: environment.optional()
 });
 //#endregion
@@ -290,6 +295,7 @@ const baseRuleSetRule = zod_1.z.strictObject({
     exclude: ruleSetCondition.optional(),
     include: ruleSetCondition.optional(),
     issuer: ruleSetCondition.optional(),
+    issuerLayer: ruleSetCondition.optional(),
     dependency: ruleSetCondition.optional(),
     resource: ruleSetCondition.optional(),
     resourceFragment: ruleSetCondition.optional(),
@@ -297,7 +303,9 @@ const baseRuleSetRule = zod_1.z.strictObject({
     scheme: ruleSetCondition.optional(),
     mimetype: ruleSetCondition.optional(),
     descriptionData: zod_1.z.record(ruleSetCondition).optional(),
+    with: zod_1.z.record(ruleSetCondition).optional(),
     type: zod_1.z.string().optional(),
+    layer: zod_1.z.string().optional(),
     loader: ruleSetLoader.optional(),
     options: ruleSetLoaderOptions.optional(),
     use: ruleSetUse.optional(),
@@ -351,6 +359,7 @@ const javascriptParserOptions = zod_1.z.strictObject({
     dynamicImportPreload: dynamicImportPreload.optional(),
     dynamicImportPrefetch: dynamicImportPrefetch.optional(),
     dynamicImportFetchPriority: dynamicImportFetchPriority.optional(),
+    importMeta: zod_1.z.boolean().optional(),
     url: javascriptParserUrl.optional(),
     exprContextCritical: exprContextCritical.optional(),
     wrappedContextCritical: wrappedContextCritical.optional(),
@@ -390,7 +399,7 @@ const assetInlineGeneratorOptions = zod_1.z.strictObject({
 });
 const assetResourceGeneratorOptions = zod_1.z.strictObject({
     emit: zod_1.z.boolean().optional(),
-    filename: filenameTemplate.optional(),
+    filename: filename.optional(),
     publicPath: publicPath.optional()
 });
 const assetGeneratorOptions = assetInlineGeneratorOptions.merge(assetResourceGeneratorOptions);
@@ -519,7 +528,12 @@ const externalItemObjectUnknown = zod_1.z.record(externalItemValue);
 const externalItemFunctionData = zod_1.z.strictObject({
     context: zod_1.z.string().optional(),
     dependencyType: zod_1.z.string().optional(),
-    request: zod_1.z.string().optional()
+    request: zod_1.z.string().optional(),
+    contextInfo: zod_1.z
+        .strictObject({
+        issuer: zod_1.z.string()
+    })
+        .optional()
 });
 const externalItem = zod_1.z
     .string()
@@ -617,12 +631,19 @@ const snapshotOptions = zod_1.z.strictObject({});
 const cacheOptions = zod_1.z.boolean();
 //#endregion
 //#region Stats
+const statsPresets = zod_1.z.enum([
+    "normal",
+    "none",
+    "verbose",
+    "errors-only",
+    "errors-warnings",
+    "minimal",
+    "detailed",
+    "summary"
+]);
 const statsOptions = zod_1.z.strictObject({
     all: zod_1.z.boolean().optional(),
-    preset: zod_1.z
-        .boolean()
-        .or(zod_1.z.enum(["normal", "none", "verbose", "errors-only", "errors-warnings"]))
-        .optional(),
+    preset: zod_1.z.boolean().or(statsPresets).optional(),
     assets: zod_1.z.boolean().optional(),
     chunks: zod_1.z.boolean().optional(),
     modules: zod_1.z.boolean().optional(),
@@ -713,10 +734,7 @@ const statsOptions = zod_1.z.strictObject({
     errorStack: zod_1.z.boolean().optional(),
     moduleTrace: zod_1.z.boolean().optional()
 });
-const statsValue = zod_1.z
-    .enum(["none", "errors-only", "errors-warnings", "normal", "verbose"])
-    .or(zod_1.z.boolean())
-    .or(statsOptions);
+const statsValue = zod_1.z.boolean().or(statsPresets).or(statsOptions);
 const plugin = zod_1.z.union([
     zod_1.z.custom(),
     zod_1.z.custom(),
@@ -847,6 +865,7 @@ const experiments = zod_1.z.strictObject({
     outputModule: zod_1.z.boolean().optional(),
     topLevelAwait: zod_1.z.boolean().optional(),
     css: zod_1.z.boolean().optional(),
+    layers: zod_1.z.boolean().optional(),
     futureDefaults: zod_1.z.boolean().optional(),
     rspackFuture: rspackFutureOptions.optional()
 });

package/dist/container/ContainerPlugin.d.ts

@@ -28,19 +28,19 @@ export declare class ContainerPlugin extends RspackBuiltinPlugin {
         shareScope: string;
         library: {
             type: string;
+            name?: string | string[] | {
+                commonjs?: string | undefined;
+                amd?: string | undefined;
+                root?: string | string[] | undefined;
+            } | undefined;
             amdContainer?: string | undefined;
             auxiliaryComment?: string | {
-                amd?: string | undefined;
                 commonjs?: string | undefined;
-                commonjs2?: string | undefined;
+                amd?: string | undefined;
                 root?: string | undefined;
+                commonjs2?: string | undefined;
             } | undefined;
             export?: string | string[] | undefined;
-            name?: string | string[] | {
-                amd?: string | undefined;
-                commonjs?: string | undefined;
-                root?: string | string[] | undefined;
-            } | undefined;
             umdNamedDefine?: boolean | undefined;
         };
         runtime: string | false | undefined;

package/dist/container/ContainerReferencePlugin.d.ts

@@ -21,7 +21,7 @@ export type RemotesConfig = {
 export declare class ContainerReferencePlugin extends RspackBuiltinPlugin {
     name: BuiltinPluginName;
     _options: {
-        remoteType: "promise" | "module" | "commonjs" | "umd" | "amd" | "jsonp" | "import" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "global" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd2" | "system" | "script" | "node-commonjs";
+        remoteType: "module" | "global" | "system" | "promise" | "commonjs" | "umd" | "amd" | "jsonp" | "import" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd2" | "script" | "node-commonjs";
         remotes: [string, {
             external: string[];
             shareScope: string;

package/dist/container/ModuleFederationRuntimePlugin.d.ts

@@ -3,7 +3,7 @@ export declare const ModuleFederationRuntimePlugin: {
     new (): {
         name: BuiltinPluginName;
         _args: [];
-        affectedHooks: "done" | "compilation" | "failed" | "environment" | "emit" | "make" | "compile" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "shutdown" | "watchRun" | "watchClose" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
+        affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
         raw(compiler: import("../Compiler").Compiler): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("../Compiler").Compiler): void;
     };

package/dist/container/options.js

@@ -28,7 +28,7 @@ const process = (options, normalizeSimple, normalizeOptions, fn) => {
     if (!options) {
         return;
     }
-    else if (Array.isArray(options)) {
+    if (Array.isArray(options)) {
         array(options);
     }
     else if (typeof options === "object") {

package/dist/exports.d.ts

@@ -18,8 +18,7 @@ export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule,
 export { Stats } from "./Stats";
 import * as ModuleFilenameHelpers from "./lib/ModuleFilenameHelpers";
 export { ModuleFilenameHelpers };
-import Template = require("./Template");
-export { Template };
+export { Template } from "./Template";
 export declare const WebpackError: ErrorConstructor;
 export type { Watching } from "./Watching";
 import sources = require("../compiled/webpack-sources");
@@ -34,8 +33,8 @@ type Config = {
 export declare const config: Config;
 export type * from "./config";
 export declare const util: {
-    createHash: (algorithm: any) => any;
-    cleverMerge: <T, O>(first: T, second: O) => T | O | (T & O);
+    createHash: (algorithm: (string & {}) | "debug" | "xxhash64" | "md4" | "native-md4" | (new () => import("./util/hash").default)) => import("./util/hash").default;
+    cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
 };
 export { default as EntryOptionPlugin } from "./lib/EntryOptionPlugin";
 export { type OutputFileSystem } from "./util/fs";
@@ -148,6 +147,7 @@ export { EvalSourceMapDevToolPlugin } from "./builtin-plugin";
 export { EvalDevToolModulePlugin } from "./builtin-plugin";
 export { CssExtractRspackPlugin } from "./builtin-plugin";
 export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./builtin-loader/swc/index";
+export { type LoaderOptions as LightningcssLoaderOptions, type FeatureOptions as LightningcssFeatureOptions } from "./builtin-loader/lightningcss/index";
 import { cleanupGlobalTrace, registerGlobalTrace } from "@rspack/binding";
 interface Experiments {
     globalTrace: {

package/dist/exports.js

@@ -52,8 +52,8 @@ Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { r
 const ModuleFilenameHelpers = __importStar(require("./lib/ModuleFilenameHelpers"));
 exports.ModuleFilenameHelpers = ModuleFilenameHelpers;
 // API extractor not working with some re-exports, see: https://github.com/microsoft/fluentui/issues/20694
-const Template = require("./Template");
-exports.Template = Template;
+var Template_1 = require("./Template");
+Object.defineProperty(exports, "Template", { enumerable: true, get: function () { return Template_1.Template; } });
 exports.WebpackError = Error;
 const sources = require("../compiled/webpack-sources");
 exports.sources = sources;

package/dist/lib/AbstractMethodError.d.ts

@@ -1,4 +1,13 @@
-export = AbstractMethodError;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/AbstractMethodError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import WebpackError from "./WebpackError";
 /**
  * Error for abstract method
  * @example
@@ -9,7 +18,7 @@ export = AbstractMethodError;
  * }
  *
  */
-declare class AbstractMethodError extends WebpackError {
+export declare class AbstractMethodError extends WebpackError {
     constructor();
 }
-import WebpackError = require("./WebpackError");
+export default AbstractMethodError;

package/dist/lib/AbstractMethodError.js

@@ -1,29 +1,36 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Ivan Kopeykin @vankop
-*/
 "use strict";
-const WebpackError = require("./WebpackError");
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/AbstractMethodError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMethodError = void 0;
+const WebpackError_1 = __importDefault(require("./WebpackError"));
 const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
 /**
- * @param {string=} method method name
- * @returns {string} message
+ * @param method method name
+ * @returns message
  */
 function createMessage(method) {
     return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
 }
-/**
- * @constructor
- */
-function Message() {
-    /** @type {string} */
-    // @ts-expect-error
-    this.stack = undefined;
-    Error.captureStackTrace(this);
-    /** @type {RegExpMatchArray} */
-    // @ts-expect-error
-    const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
-    this.message = match && match[1] ? createMessage(match[1]) : createMessage();
+class Message extends Error {
+    constructor() {
+        super();
+        this.stack = undefined;
+        Error.captureStackTrace(this);
+        const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
+        this.message =
+            match && match[1] ? createMessage(match[1]) : createMessage();
+    }
 }
 /**
  * Error for abstract method
@@ -35,10 +42,11 @@ function Message() {
  * }
  *
  */
-class AbstractMethodError extends WebpackError {
+class AbstractMethodError extends WebpackError_1.default {
     constructor() {
         super(new Message().message);
         this.name = "AbstractMethodError";
     }
 }
-module.exports = AbstractMethodError;
+exports.AbstractMethodError = AbstractMethodError;
+exports.default = AbstractMethodError;

package/dist/lib/Cache.d.ts

@@ -1,71 +1,65 @@
-export = Cache;
-declare class Cache {
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Cache.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } from "@rspack/lite-tapable";
+import type { WebpackError } from "./WebpackError";
+export interface Etag {
+    toString(): string;
+}
+export type CallbackCache<T> = (err?: WebpackError | null, result?: T) => void;
+type GotHandler<T = any> = (result: any | null, callback: (error: Error) => void) => void;
+export declare class Cache {
+    static STAGE_DISK: number;
+    static STAGE_MEMORY: number;
+    static STAGE_DEFAULT: number;
+    static STAGE_NETWORK: number;
     hooks: {
-        /** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
         get: AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>;
-        /** @type {AsyncParallelHook<[string, Etag | null, any]>} */
         store: AsyncParallelHook<[string, Etag | null, any]>;
-        /** @type {AsyncParallelHook<[Iterable<string>]>} */
         storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
-        /** @type {SyncHook<[]>} */
         beginIdle: SyncHook<[]>;
-        /** @type {AsyncParallelHook<[]>} */
         endIdle: AsyncParallelHook<[]>;
-        /** @type {AsyncParallelHook<[]>} */
         shutdown: AsyncParallelHook<[]>;
     };
+    constructor();
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get<T>(identifier: string, etag: Etag | null, callback: CallbackCache<T>): void;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
-    store<T_1>(identifier: string, etag: Etag | null, data: T_1, callback: CallbackCache<void>): void;
+    store<T>(identifier: string, etag: Etag | null, data: T, callback: CallbackCache<void>): void;
     /**
      * After this method has succeeded the cache can only be restored when build dependencies are
-     * @param {Iterable<string>} dependencies list of all build dependencies
-     * @param {CallbackCache<void>} callback signals when the dependencies are stored
-     * @returns {void}
+     * @param dependencies list of all build dependencies
+     * @param callback signals when the dependencies are stored
+     * @returns
      */
     storeBuildDependencies(dependencies: Iterable<string>, callback: CallbackCache<void>): void;
-    /**
-     * @returns {void}
-     */
     beginIdle(): void;
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     endIdle(callback: CallbackCache<void>): void;
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     shutdown(callback: CallbackCache<void>): void;
 }
-declare namespace Cache {
-    export { STAGE_MEMORY, STAGE_DEFAULT, STAGE_DISK, STAGE_NETWORK, WebpackError, Etag, CallbackCache, GotHandler };
-}
-import { AsyncSeriesBailHook } from "@rspack/lite-tapable";
-type Etag = {
-    toString: () => string;
-};
-type GotHandler = (result: any, callback: (arg0: Error | undefined) => void) => void;
-import { AsyncParallelHook } from "@rspack/lite-tapable";
-import { SyncHook } from "@rspack/lite-tapable";
-type CallbackCache<T> = (err?: (WebpackError | null) | undefined, result?: T | undefined) => void;
-declare var STAGE_MEMORY: number;
-declare var STAGE_DEFAULT: number;
-declare var STAGE_DISK: number;
-declare var STAGE_NETWORK: number;
-type WebpackError = import("./WebpackError");
+export default Cache;

package/dist/lib/Cache.js

@@ -1,72 +1,50 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = require("@rspack/lite-tapable");
-const { makeWebpackError, makeWebpackErrorCallback } = require("./HookWebpackError.js");
-/** @typedef {import("./WebpackError")} WebpackError */
 /**
- * @typedef {Object} Etag
- * @property {function(): string} toString
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Cache.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
-/**
- * @callback GotHandler
- * @param {any} result
- * @param {function(Error=): void} callback
- * @returns {void}
- */
-// @ts-expect-error
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const lite_tapable_1 = require("@rspack/lite-tapable");
+const HookWebpackError_1 = require("./HookWebpackError");
 const needCalls = (times, callback) => {
-    // @ts-expect-error
     return err => {
         if (--times === 0) {
-            return callback(err);
+            return callback();
         }
         if (err && times > 0) {
             times = 0;
-            return callback(err);
+            return callback();
         }
     };
 };
 class Cache {
     constructor() {
         this.hooks = {
-            /** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
-            get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
-            /** @type {AsyncParallelHook<[string, Etag | null, any]>} */
-            store: new AsyncParallelHook(["identifier", "etag", "data"]),
-            /** @type {AsyncParallelHook<[Iterable<string>]>} */
-            storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
-            /** @type {SyncHook<[]>} */
-            beginIdle: new SyncHook([]),
-            /** @type {AsyncParallelHook<[]>} */
-            endIdle: new AsyncParallelHook([]),
-            /** @type {AsyncParallelHook<[]>} */
-            shutdown: new AsyncParallelHook([])
+            get: new lite_tapable_1.AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
+            store: new lite_tapable_1.AsyncParallelHook(["identifier", "etag", "data"]),
+            storeBuildDependencies: new lite_tapable_1.AsyncParallelHook(["dependencies"]),
+            beginIdle: new lite_tapable_1.SyncHook([]),
+            endIdle: new lite_tapable_1.AsyncParallelHook([]),
+            shutdown: new lite_tapable_1.AsyncParallelHook([])
         };
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get(identifier, etag, callback) {
-        // @ts-expect-error
         const gotHandlers = [];
-        // @ts-expect-error
         this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
             if (err) {
-                callback(makeWebpackError(err, "Cache.hooks.get"));
+                callback((0, HookWebpackError_1.makeWebpackError)(err, "Cache.hooks.get"));
                 return;
             }
             if (result === null) {
@@ -74,13 +52,11 @@ class Cache {
             }
             if (gotHandlers.length > 1) {
                 const innerCallback = needCalls(gotHandlers.length, () => callback(null, result));
-                // @ts-expect-error
                 for (const gotHandler of gotHandlers) {
                     gotHandler(result, innerCallback);
                 }
             }
             else if (gotHandlers.length === 1) {
-                // @ts-expect-error
                 gotHandlers[0](result, () => callback(null, result));
             }
             else {
@@ -89,56 +65,45 @@ class Cache {
         });
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
     store(identifier, etag, data, callback) {
-        this.hooks.store.callAsync(identifier, etag, data, 
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.store"));
+        this.hooks.store.callAsync(identifier, etag, data, (0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.store"));
     }
     /**
      * After this method has succeeded the cache can only be restored when build dependencies are
-     * @param {Iterable<string>} dependencies list of all build dependencies
-     * @param {CallbackCache<void>} callback signals when the dependencies are stored
-     * @returns {void}
+     * @param dependencies list of all build dependencies
+     * @param callback signals when the dependencies are stored
+     * @returns
      */
     storeBuildDependencies(dependencies, callback) {
-        this.hooks.storeBuildDependencies.callAsync(dependencies, 
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies"));
+        this.hooks.storeBuildDependencies.callAsync(dependencies, (0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.storeBuildDependencies"));
     }
-    /**
-     * @returns {void}
-     */
     beginIdle() {
         this.hooks.beginIdle.call();
     }
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     endIdle(callback) {
-        this.hooks.endIdle.callAsync(
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.endIdle"));
+        this.hooks.endIdle.callAsync((0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.endIdle"));
     }
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     shutdown(callback) {
-        this.hooks.shutdown.callAsync(
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.shutdown"));
+        this.hooks.shutdown.callAsync((0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.shutdown"));
     }
 }
+Cache.STAGE_DISK = 10;
 Cache.STAGE_MEMORY = -10;
 Cache.STAGE_DEFAULT = 0;
-Cache.STAGE_DISK = 10;
 Cache.STAGE_NETWORK = 20;
-module.exports = Cache;
+exports.Cache = Cache;
+exports.default = Cache;