@rspack/core 1.0.7 → 1.0.9

package/dist/builtin-plugin/HtmlRspackPlugin.d.ts

@@ -1,76 +1,70 @@
 import { BuiltinPluginName, type JsAfterEmitData, type JsAfterTemplateExecutionData, type JsAlterAssetTagGroupsData, type JsAlterAssetTagsData, type JsBeforeAssetTagGenerationData, type JsBeforeEmitData, type JsHtmlPluginTag } from "@rspack/binding";
 import * as liteTapable from "@rspack/lite-tapable";
-import { z } from "../../compiled/zod";
 import { Compilation } from "../Compilation";
 import type { Compiler } from "../Compiler";
-declare const htmlRspackPluginOptions: z.ZodObject<{
-    filename: z.ZodOptional<z.ZodString>;
-    template: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    templateContent: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
-    templateParameters: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodString>, z.ZodBoolean]>, z.ZodFunction<z.ZodTuple<[z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodPromise<z.ZodRecord<z.ZodString, z.ZodAny>>]>>]>>;
-    inject: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["head", "body"]>, z.ZodBoolean]>>;
-    publicPath: z.ZodOptional<z.ZodString>;
-    base: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        href: z.ZodOptional<z.ZodString>;
-        target: z.ZodOptional<z.ZodEnum<["_self", "_blank", "_parent", "_top"]>>;
-    }, "strict", z.ZodTypeAny, {
-        target?: "_self" | "_blank" | "_parent" | "_top" | undefined;
-        href?: string | undefined;
-    }, {
-        target?: "_self" | "_blank" | "_parent" | "_top" | undefined;
-        href?: string | undefined;
-    }>]>>;
-    scriptLoading: z.ZodOptional<z.ZodEnum<["blocking", "defer", "module", "systemjs-module"]>>;
-    chunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    excludeChunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    sri: z.ZodOptional<z.ZodEnum<["sha256", "sha384", "sha512"]>>;
-    minify: z.ZodOptional<z.ZodBoolean>;
-    title: z.ZodOptional<z.ZodString>;
-    favicon: z.ZodOptional<z.ZodString>;
-    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
-    hash: z.ZodOptional<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    filename?: string | undefined;
-    publicPath?: string | undefined;
-    hash?: boolean | undefined;
-    chunks?: string[] | undefined;
+export type TemplateRenderFunction = (params: Record<string, any>) => string | Promise<string>;
+export type TemplateParamFunction = (params: Record<string, any>) => Record<string, any> | Promise<Record<string, any>>;
+export type HtmlRspackPluginOptions = {
+    /** The title to use for the generated HTML document. */
+    title?: string;
+    /**
+     * The file to write the HTML to. You can specify a subdirectory here too (eg: pages/index.html).
+     * @default 'index.html'
+     */
+    filename?: string;
+    /** The template file path. */
+    template?: string;
+    /**
+     * The template file content, priority is greater than template.
+     * When using a function, pass in the template parameters and use the returned string as the template content.
+     */
+    templateContent?: string | TemplateRenderFunction;
+    /**
+     * Allows to overwrite the parameters used in the template.
+     * When using a function, pass in the original template parameters and use the returned object as the final template parameters.
+     */
+    templateParameters?: Record<string, string> | boolean | TemplateParamFunction;
+    /**
+     * The script and link tag inject position in template. Use false to not inject.
+     * If not specified, it will be automatically determined based on scriptLoading.
+     */
+    inject?: boolean | "head" | "body";
+    /** The publicPath used for script and link tags. */
+    publicPath?: string;
+    /** Inject a [base](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base) tag */
     base?: string | {
-        target?: "_self" | "_blank" | "_parent" | "_top" | undefined;
-        href?: string | undefined;
-    } | undefined;
-    template?: string | undefined;
-    templateContent?: string | ((args_0: Record<string, any>, ...args_1: unknown[]) => string | Promise<string>) | undefined;
-    templateParameters?: boolean | Record<string, string> | ((args_0: Record<string, any>, ...args_1: unknown[]) => Record<string, any> | Promise<Record<string, any>>) | undefined;
-    inject?: boolean | "head" | "body" | undefined;
-    scriptLoading?: "module" | "blocking" | "defer" | "systemjs-module" | undefined;
-    excludeChunks?: string[] | undefined;
-    sri?: "sha256" | "sha384" | "sha512" | undefined;
-    minify?: boolean | undefined;
-    title?: string | undefined;
-    favicon?: string | undefined;
-    meta?: Record<string, string | Record<string, string>> | undefined;
-}, {
-    filename?: string | undefined;
-    publicPath?: string | undefined;
-    hash?: boolean | undefined;
-    chunks?: string[] | undefined;
-    base?: string | {
-        target?: "_self" | "_blank" | "_parent" | "_top" | undefined;
-        href?: string | undefined;
-    } | undefined;
-    template?: string | undefined;
-    templateContent?: string | ((args_0: Record<string, any>, ...args_1: unknown[]) => string | Promise<string>) | undefined;
-    templateParameters?: boolean | Record<string, string> | ((args_0: Record<string, any>, ...args_1: unknown[]) => Record<string, any> | Promise<Record<string, any>>) | undefined;
-    inject?: boolean | "head" | "body" | undefined;
-    scriptLoading?: "module" | "blocking" | "defer" | "systemjs-module" | undefined;
-    excludeChunks?: string[] | undefined;
-    sri?: "sha256" | "sha384" | "sha512" | undefined;
-    minify?: boolean | undefined;
-    title?: string | undefined;
-    favicon?: string | undefined;
-    meta?: Record<string, string | Record<string, string>> | undefined;
-}>;
-export type HtmlRspackPluginOptions = z.infer<typeof htmlRspackPluginOptions>;
+        href?: string;
+        target?: "_self" | "_blank" | "_parent" | "_top";
+    };
+    /**
+     * Modern browsers support non blocking javascript loading ('defer') to improve the page startup performance.
+     * Setting to 'module' adds attribute type='module'.
+     * This also implies 'defer', since modules are automatically deferred.
+     * @default 'defer'
+     * */
+    scriptLoading?: "blocking" | "defer" | "module" | "systemjs-module";
+    /** Allows you to add only some chunks. */
+    chunks?: string[];
+    /** Allows you to skip some chunks. */
+    excludeChunks?: string[];
+    /** The sri hash algorithm, disabled by default. */
+    sri?: "sha256" | "sha384" | "sha512";
+    /**
+     * Controls whether to minify the output.
+     * @default false
+     */
+    minify?: boolean;
+    /** Adds the given favicon path to the output HTML. */
+    favicon?: string;
+    /**
+     * If true then append a unique rspack compilation hash to all included scripts and CSS files.
+     * This is useful for cache busting
+     * @default false
+     * */
+    meta?: Record<string, string | Record<string, string>>;
+    /** Inject a base tag */
+    hash?: boolean;
+};
 type ExtraPluginHookData = {
     plugin: {
         options: HtmlRspackPluginOptions;
@@ -95,49 +89,9 @@ export type HtmlRspackPluginHooks = {
     ]>;
 };
 declare const HtmlRspackPlugin: {
-    new (c?: {
-        filename?: string | undefined;
-        publicPath?: string | undefined;
-        hash?: boolean | undefined;
-        chunks?: string[] | undefined;
-        base?: string | {
-            target?: "_self" | "_blank" | "_parent" | "_top" | undefined;
-            href?: string | undefined;
-        } | undefined;
-        template?: string | undefined;
-        templateContent?: string | ((args_0: Record<string, any>, ...args_1: unknown[]) => string | Promise<string>) | undefined;
-        templateParameters?: boolean | Record<string, string> | ((args_0: Record<string, any>, ...args_1: unknown[]) => Record<string, any> | Promise<Record<string, any>>) | undefined;
-        inject?: boolean | "head" | "body" | undefined;
-        scriptLoading?: "module" | "blocking" | "defer" | "systemjs-module" | undefined;
-        excludeChunks?: string[] | undefined;
-        sri?: "sha256" | "sha384" | "sha512" | undefined;
-        minify?: boolean | undefined;
-        title?: string | undefined;
-        favicon?: string | undefined;
-        meta?: Record<string, string | Record<string, string>> | undefined;
-    } | undefined): {
+    new (c?: HtmlRspackPluginOptions | undefined): {
         name: BuiltinPluginName;
-        _args: [c?: {
-            filename?: string | undefined;
-            publicPath?: string | undefined;
-            hash?: boolean | undefined;
-            chunks?: string[] | undefined;
-            base?: string | {
-                target?: "_self" | "_blank" | "_parent" | "_top" | undefined;
-                href?: string | undefined;
-            } | undefined;
-            template?: string | undefined;
-            templateContent?: string | ((args_0: Record<string, any>, ...args_1: unknown[]) => string | Promise<string>) | undefined;
-            templateParameters?: boolean | Record<string, string> | ((args_0: Record<string, any>, ...args_1: unknown[]) => Record<string, any> | Promise<Record<string, any>>) | undefined;
-            inject?: boolean | "head" | "body" | undefined;
-            scriptLoading?: "module" | "blocking" | "defer" | "systemjs-module" | undefined;
-            excludeChunks?: string[] | undefined;
-            sri?: "sha256" | "sha384" | "sha512" | undefined;
-            minify?: boolean | undefined;
-            title?: string | undefined;
-            favicon?: string | undefined;
-            meta?: Record<string, string | Record<string, string>> | undefined;
-        } | undefined];
+        _args: [c?: HtmlRspackPluginOptions | 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: Compiler): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: Compiler): void;

package/dist/builtin-plugin/IgnorePlugin.d.ts

@@ -1,8 +1,11 @@
 import { BuiltinPluginName, type RawIgnorePluginOptions } from "@rspack/binding";
 export type IgnorePluginOptions = {
+    /** A RegExp to test the resource against. */
     resourceRegExp: NonNullable<RawIgnorePluginOptions["resourceRegExp"]>;
+    /** A RegExp to test the context (directory) against. */
     contextRegExp?: RawIgnorePluginOptions["contextRegExp"];
 } | {
+    /** A Filter function that receives `resource` and `context` as arguments, must return boolean. */
     checkResource: NonNullable<RawIgnorePluginOptions["checkResource"]>;
 };
 export declare const IgnorePlugin: {

package/dist/config/adapter.js

@@ -489,7 +489,11 @@ function getRawJavascriptParserOptions(parser) {
                 ? ["..."]
                 : []
             : parser.worker,
-        overrideStrict: parser.overrideStrict
+        overrideStrict: parser.overrideStrict,
+        requireAsExpression: parser.requireAsExpression,
+        requireDynamic: parser.requireDynamic,
+        requireResolve: parser.requireResolve,
+        importDynamic: parser.importDynamic
     };
 }
 function getRawAssetParserOptions(parser) {

package/dist/config/defaults.js

@@ -168,6 +168,10 @@ const applyJavascriptParserOptionsDefaults = (parserOptions) => {
     D(parserOptions, "exprContextCritical", true);
     D(parserOptions, "wrappedContextCritical", false);
     D(parserOptions, "strictExportPresence", false);
+    D(parserOptions, "requireAsExpression", true);
+    D(parserOptions, "requireDynamic", true);
+    D(parserOptions, "requireResolve", true);
+    D(parserOptions, "importDynamic", true);
     D(parserOptions, "worker", ["..."]);
     D(parserOptions, "importMeta", true);
 };

package/dist/config/types.d.ts

@@ -0,0 +1,293 @@
+import type { JsAssetInfo } from "@rspack/binding";
+import type { PathData } from "../Compilation";
+export type FilenameTemplate = string;
+export type Filename = FilenameTemplate | ((pathData: PathData, assetInfo?: JsAssetInfo) => string);
+/** Name of the configuration. Used when loading multiple configurations. */
+export type Name = string;
+/** A list of name defining all sibling configurations it depends on. Dependent configurations need to be compiled first. */
+export type Dependencies = Name[];
+/**
+ * The context configuration is used to set the base directory for Rspack builds.
+ * @default process.cwd()
+ * */
+export type Context = string;
+/**
+ * The mode configuration is used to set the build mode of Rspack to enable the default optimization strategy.
+ * @default 'production'
+ * */
+export type Mode = "development" | "production" | "none";
+export type Falsy = false | "" | 0 | null | undefined;
+/** The publicPath of the resource referenced by this entry. */
+export type PublicPath = "auto" | Filename;
+/** The baseURI of the resource referenced by this entry. */
+export type BaseUri = string;
+/** How this entry load other chunks. */
+export type ChunkLoadingType = string | "jsonp" | "import-scripts" | "require" | "async-node" | "import";
+/** How this entry load other chunks. */
+export type ChunkLoading = false | ChunkLoadingType;
+/** Whether to create a load-on-demand asynchronous chunk for entry. */
+export type AsyncChunks = boolean;
+/** Option to set the method of loading WebAssembly Modules. */
+export type WasmLoadingType = string | "fetch-streaming" | "fetch" | "async-node";
+/** Option to set the method of loading WebAssembly Modules. */
+export type WasmLoading = false | WasmLoadingType;
+export type ScriptType = false | "text/javascript" | "module";
+export type LibraryCustomUmdObject = {
+    amd?: string;
+    commonjs?: string;
+    root?: string | string[];
+};
+/** Specify a name for the library. */
+export type LibraryName = string | string[] | LibraryCustomUmdObject;
+export type LibraryCustomUmdCommentObject = {
+    amd?: string;
+    commonjs?: string;
+    commonjs2?: string;
+    root?: string;
+};
+/** Use a container(defined in global space) for calling define/require functions in an AMD module. */
+export type AmdContainer = string;
+/** Add a comment in the UMD wrapper. */
+export type AuxiliaryComment = string | LibraryCustomUmdCommentObject;
+/** Specify which export should be exposed as a library. */
+export type LibraryExport = string | string[];
+/** Configure how the library will be exposed. */
+export type LibraryType = string | "var" | "module" | "assign" | "assign-properties" | "this" | "window" | "self" | "global" | "commonjs" | "commonjs2" | "commonjs-module" | "commonjs-static" | "amd" | "amd-require" | "umd" | "umd2" | "jsonp" | "system";
+/** When using output.library.type: "umd", setting output.library.umdNamedDefine to true will name the AMD module of the UMD build. */
+export type UmdNamedDefine = boolean;
+/** Options for library.  */
+export type LibraryOptions = {
+    /** Use a container(defined in global space) for calling define/require functions in an AMD module. */
+    amdContainer?: AmdContainer;
+    /** Add a comment in the UMD wrapper. */
+    auxiliaryComment?: AuxiliaryComment;
+    /** Specify which export should be exposed as a library. */
+    export?: LibraryExport;
+    /** Specify a name for the library. */
+    name?: LibraryName;
+    /** Configure how the library will be exposed. */
+    type: LibraryType;
+    /**
+     * When using output.library.type: "umd", setting output.library.umdNamedDefine to true will name the AMD module of the UMD build.
+     * Otherwise, an anonymous define is used.
+     * */
+    umdNamedDefine?: UmdNamedDefine;
+};
+/** Options for library. */
+export type Library = LibraryName | LibraryOptions | undefined;
+/** The layer of this entry. */
+export type Layer = string | null;
+/** The filename of the entry chunk. */
+export type EntryFilename = Filename;
+/** The name of the runtime chunk. */
+export type EntryRuntime = false | string;
+/** The path to the entry module. */
+export type EntryItem = string | string[];
+/** The entry that the current entry depends on. With dependOn option you can share the modules from one entry chunk to another. */
+export type EntryDependOn = string | string[];
+export type EntryDescription = {
+    /**
+     * The path to the entry module.
+     * @default './src/index.js'
+     * */
+    import: EntryItem;
+    /**
+     * The name of the runtime chunk.
+     * When runtime is set, a new runtime chunk will be created.
+     * You can also set it to false to avoid a new runtime chunk.
+     * */
+    runtime?: EntryRuntime;
+    /** The publicPath of the resource referenced by this entry. */
+    publicPath?: PublicPath;
+    /** The baseURI of the resource referenced by this entry. */
+    baseUri?: BaseUri;
+    /** How this entry load other chunks. */
+    chunkLoading?: ChunkLoading;
+    /** Whether to create a load-on-demand asynchronous chunk for this entry. */
+    asyncChunks?: AsyncChunks;
+    /** Option to set the method of loading WebAssembly Modules. */
+    wasmLoading?: WasmLoading;
+    /** The filename of the entry chunk. */
+    filename?: EntryFilename;
+    /** The format of the chunk generated by this entry as a library. */
+    library?: LibraryOptions;
+    /** The entry that the current entry depends on. With dependOn option you can share the modules from one entry chunk to another. */
+    dependOn?: EntryDependOn;
+    /** The layer of this entry, make the corresponding configuration take effect through layer matching in SplitChunks, Rules, Stats, and Externals. */
+    layer?: Layer;
+};
+export type EntryUnnamed = EntryItem;
+export type EntryObject = Record<string, EntryItem | EntryDescription>;
+/** A static entry.  */
+export type EntryStatic = EntryObject | EntryUnnamed;
+/** A Function returning entry options. */
+export type EntryDynamic = () => EntryStatic | Promise<EntryStatic>;
+/** The entry options for building */
+export type Entry = EntryStatic | EntryDynamic;
+/**
+ * Path alias
+ * @example
+ * ```js
+ * {
+ * 	"@": path.resolve(__dirname, './src'),
+ * 	"abc$": path.resolve(__dirname, './node_modules/abc/index.js'),
+ * }
+ * // - require("@/a") will attempt to resolve <root>/src/a.
+ * // - require("abc") will attempt to resolve <root>/src/abc.
+ * // - require("abc/file.js") will not match, and it will attempt to resolve node_modules/abc/file.js.
+ * ```
+ * */
+export type ResolveAlias = {
+    [x: string]: string | false | (string | false)[];
+};
+/** The replacement of [tsconfig-paths-webpack-plugin](https://www.npmjs.com/package/tsconfig-paths-webpack-plugin) in Rspack. */
+export type ResolveTsConfig = string | {
+    configFile: string;
+    references?: string[] | "auto" | undefined;
+};
+/** Used to configure the Rspack module resolution */
+export type ResolveOptions = {
+    /** Path alias */
+    alias?: ResolveAlias;
+    /** Same as node's [conditionNames](https://nodejs.org/api/packages.html#conditional-exports) for the exports and imports fields in package.json. */
+    conditionNames?: string[];
+    /**
+     * Parse modules in order.
+     * @default [".js", ".json", ".wasm"]
+     * */
+    extensions?: string[];
+    /** Redirect module requests when normal resolving fails. */
+    fallback?: ResolveAlias;
+    /** Try to parse the fields in package.json */
+    mainFields?: string[];
+    /**
+     * The filename suffix when resolving directories, e.g. require('. /dir/') will try to resolve '. /dir/index'.
+     * @default ['index']
+     */
+    mainFiles?: string[];
+    /**
+     * The name of the directory to use when resolving dependencies.
+     * @default ["node_modules"]
+     */
+    modules?: string[];
+    /**
+     * When enabled, require('file') will first look for the . /file file in the current directory, not <modules>/file.
+     * @default false
+     */
+    preferRelative?: boolean;
+    /**
+     * Opt for absolute paths when resolving, in relation to resolve.roots.
+     * @default false
+     */
+    preferAbsolute?: boolean;
+    /**
+     * Whether to resolve symlinks to their symlinked location.
+     * @default true
+     */
+    symlinks?: boolean;
+    /**
+     * By default, It changes to true if resolve.extensions contains an empty string;
+     * otherwise, this value changes to false.
+     */
+    enforceExtension?: boolean;
+    /**
+     * Customize the imports field in package.json which are used to provide the internal requests of a package (requests starting with # are considered internal).
+     * @default ["imports"]
+     */
+    importsFields?: string[];
+    /**
+     * The JSON files to use for descriptions.
+     * @default ['package.json']
+     */
+    descriptionFiles?: string[];
+    /** The replacement of [tsconfig-paths-webpack-plugin](https://www.npmjs.com/package/tsconfig-paths-webpack-plugin) in Rspack. */
+    tsConfig?: ResolveTsConfig;
+    /**
+     * No longer resolve extensions, no longer resolve mainFiles in package.json (but does not affect requests from mainFiles, browser, alias).
+     * @default false
+     * */
+    fullySpecified?: boolean;
+    /**
+     * Customize the exports field in package.json.
+     * @default ["exports"]
+     * */
+    exportsFields?: string[];
+    /** Define alias for the extension. */
+    extensionAlias?: Record<string, string | string[]>;
+    /**
+     * Define a field, such as browser, that should be parsed in accordance with this [specification](https://github.com/defunctzombie/package-browser-field-spec).
+     * @default ['browser']
+     * */
+    aliasFields?: string[];
+    /**
+     * A list of resolve restrictions to restrict the paths that a request can be resolved on.
+     * @default []
+     * */
+    restrictions?: string[];
+    /**
+     * A list of directories where server-relative URLs (beginning with '/') are resolved.
+     * It defaults to the context configuration option.
+     * On systems other than Windows, these requests are initially resolved as an absolute path.
+     * @default []
+     */
+    roots?: string[];
+    /** Customize the Resolve configuration based on the module type. */
+    byDependency?: Record<string, ResolveOptions>;
+};
+/** Used to configure the Rspack module resolution */
+export type Resolve = ResolveOptions;
+/**
+ * Specify the default type of externals.
+ * `amd`, `umd`, `system` and `jsonp` externals depend on the `output.libraryTarget` being set to the same value e.g. you can only consume amd externals within an amd library.
+ * @default 'var'
+ */
+export type ExternalsType = "var" | "module" | "assign" | "this" | "window" | "self" | "global" | "commonjs" | "commonjs2" | "commonjs-module" | "commonjs-static" | "amd" | "amd-require" | "umd" | "umd2" | "jsonp" | "system" | "promise" | "import" | "module-import" | "script" | "node-commonjs";
+/**
+ * The dependency used for the external.
+ */
+export type ExternalItemValue = string | boolean | string[] | Record<string, string | string[]>;
+/**
+ * If an dependency matches exactly a property of the object, the property value is used as dependency.
+ */
+export type ExternalItemObjectUnknown = {
+    [x: string]: ExternalItemValue;
+};
+/**
+ * Data object passed as argument when a function is set for 'externals'.
+ */
+export type ExternalItemFunctionData = {
+    context?: string;
+    dependencyType?: string;
+    request?: string;
+    contextInfo?: {
+        issuer: string;
+    };
+};
+/**
+ * Prevent bundling of certain imported package and instead retrieve these external dependencies at runtime.
+ *
+ * @example
+ * ```js
+ * // jquery lib will be excluded from bundling.
+ * module.exports = {
+ * 	externals: {
+ * 		jquery: 'jQuery',
+ * 	}
+ * }
+ * ```
+ * */
+export type ExternalItem = string | RegExp | ExternalItemObjectUnknown | ((data: ExternalItemFunctionData, callback: (err?: Error, result?: ExternalItemValue, type?: ExternalsType) => void) => void) | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
+/**
+ * Prevent bundling of certain imported packages and instead retrieve these external dependencies at runtime.
+ *
+ * @example
+ * ```js
+ * // jquery lib will be excluded from bundling.
+ * module.exports = {
+ * 	externals: {
+ * 		jquery: 'jQuery',
+ * 	}
+ * }
+ * ```
+ * */
+export type Externals = ExternalItem | ExternalItem[];

package/dist/config/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//#endregion