@rspack-canary/browser 1.4.12-canary-f056cdd6-20250801072217 → 1.4.12-canary-d2f8a578-20250801090118

package/dist/RuntimeGlobals.d.ts

@@ -0,0 +1,325 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/v5.88.2/lib/RuntimeGlobals.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers \@sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { JsRuntimeGlobals } from "@rspack/binding";
+export declare function __from_binding_runtime_globals(runtimeRequirements: JsRuntimeGlobals): Set<string>;
+export declare function __to_binding_runtime_globals(runtimeRequirements: Set<string>): JsRuntimeGlobals;
+export declare const RuntimeGlobals: {
+    /**
+     * the internal require function
+     */
+    readonly require: "__webpack_require__";
+    /**
+     * access to properties of the internal require function/object
+     */
+    readonly requireScope: "__webpack_require__.*";
+    /**
+     * the internal exports object
+     */
+    readonly exports: "__webpack_exports__";
+    /**
+     * top-level this need to be the exports object
+     */
+    readonly thisAsExports: "top-level-this-exports";
+    /**
+     * runtime need to return the exports of the last entry module
+     */
+    readonly returnExportsFromRuntime: "return-exports-from-runtime";
+    /**
+     * the internal module object
+     */
+    readonly module: "module";
+    /**
+     * the internal module object
+     */
+    readonly moduleId: "module.id";
+    /**
+     * the internal module object
+     */
+    readonly moduleLoaded: "module.loaded";
+    /**
+     * the bundle public path
+     */
+    readonly publicPath: "__webpack_require__.p";
+    /**
+     * the module id of the entry point
+     */
+    readonly entryModuleId: "__webpack_require__.s";
+    /**
+     * the module cache
+     */
+    readonly moduleCache: "__webpack_require__.c";
+    /**
+     * the module functions
+     */
+    readonly moduleFactories: "__webpack_require__.m";
+    /**
+     * the module functions, with only write access
+     */
+    readonly moduleFactoriesAddOnly: "__webpack_require__.m (add only)";
+    /**
+     * the chunk ensure function
+     */
+    readonly ensureChunk: "__webpack_require__.e";
+    /**
+     * an object with handlers to ensure a chunk
+     */
+    readonly ensureChunkHandlers: "__webpack_require__.f";
+    /**
+     * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
+     */
+    readonly ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
+    /**
+     * the chunk prefetch function
+     */
+    readonly prefetchChunk: "__webpack_require__.E";
+    /**
+     * an object with handlers to prefetch a chunk
+     */
+    readonly prefetchChunkHandlers: "__webpack_require__.F";
+    /**
+     * the chunk preload function
+     */
+    readonly preloadChunk: "__webpack_require__.G";
+    /**
+     * an object with handlers to preload a chunk
+     */
+    readonly preloadChunkHandlers: "__webpack_require__.H";
+    /**
+     * the exported property define getters function
+     */
+    readonly definePropertyGetters: "__webpack_require__.d";
+    /**
+     * define compatibility on export
+     */
+    readonly makeNamespaceObject: "__webpack_require__.r";
+    /**
+     * create a fake namespace object
+     */
+    readonly createFakeNamespaceObject: "__webpack_require__.t";
+    /**
+     * compatibility get default export
+     */
+    readonly compatGetDefaultExport: "__webpack_require__.n";
+    /**
+     * ES modules decorator
+     */
+    readonly harmonyModuleDecorator: "__webpack_require__.hmd";
+    /**
+     * node.js module decorator
+     */
+    readonly nodeModuleDecorator: "__webpack_require__.nmd";
+    /**
+     * the webpack hash
+     */
+    readonly getFullHash: "__webpack_require__.h";
+    /**
+     * an object containing all installed WebAssembly.Instance export objects keyed by module id
+     */
+    readonly wasmInstances: "__webpack_require__.w";
+    /**
+     * instantiate a wasm instance from module exports object, id, hash and importsObject
+     */
+    readonly instantiateWasm: "__webpack_require__.v";
+    /**
+     * the uncaught error handler for the webpack runtime
+     */
+    readonly uncaughtErrorHandler: "__webpack_require__.oe";
+    /**
+     * the script nonce
+     */
+    readonly scriptNonce: "__webpack_require__.nc";
+    /**
+     * function to load a script tag.
+     * Arguments: (url: string, done: (event) =\> void), key?: string | number, chunkId?: string | number) =\> void
+     * done function is called when loading has finished or timeout occurred.
+     * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
+     */
+    readonly loadScript: "__webpack_require__.l";
+    /**
+     * function to promote a string to a TrustedScript using webpack's Trusted
+     * Types policy
+     * Arguments: (script: string) =\> TrustedScript
+     */
+    readonly createScript: "__webpack_require__.ts";
+    /**
+     * function to promote a string to a TrustedScriptURL using webpack's Trusted
+     * Types policy
+     * Arguments: (url: string) =\> TrustedScriptURL
+     */
+    readonly createScriptUrl: "__webpack_require__.tu";
+    /**
+     * function to return webpack's Trusted Types policy
+     * Arguments: () =\> TrustedTypePolicy
+     */
+    readonly getTrustedTypesPolicy: "__webpack_require__.tt";
+    /**
+     * a flag when a chunk has a fetch priority
+     */
+    readonly hasFetchPriority: "has fetch priority";
+    /**
+     * the chunk name of the chunk with the runtime
+     */
+    readonly chunkName: "__webpack_require__.cn";
+    /**
+     * the runtime id of the current runtime
+     */
+    readonly runtimeId: "__webpack_require__.j";
+    /**
+     * the filename of the script part of the chunk
+     */
+    readonly getChunkScriptFilename: "__webpack_require__.u";
+    /**
+     * the filename of the css part of the chunk
+     */
+    readonly getChunkCssFilename: "__webpack_require__.k";
+    /**
+     * a flag when a module/chunk/tree has css modules
+     */
+    readonly hasCssModules: "has css modules";
+    /**
+     * the filename of the script part of the hot update chunk
+     */
+    readonly getChunkUpdateScriptFilename: "__webpack_require__.hu";
+    /**
+     * the filename of the css part of the hot update chunk
+     */
+    readonly getChunkUpdateCssFilename: "__webpack_require__.hk";
+    /**
+     * startup signal from runtime
+     * This will be called when the runtime chunk has been loaded.
+     */
+    readonly startup: "__webpack_require__.x";
+    /**
+     * @deprecated
+     * creating a default startup function with the entry modules
+     */
+    readonly startupNoDefault: "__webpack_require__.x (no default handler)";
+    /**
+     * startup signal from runtime but only used to add logic after the startup
+     */
+    readonly startupOnlyAfter: "__webpack_require__.x (only after)";
+    /**
+     * startup signal from runtime but only used to add sync logic before the startup
+     */
+    readonly startupOnlyBefore: "__webpack_require__.x (only before)";
+    /**
+     * global callback functions for installing chunks
+     */
+    readonly chunkCallback: "webpackChunk";
+    /**
+     * method to startup an entrypoint with needed chunks.
+     * Signature: (moduleId: Id, chunkIds: Id[]) =\> any.
+     * Returns the exports of the module or a Promise
+     */
+    readonly startupEntrypoint: "__webpack_require__.X";
+    /**
+     * register deferred code, which will run when certain
+     * chunks are loaded.
+     * Signature: (chunkIds: Id[], fn: () =\> any, priority: int \>= 0 = 0) =\> any
+     * Returned value will be returned directly when all chunks are already loaded
+     * When (priority & 1) it will wait for all other handlers with lower priority to
+     * be executed before itself is executed
+     */
+    readonly onChunksLoaded: "__webpack_require__.O";
+    /**
+     * method to install a chunk that was loaded somehow
+     * Signature: (\{ id, ids, modules, runtime \}) =\> void
+     */
+    readonly externalInstallChunk: "__webpack_require__.C";
+    /**
+     * interceptor for module executions
+     */
+    readonly interceptModuleExecution: "__webpack_require__.i";
+    /**
+     * the global object
+     */
+    readonly global: "__webpack_require__.g";
+    /**
+     * an object with all share scopes
+     */
+    readonly shareScopeMap: "__webpack_require__.S";
+    /**
+     * The sharing init sequence function (only runs once per share scope).
+     * Has one argument, the name of the share scope.
+     * Creates a share scope if not existing
+     */
+    readonly initializeSharing: "__webpack_require__.I";
+    /**
+     * The current scope when getting a module from a remote
+     */
+    readonly currentRemoteGetScope: "__webpack_require__.R";
+    /**
+     * the filename of the HMR manifest
+     */
+    readonly getUpdateManifestFilename: "__webpack_require__.hmrF";
+    /**
+     * function downloading the update manifest
+     */
+    readonly hmrDownloadManifest: "__webpack_require__.hmrM";
+    /**
+     * array with handler functions to download chunk updates
+     */
+    readonly hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
+    /**
+     * object with all hmr module data for all modules
+     */
+    readonly hmrModuleData: "__webpack_require__.hmrD";
+    /**
+     * array with handler functions when a module should be invalidated
+     */
+    readonly hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
+    /**
+     * the prefix for storing state of runtime modules when hmr is enabled
+     */
+    readonly hmrRuntimeStatePrefix: "__webpack_require__.hmrS";
+    /**
+     * the AMD define function
+     */
+    readonly amdDefine: "__webpack_require__.amdD";
+    /**
+     * the AMD options
+     */
+    readonly amdOptions: "__webpack_require__.amdO";
+    /**
+     * the System polyfill object
+     */
+    readonly system: "__webpack_require__.System";
+    /**
+     * the shorthand for Object.prototype.hasOwnProperty
+     * using of it decreases the compiled bundle size
+     */
+    readonly hasOwnProperty: "__webpack_require__.o";
+    /**
+     * the System.register context object
+     */
+    readonly systemContext: "__webpack_require__.y";
+    /**
+     * the baseURI of current document
+     */
+    readonly baseURI: "__webpack_require__.b";
+    /**
+     * a RelativeURL class when relative URLs are used
+     */
+    readonly relativeUrl: "__webpack_require__.U";
+    /**
+     * Creates an async module. The body function must be a async function.
+     * "module.exports" will be decorated with an AsyncModulePromise.
+     * The body function will be called.
+     * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
+     * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
+     * Signature: function(
+     * module: Module,
+     * body: (handleDependencies: (deps: AsyncModulePromise[]) =\> Promise\<any[]\> & () =\> void,
+     * hasAwaitAfterDependencies?: boolean
+     * ) =\> void
+     */
+    readonly asyncModule: "__webpack_require__.a";
+};
+export declare const isReservedRuntimeGlobal: (r: string) => boolean;

package/dist/RuntimeModule.d.ts

@@ -0,0 +1,32 @@
+import type { JsAddingRuntimeModule } from "@rspack/binding";
+import type { Chunk } from "./Chunk";
+import type { ChunkGraph } from "./ChunkGraph";
+import type { Compilation } from "./Compilation";
+export declare enum RuntimeModuleStage {
+    NORMAL = 0,
+    BASIC = 5,
+    ATTACH = 10,
+    TRIGGER = 20
+}
+export declare class RuntimeModule {
+    static STAGE_NORMAL: RuntimeModuleStage;
+    static STAGE_BASIC: RuntimeModuleStage;
+    static STAGE_ATTACH: RuntimeModuleStage;
+    static STAGE_TRIGGER: RuntimeModuleStage;
+    static __to_binding(compilation: Compilation, module: RuntimeModule): JsAddingRuntimeModule;
+    private _name;
+    private _stage;
+    fullHash: boolean;
+    dependentHash: boolean;
+    protected chunk: Chunk | null;
+    protected compilation: Compilation | null;
+    protected chunkGraph: ChunkGraph | null;
+    constructor(name: string, stage?: RuntimeModuleStage);
+    attach(compilation: Compilation, chunk: Chunk, chunkGraph: ChunkGraph): void;
+    get name(): string;
+    get stage(): RuntimeModuleStage;
+    identifier(): string;
+    readableIdentifier(): string;
+    shouldIsolate(): boolean;
+    generate(): string;
+}

package/dist/Stats.d.ts

@@ -0,0 +1,17 @@
+import type { Compilation } from "./Compilation";
+import type { StatsOptions, StatsValue } from "./config";
+import type { StatsCompilation } from "./stats/statsFactoryUtils";
+export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule } from "./stats/statsFactoryUtils";
+export declare class Stats {
+    #private;
+    constructor(compilation: Compilation);
+    get compilation(): Compilation;
+    get hash(): Readonly<string | null>;
+    get startTime(): number | undefined;
+    get endTime(): number | undefined;
+    hasErrors(): boolean;
+    hasWarnings(): boolean;
+    toJson(opts?: StatsValue, forToString?: boolean): StatsCompilation;
+    toString(opts?: StatsValue): string;
+}
+export declare function normalizeStatsPreset(options?: StatsValue): StatsOptions;

package/dist/Template.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Template.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+declare class Template {
+    /**
+     *
+     * @param fn a runtime function (.runtime.js) "template"
+     * @returns the updated and normalized function string
+     */
+    static getFunctionContent(fn: Function): string;
+    /**
+     * @param str the string converted to identifier
+     * @returns created identifier
+     */
+    static toIdentifier(str: any): string;
+    /**
+     *
+     * @param str string to be converted to commented in bundle code
+     * @returns returns a commented version of string
+     */
+    static toComment(str: string): string;
+    /**
+     *
+     * @param str string to be converted to "normal comment"
+     * @returns returns a commented version of string
+     */
+    static toNormalComment(str: string): string;
+    /**
+     * @param str string path to be normalized
+     * @returns normalized bundle-safe path
+     */
+    static toPath(str: string): string;
+    /**
+     * @param num number to convert to ident
+     * @returns returns single character ident
+     */
+    static numberToIdentifier(num: number): string;
+    /**
+     * @param num number to convert to ident
+     * @returns returns single character ident
+     */
+    static numberToIdentifierContinuation(num: number): string;
+    /**
+     *
+     * @param s string to convert to identity
+     * @returns converted identity
+     */
+    static indent(s: string | string[]): string;
+    /**
+     *
+     * @param s string to create prefix for
+     * @param prefix prefix to compose
+     * @returns returns new prefix string
+     */
+    static prefix(s: string | string[], prefix: string): string;
+    /**
+     *
+     * @param str string or string collection
+     * @returns returns a single string from array
+     */
+    static asString(str: string | string[]): string;
+    /**
+     * @param modules a collection of modules to get array bounds for
+     * @returns returns the upper and lower array bounds
+     * or false if not every module has a number based id
+     */
+    static getModulesArrayBounds(modules: {
+        id: string | number;
+    }[]): [number, number] | false;
+}
+export { Template };

package/dist/Watching.d.ts

@@ -0,0 +1,47 @@
+import type { Callback } from "@rspack/lite-tapable";
+import type { Compiler } from ".";
+import { Stats } from ".";
+import type { WatchOptions } from "./config";
+import type { Watcher } from "./util/fs";
+export declare class Watching {
+    #private;
+    watcher?: Watcher;
+    pausedWatcher?: Watcher;
+    compiler: Compiler;
+    handler: Callback<Error, Stats>;
+    callbacks: Callback<Error, void>[];
+    watchOptions: WatchOptions;
+    lastWatcherStartTime: number;
+    running: boolean;
+    blocked: boolean;
+    isBlocked: () => boolean;
+    onChange: () => void;
+    onInvalid: () => void;
+    invalid: boolean;
+    startTime?: number;
+    suspended: boolean;
+    constructor(compiler: Compiler, watchOptions: WatchOptions, handler: Callback<Error, Stats>);
+    watch(files: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, dirs: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, missing: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }): void;
+    close(callback?: () => void): void;
+    invalidate(callback?: Callback<Error, void>): void;
+    /**
+     * @internal This is not a public API yet, still unstable, might change in the future
+     */
+    invalidateWithChangesAndRemovals(changedFiles?: Set<string>, removedFiles?: Set<string>, callback?: Callback<Error, void>): void;
+    /**
+     * The reason why this is _done instead of #done, is that in Webpack,
+     * it will rewrite this function to another function
+     */
+    private _done;
+    suspend(): void;
+    resume(): void;
+}

package/dist/browser/buffer.d.ts

@@ -0,0 +1 @@
+export { Buffer } from "@napi-rs/wasm-runtime/fs";

package/dist/browser/fs.d.ts

@@ -0,0 +1,12 @@
+import type { IFs, Volume } from "memfs";
+export declare const fs: IFs;
+export declare const volume: Volume;
+declare const readFileSync: (file: import("memfs/lib/volume").TFileId, options?: import("memfs/lib/node/types/options").IReadFileOptions | string) => import("memfs/lib/encoding").TDataOut, readdirSync: (path: import("memfs/lib/node/types/misc").PathLike, options?: import("memfs/lib/node/types/options").IReaddirOptions | string) => import("memfs/lib/encoding").TDataOut[] | import("memfs/lib/Dirent").Dirent[], lstat: {
+    (path: import("memfs/lib/node/types/misc").PathLike, callback: import("memfs/lib/volume").TCallback<import("memfs/lib/Stats").Stats>): void;
+    (path: import("memfs/lib/node/types/misc").PathLike, options: import("memfs/lib/node/types/options").IStatOptions, callback: import("memfs/lib/volume").TCallback<import("memfs/lib/Stats").Stats>): void;
+}, existsSync: (path: import("memfs/lib/node/types/misc").PathLike) => boolean, readdir: {
+    (path: import("memfs/lib/node/types/misc").PathLike, callback: import("memfs/lib/volume").TCallback<import("memfs/lib/encoding").TDataOut[] | import("memfs/lib/Dirent").Dirent[]>): any;
+    (path: import("memfs/lib/node/types/misc").PathLike, options: import("memfs/lib/node/types/options").IReaddirOptions | string, callback: import("memfs/lib/volume").TCallback<import("memfs/lib/encoding").TDataOut[] | import("memfs/lib/Dirent").Dirent[]>): any;
+}, watch: (path: import("memfs/lib/node/types/misc").PathLike, options?: import("memfs/lib/volume").IWatchOptions | string, listener?: (eventType: string, filename: string) => void) => import("memfs/lib/volume").FSWatcher;
+export default fs;
+export { readFileSync, readdirSync, lstat, existsSync, readdir, watch };

package/dist/browser/index.d.ts

@@ -0,0 +1,5 @@
+export * from "../index";
+export declare const builtinMemFs: {
+    fs: import("memfs").IFs;
+    volume: import("memfs").Volume;
+};

package/dist/browser/service.d.ts

@@ -0,0 +1,3 @@
+export declare enum RequestType {
+}
+export declare function run(): Promise<void>;

package/dist/builtin-loader/index.d.ts

@@ -0,0 +1 @@
+export * from "./swc";

package/dist/builtin-loader/lightningcss/index.d.ts

@@ -0,0 +1,117 @@
+/**
+MIT License
+
+Copyright (c) 2021-present Devon Govett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+export declare function toFeatures(featureOptions: FeatureOptions): Features;
+export declare enum Features {
+    Empty = 0,
+    Nesting = 1,
+    NotSelectorList = 2,
+    DirSelector = 4,
+    LangSelectorList = 8,
+    IsSelector = 16,
+    TextDecorationThicknessPercent = 32,
+    MediaIntervalSyntax = 64,
+    MediaRangeSyntax = 128,
+    CustomMediaQueries = 256,
+    ClampFunction = 512,
+    ColorFunction = 1024,
+    OklabColors = 2048,
+    LabColors = 4096,
+    P3Colors = 8192,
+    HexAlphaColors = 16384,
+    SpaceSeparatedColorNotation = 32768,
+    FontFamilySystemUi = 65536,
+    DoublePositionGradients = 131072,
+    VendorPrefixes = 262144,
+    LogicalProperties = 524288,
+    Selectors = 31,
+    MediaQueries = 448,
+    Color = 64512
+}
+export interface Targets {
+    android?: number;
+    chrome?: number;
+    edge?: number;
+    firefox?: number;
+    ie?: number;
+    ios_saf?: number;
+    opera?: number;
+    safari?: number;
+    samsung?: number;
+}
+export interface Drafts {
+    /** Whether to enable @custom-media rules. */
+    customMedia?: boolean;
+}
+export interface NonStandard {
+    /** Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue. */
+    deepSelectorCombinator?: boolean;
+}
+export interface PseudoClasses {
+    hover?: string;
+    active?: string;
+    focus?: string;
+    focusVisible?: string;
+    focusWithin?: string;
+}
+export type FeatureOptions = {
+    nesting?: boolean;
+    notSelectorList?: boolean;
+    dirSelector?: boolean;
+    langSelectorList?: boolean;
+    isSelector?: boolean;
+    textDecorationThicknessPercent?: boolean;
+    mediaIntervalSyntax?: boolean;
+    mediaRangeSyntax?: boolean;
+    customMediaQueries?: boolean;
+    clampFunction?: boolean;
+    colorFunction?: boolean;
+    oklabColors?: boolean;
+    labColors?: boolean;
+    p3Colors?: boolean;
+    hexAlphaColors?: boolean;
+    spaceSeparatedColorNotation?: boolean;
+    fontFamilySystemUi?: boolean;
+    doublePositionGradients?: boolean;
+    vendorPrefixes?: boolean;
+    logicalProperties?: boolean;
+    selectors?: boolean;
+    mediaQueries?: boolean;
+    color?: boolean;
+};
+export type LoaderOptions = {
+    minify?: boolean;
+    errorRecovery?: boolean;
+    targets?: Targets | string[] | string;
+    include?: FeatureOptions;
+    exclude?: FeatureOptions;
+    /**
+     * @deprecated Use `drafts` instead.
+     * This will be removed in the next major version.
+     */
+    draft?: Drafts;
+    drafts?: Drafts;
+    nonStandard?: NonStandard;
+    pseudoClasses?: PseudoClasses;
+    unusedSymbols?: string[];
+};

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

@@ -0,0 +1,21 @@
+export type CollectTypeScriptInfoOptions = {
+    /**
+     * Whether to collect type exports information for `typeReexportsPresence`.
+     * This is used to check type exports of submodules when running in `'tolerant'` mode.
+     * @default false
+     */
+    typeExports?: boolean;
+    /**
+     * Whether to collect information about exported `enum`s.
+     * - `true` will collect all `enum` information, including `const enum`s and regular `enum`s.
+     * - `false` will not collect any `enum` information.
+     * - `'const-only'` will gather only `const enum`s, enabling Rspack to perform cross-module
+     * inlining optimizations for them.
+     * @default false
+     */
+    exportedEnum?: boolean | "const-only";
+};
+export declare function resolveCollectTypeScriptInfo(options: CollectTypeScriptInfoOptions): {
+    typeExports: boolean | undefined;
+    exportedEnum: string;
+};

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

@@ -0,0 +1,5 @@
+export type { CollectTypeScriptInfoOptions } from "./collectTypeScriptInfo";
+export { resolveCollectTypeScriptInfo } from "./collectTypeScriptInfo";
+export type { PluginImportOptions } from "./pluginImport";
+export { resolvePluginImport } from "./pluginImport";
+export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./types";