@rspack/core 1.0.9 → 1.0.10

package/dist/Compiler.js

@@ -754,17 +754,22 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             await queried.promise(data, {});
         }),
         registerContextModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryBeforeResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").contextModuleFactory.hooks.beforeResolve, queried => async (bindingData) => {
-            return queried.promise(bindingData);
+            const data = bindingData
+                ? Module_1.ContextModuleFactoryBeforeResolveData.__from_binding(bindingData)
+                : false;
+            const result = await queried.promise(data);
+            return result
+                ? Module_1.ContextModuleFactoryBeforeResolveData.__to_binding(result)
+                : false;
         }),
         registerContextModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryAfterResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").contextModuleFactory.hooks.afterResolve, queried => async (bindingData) => {
             const data = bindingData
                 ? Module_1.ContextModuleFactoryAfterResolveData.__from_binding(bindingData)
                 : false;
-            const ret = await queried.promise(data);
-            const result = ret
-                ? Module_1.ContextModuleFactoryAfterResolveData.__to_binding(ret)
+            const result = await queried.promise(data);
+            return result
+                ? Module_1.ContextModuleFactoryAfterResolveData.__to_binding(result)
                 : false;
-            return result;
         }),
         registerJavascriptModulesChunkHashTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.JavascriptModulesChunkHash, () => builtin_plugin_1.JavascriptModulesPlugin.getCompilationHooks(__classPrivateFieldGet(this, _Compiler_compilation, "f"))
             .chunkHash, queried => (chunk) => {

package/dist/DependenciesBlock.js

@@ -20,7 +20,7 @@ class DependenciesBlock {
         __classPrivateFieldSet(this, _DependenciesBlock_binding, binding, "f");
     }
     get dependencies() {
-        return __classPrivateFieldGet(this, _DependenciesBlock_binding, "f").dependencies.map(d => new Dependency_1.Dependency(d));
+        return __classPrivateFieldGet(this, _DependenciesBlock_binding, "f").dependencies.map(d => Dependency_1.Dependency.__from_binding(d));
     }
     get blocks() {
         return __classPrivateFieldGet(this, _DependenciesBlock_binding, "f").blocks.map(b => new DependenciesBlock(b));

package/dist/Dependency.d.ts

@@ -1,8 +1,9 @@
-import type { DependencyDTO } from "@rspack/binding";
+import { type JsDependency, JsDependencyMut } from "@rspack/binding";
 export declare class Dependency {
-    #private;
-    constructor(binding: DependencyDTO);
-    get type(): string;
-    get category(): string;
-    get request(): string | undefined;
+    readonly type: string;
+    readonly category: string;
+    readonly request: string | undefined;
+    critical: boolean;
+    static __from_binding(binding: JsDependencyMut | JsDependency): Dependency;
+    private constructor();
 }

package/dist/Dependency.js

@@ -1,32 +1,43 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Dependency_binding;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dependency = void 0;
+const binding_1 = require("@rspack/binding");
 class Dependency {
-    constructor(binding) {
-        _Dependency_binding.set(this, void 0);
-        __classPrivateFieldSet(this, _Dependency_binding, binding, "f");
-    }
-    get type() {
-        return __classPrivateFieldGet(this, _Dependency_binding, "f").type;
+    static __from_binding(binding) {
+        return new Dependency(binding);
     }
-    get category() {
-        return __classPrivateFieldGet(this, _Dependency_binding, "f").category;
-    }
-    get request() {
-        return __classPrivateFieldGet(this, _Dependency_binding, "f").request;
+    constructor(binding) {
+        Object.defineProperties(this, {
+            type: {
+                enumerable: true,
+                get() {
+                    return binding.type;
+                }
+            },
+            category: {
+                enumerable: true,
+                get() {
+                    return binding.category;
+                }
+            },
+            request: {
+                enumerable: true,
+                get() {
+                    return binding.request;
+                }
+            },
+            critical: {
+                enumerable: true,
+                get() {
+                    return binding.critical;
+                },
+                set(val) {
+                    if (binding instanceof binding_1.JsDependencyMut) {
+                        binding.critical = val;
+                    }
+                }
+            }
+        });
     }
 }
 exports.Dependency = Dependency;
-_Dependency_binding = new WeakMap();

package/dist/Module.d.ts

@@ -1,8 +1,8 @@
-import type { JsCodegenerationResult, JsContextModuleFactoryAfterResolveData, JsCreateData, JsFactoryMeta, JsModule, ModuleDTO } from "@rspack/binding";
+import type { JsCodegenerationResult, JsContextModuleFactoryAfterResolveData, JsContextModuleFactoryBeforeResolveData, JsCreateData, JsFactoryMeta, JsModule, ModuleDTO } from "@rspack/binding";
 import type { Source } from "../compiled/webpack-sources";
 import type { Compilation } from "./Compilation";
 import { DependenciesBlock } from "./DependenciesBlock";
-import type { Dependency } from "./Dependency";
+import { Dependency } from "./Dependency";
 export type ResourceData = {
     resource: string;
     path: string;
@@ -25,26 +25,28 @@ export type ResolveData = {
     contextDependencies: string[];
     createData?: CreateData;
 };
-export type ContextModuleFactoryBeforeResolveResult = false | {
+export declare class ContextModuleFactoryBeforeResolveData {
+    #private;
     context: string;
-    request?: string;
-};
+    request: string;
+    regExp: RegExp | undefined;
+    recursive: boolean;
+    static __from_binding(binding: JsContextModuleFactoryBeforeResolveData): ContextModuleFactoryBeforeResolveData;
+    static __to_binding(data: ContextModuleFactoryBeforeResolveData): JsContextModuleFactoryBeforeResolveData;
+    private constructor();
+}
+export type ContextModuleFactoryBeforeResolveResult = false | ContextModuleFactoryBeforeResolveData;
 export declare class ContextModuleFactoryAfterResolveData {
     #private;
+    resource: number;
+    context: string;
+    request: string;
+    regExp: RegExp | undefined;
+    recursive: boolean;
+    readonly dependencies: Dependency[];
     static __from_binding(binding: JsContextModuleFactoryAfterResolveData): ContextModuleFactoryAfterResolveData;
     static __to_binding(data: ContextModuleFactoryAfterResolveData): JsContextModuleFactoryAfterResolveData;
-    constructor(data: JsContextModuleFactoryAfterResolveData);
-    get resource(): string;
-    set resource(val: string);
-    get context(): string;
-    set context(val: string);
-    get request(): string;
-    set request(val: string);
-    get regExp(): RegExp | undefined;
-    set regExp(val: RegExp | undefined);
-    get recursive(): boolean;
-    set recursive(val: boolean);
-    get dependencies(): Dependency[];
+    private constructor();
 }
 export type ContextModuleFactoryAfterResolveResult = false | ContextModuleFactoryAfterResolveData;
 export declare class Module {

package/dist/Module.js

@@ -10,11 +10,75 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _ContextModuleFactoryAfterResolveData_inner, _Module_inner, _Module_originalSource, _CodeGenerationResult_inner;
+var _ContextModuleFactoryBeforeResolveData_inner, _ContextModuleFactoryAfterResolveData_inner, _Module_inner, _Module_originalSource, _CodeGenerationResult_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = exports.ContextModuleFactoryAfterResolveData = void 0;
+exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = exports.ContextModuleFactoryAfterResolveData = exports.ContextModuleFactoryBeforeResolveData = void 0;
 const DependenciesBlock_1 = require("./DependenciesBlock");
+const Dependency_1 = require("./Dependency");
 const source_1 = require("./util/source");
+class ContextModuleFactoryBeforeResolveData {
+    static __from_binding(binding) {
+        return new ContextModuleFactoryBeforeResolveData(binding);
+    }
+    static __to_binding(data) {
+        return __classPrivateFieldGet(data, _ContextModuleFactoryBeforeResolveData_inner, "f");
+    }
+    constructor(binding) {
+        _ContextModuleFactoryBeforeResolveData_inner.set(this, void 0);
+        __classPrivateFieldSet(this, _ContextModuleFactoryBeforeResolveData_inner, binding, "f");
+        Object.defineProperties(this, {
+            context: {
+                enumerable: true,
+                get() {
+                    return binding.context;
+                },
+                set(val) {
+                    binding.context = val;
+                }
+            },
+            request: {
+                enumerable: true,
+                get() {
+                    return binding.request;
+                },
+                set(val) {
+                    binding.request = val;
+                }
+            },
+            regExp: {
+                enumerable: true,
+                get() {
+                    if (!binding.regExp) {
+                        return undefined;
+                    }
+                    const { source, flags } = binding.regExp;
+                    return new RegExp(source, flags);
+                },
+                set(val) {
+                    if (!val) {
+                        binding.regExp = undefined;
+                        return;
+                    }
+                    binding.regExp = {
+                        source: val.source,
+                        flags: val.flags
+                    };
+                }
+            },
+            recursive: {
+                enumerable: true,
+                get() {
+                    return binding.recursive;
+                },
+                set(val) {
+                    binding.recursive = val;
+                }
+            }
+        });
+    }
+}
+exports.ContextModuleFactoryBeforeResolveData = ContextModuleFactoryBeforeResolveData;
+_ContextModuleFactoryBeforeResolveData_inner = new WeakMap();
 class ContextModuleFactoryAfterResolveData {
     static __from_binding(binding) {
         return new ContextModuleFactoryAfterResolveData(binding);
@@ -22,54 +86,73 @@ class ContextModuleFactoryAfterResolveData {
     static __to_binding(data) {
         return __classPrivateFieldGet(data, _ContextModuleFactoryAfterResolveData_inner, "f");
     }
-    constructor(data) {
+    constructor(binding) {
         _ContextModuleFactoryAfterResolveData_inner.set(this, void 0);
-        __classPrivateFieldSet(this, _ContextModuleFactoryAfterResolveData_inner, data, "f");
-    }
-    get resource() {
-        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").resource;
-    }
-    set resource(val) {
-        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").resource = val;
-    }
-    get context() {
-        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").context;
-    }
-    set context(val) {
-        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").context = val;
-    }
-    get request() {
-        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").request;
-    }
-    set request(val) {
-        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").request = val;
-    }
-    get regExp() {
-        if (!__classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp) {
-            return undefined;
-        }
-        const { source, flags } = __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp;
-        return new RegExp(source, flags);
-    }
-    set regExp(val) {
-        if (!val) {
-            __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp = undefined;
-            return;
-        }
-        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp = {
-            source: val.source,
-            flags: val.flags
-        };
-    }
-    get recursive() {
-        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").recursive;
-    }
-    set recursive(val) {
-        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").recursive = val;
-    }
-    get dependencies() {
-        // TODO: Dependencies are not fully supported yet; this is a placeholder to prevent errors in moment-locales-webpack-plugin.
-        return [];
+        __classPrivateFieldSet(this, _ContextModuleFactoryAfterResolveData_inner, binding, "f");
+        Object.defineProperties(this, {
+            resource: {
+                enumerable: true,
+                get() {
+                    return binding.resource;
+                },
+                set(val) {
+                    binding.resource = val;
+                }
+            },
+            context: {
+                enumerable: true,
+                get() {
+                    return binding.context;
+                },
+                set(val) {
+                    binding.context = val;
+                }
+            },
+            request: {
+                enumerable: true,
+                get() {
+                    return binding.request;
+                },
+                set(val) {
+                    binding.request = val;
+                }
+            },
+            regExp: {
+                enumerable: true,
+                get() {
+                    if (!binding.regExp) {
+                        return undefined;
+                    }
+                    const { source, flags } = binding.regExp;
+                    return new RegExp(source, flags);
+                },
+                set(val) {
+                    if (!val) {
+                        binding.regExp = undefined;
+                        return;
+                    }
+                    binding.regExp = {
+                        source: val.source,
+                        flags: val.flags
+                    };
+                }
+            },
+            recursive: {
+                enumerable: true,
+                get() {
+                    return binding.recursive;
+                },
+                set(val) {
+                    binding.recursive = val;
+                }
+            },
+            dependencies: {
+                enumerable: true,
+                get() {
+                    return binding.dependencies.map(dep => Dependency_1.Dependency.__from_binding(dep));
+                }
+            }
+        });
     }
 }
 exports.ContextModuleFactoryAfterResolveData = ContextModuleFactoryAfterResolveData;

package/dist/config/types.d.ts

@@ -1,5 +1,8 @@
 import type { JsAssetInfo } from "@rspack/binding";
 import type { PathData } from "../Compilation";
+import type { Compiler } from "../Compiler";
+import type { Module } from "../Module";
+import type { Chunk } from "../exports";
 export type FilenameTemplate = string;
 export type Filename = FilenameTemplate | ((pathData: PathData, assetInfo?: JsAssetInfo) => string);
 /** Name of the configuration. Used when loading multiple configurations. */
@@ -291,3 +294,236 @@ export type ExternalItem = string | RegExp | ExternalItemObjectUnknown | ((data:
  * ```
  * */
 export type Externals = ExternalItem | ExternalItem[];
+export interface RspackPluginInstance {
+    apply: (compiler: Compiler) => void;
+    [k: string]: any;
+}
+export type RspackPluginFunction = (this: Compiler, compiler: Compiler) => void;
+export type WebpackCompiler = any;
+export interface WebpackPluginInstance {
+    apply: (compiler: WebpackCompiler) => void;
+    [k: string]: any;
+}
+export type WebpackPluginFunction = (this: WebpackCompiler, compiler: WebpackCompiler) => void;
+export type Plugin = RspackPluginInstance | RspackPluginFunction | WebpackPluginInstance | WebpackPluginFunction | Falsy;
+export type Plugins = Plugin[];
+/** Used to control how the runtime chunk is generated. */
+export type OptimizationRuntimeChunk = boolean | "single" | "multiple" | {
+    name?: string | ((value: {
+        name: string;
+    }) => string);
+};
+export type OptimizationSplitChunksNameFunction = (module?: Module) => unknown;
+type OptimizationSplitChunksName = string | false | OptimizationSplitChunksNameFunction;
+type OptimizationSplitChunksSizes = number | Record<string, number>;
+type OptimizationSplitChunksChunks = "initial" | "async" | "all" | RegExp | ((chunk: Chunk) => boolean);
+type SharedOptimizationSplitChunksCacheGroup = {
+    /**
+     * This indicates which chunks will be selected for optimization.
+     * @default 'async''
+     * */
+    chunks?: OptimizationSplitChunksChunks;
+    /** Sets the size types which are used when a number is used for sizes. */
+    defaultSizeTypes?: string[];
+    /**
+     * The minimum times must a module be shared among chunks before splitting.
+     * @default 1
+     */
+    minChunks?: number;
+    /**
+     * Enabling this, the splitting of chunks will be grouped based on the usage of modules exports in different runtimes,
+     * ensuring the optimal loading size in each runtime.
+     */
+    usedExports?: boolean;
+    /**
+     * The name of the split chunk.
+     * @default false
+     * */
+    name?: false | OptimizationSplitChunksName;
+    /**
+     * Minimum size, in bytes, for a chunk to be generated.
+     *
+     * The value is `20000` in production mode.
+     * The value is `10000` in others mode.
+     */
+    minSize?: OptimizationSplitChunksSizes;
+    /** Maximum size, in bytes, for a chunk to be generated. */
+    maxSize?: OptimizationSplitChunksSizes;
+    /** Maximum size, in bytes, for a async chunk to be generated. */
+    maxAsyncSize?: OptimizationSplitChunksSizes;
+    /** Maximum size, in bytes, for a initial chunk to be generated. */
+    maxInitialSize?: OptimizationSplitChunksSizes;
+    /**
+     * Maximum number of parallel requests when on-demand loading.
+     * @default 30
+     * */
+    maxAsyncRequests?: number;
+    /**
+     * Maximum number of parallel requests at an entry point.
+     * @default 30
+     */
+    maxInitialRequests?: number;
+    /**
+     * Tell Rspack what delimiter to use for the generated names.
+     *
+     * @default '-''
+     */
+    automaticNameDelimiter?: string;
+};
+/** How to splitting chunks. */
+export type OptimizationSplitChunksCacheGroup = {
+    /** Controls which modules are selected by this cache group. */
+    test?: string | RegExp | ((module: Module) => unknown);
+    /**
+     * A module can belong to multiple cache groups.
+     * @default -20
+     */
+    priority?: number;
+    /**
+     * Tells Rspack to ignore `splitChunks.minSize`, `splitChunks.minChunks`, `splitChunks.maxAsyncRequests` and `splitChunks.maxInitialRequests` options and always create chunks for this cache group.
+     */
+    enforce?: boolean;
+    /** Allows to override the filename when and only when it's an initial chunk. */
+    filename?: string;
+    /**
+     * Whether to reuse existing chunks when possible.
+     * @default false
+     * */
+    reuseExistingChunk?: boolean;
+    /** Allows to assign modules to a cache group by module type. */
+    type?: string | RegExp;
+    /** Sets the hint for chunk id. It will be added to chunk's filename. */
+    idHint?: string;
+} & SharedOptimizationSplitChunksCacheGroup;
+/** Tell Rspack how to splitting chunks. */
+export type OptimizationSplitChunksOptions = {
+    /**
+     * Options for module cache group
+     * */
+    cacheGroups?: Record<string, false | OptimizationSplitChunksCacheGroup>;
+    /**
+     * Options for modules not selected by any other group.
+     */
+    fallbackCacheGroup?: {
+        chunks?: OptimizationSplitChunksChunks;
+        minSize?: number;
+        maxSize?: number;
+        maxAsyncSize?: number;
+        maxInitialSize?: number;
+        automaticNameDelimiter?: string;
+    };
+    /**
+     * Prevents exposing path info when creating names for parts splitted by maxSize.
+     *
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     * */
+    hidePathInfo?: boolean;
+} & SharedOptimizationSplitChunksCacheGroup;
+export type Optimization = {
+    /**
+     * Which algorithm to use when choosing module ids.
+     */
+    moduleIds?: "named" | "natural" | "deterministic";
+    /**
+     * Which algorithm to use when choosing chunk ids.
+     */
+    chunkIds?: "natural" | "named" | "deterministic";
+    /**
+     * Whether to minimize the bundle.
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     */
+    minimize?: boolean;
+    /**
+     * Customize the minimizer.
+     * By default, `rspack.SwcJsMinimizerRspackPlugin` and `rspack.LightningCssMinimizerRspackPlugin` are used.
+     */
+    minimizer?: Array<"..." | Plugin>;
+    /**
+     * Whether to merge chunks which contain the same modules.
+     * Setting optimization.mergeDuplicateChunks to false will disable this optimization.
+     * @default true
+     */
+    mergeDuplicateChunks?: boolean;
+    /**
+     * Support splitting chunks.
+     * It is enabled by default for dynamically imported modules.
+     * To turn it off, set it to false.
+     * */
+    splitChunks?: false | OptimizationSplitChunksOptions;
+    /**
+     * Used to control how the runtime chunk is generated.
+     * Setting it to true or 'multiple' will add an additional chunk containing only the runtime for each entry point.
+     * Setting it to 'single' will extract the runtime code of all entry points into a single separate chunk.
+     * @default false
+     */
+    runtimeChunk?: OptimizationRuntimeChunk;
+    /** Detect and remove modules from chunks these modules are already included in all parents. */
+    removeAvailableModules?: boolean;
+    /**
+     * Remove empty chunks generated in the compilation.
+     * @default true
+     * */
+    removeEmptyChunks?: boolean;
+    /**
+     * Adds an additional hash compilation pass after the assets have been processed to get the correct asset content hashes.
+     *
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     */
+    realContentHash?: boolean;
+    /**
+     * Tells Rspack to recognise the sideEffects flag in package.json or rules to skip over modules which are flagged to contain no side effects when exports are not used.
+     *
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     * */
+    sideEffects?: "flag" | boolean;
+    /**
+     * After enabling, Rspack will analyze which exports the module provides, including re-exported modules.
+     * @default true
+     * */
+    providedExports?: boolean;
+    /**
+     * Tells Rspack to find segments of the module graph which can be safely concatenated into a single module.
+     *
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     */
+    concatenateModules?: boolean;
+    /**
+     * Tells Rspack whether to perform a more detailed analysis of variable assignments.
+     *
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     */
+    innerGraph?: boolean;
+    /**
+     * Tells Rspack to determine used exports for each module.
+     *
+     * The value is `true` in production mode.
+     * The value is `false` in development mode.
+     * */
+    usedExports?: "global" | boolean;
+    /**
+     * Allows to control export mangling.
+     *
+     * The value is `isdeterministic` in production mode.
+     * The value is `false` in development mode.
+     */
+    mangleExports?: "size" | "deterministic" | boolean;
+    /**
+     * Tells Rspack to set process.env.NODE_ENV to a given string value.
+     * @default false
+     */
+    nodeEnv?: string | false;
+    /**
+     * Emit assets whenever there are errors while compiling.
+     *
+     * The value is `false` in production mode.
+     * The value is `true` in development mode.
+     * */
+    emitOnErrors?: boolean;
+};
+export {};