@rspack/core 0.5.9 → 0.6.0-canary-77faf73-20240410004447

package/dist/ContextModuleFactory.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextModuleFactory = void 0;
-const tapable_1 = require("tapable");
+const liteTapable = __importStar(require("./lite-tapable"));
 class ContextModuleFactory {
     constructor() {
         this.hooks = {
@@ -18,8 +41,8 @@ class ContextModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
             // factorize: new AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
-            beforeResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"]),
-            afterResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"])
+            beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
+            afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"])
             // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             // createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
             // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */

package/dist/ExecuteModulePlugin.js

@@ -13,10 +13,10 @@ class ExecuteModulePlugin {
                 const moduleObject = options.moduleObject;
                 const source = options.codeGenerationResult.get("javascript");
                 try {
-                    const fn = node_vm_1.default.runInThisContext(`(function(module, __webpack_exports__, ${_1.RuntimeGlobals.require}) {\n${source}\n})`, {
+                    const fn = node_vm_1.default.runInThisContext(`(function(module, __webpack_module__, __webpack_exports__, exports, ${_1.RuntimeGlobals.require}) {\n${source}\n})`, {
                         filename: moduleObject.id
                     });
-                    fn.call(moduleObject.exports, moduleObject, moduleObject.exports, context.__webpack_require__);
+                    fn.call(moduleObject.exports, moduleObject, moduleObject, moduleObject.exports, moduleObject.exports, context.__webpack_require__);
                 }
                 catch (e) {
                     let err = e instanceof Error ? e : new Error(e);

package/dist/Module.d.ts

@@ -1,8 +1,27 @@
-import { JsCodegenerationResult, JsCodegenerationResults, JsModule } from "@rspack/binding";
+import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsModule } from "@rspack/binding";
 import { Source } from "webpack-sources";
+export type ResourceData = {
+    resource: string;
+    path: string;
+    query?: string;
+    fragment?: string;
+};
+export type ResourceDataWithData = ResourceData & {
+    data?: Record<string, any>;
+};
+export type CreateData = Partial<JsCreateData>;
+export type ResolveData = {
+    context: string;
+    request: string;
+    fileDependencies: string[];
+    missingDependencies: string[];
+    contextDependencies: string[];
+    createData?: CreateData;
+};
 export declare class Module {
     #private;
     _originalSource?: Source;
+    rawRequest?: string;
     static __from_binding(module: JsModule): Module;
     constructor(module: JsModule);
     get context(): string | undefined;

package/dist/Module.js

@@ -21,6 +21,7 @@ class Module {
     constructor(module) {
         _Module_inner.set(this, void 0);
         __classPrivateFieldSet(this, _Module_inner, module, "f");
+        this.rawRequest = module.rawRequest;
     }
     get context() {
         return __classPrivateFieldGet(this, _Module_inner, "f").context;

package/dist/NormalModuleFactory.d.ts

@@ -1,33 +1,18 @@
-import { AsyncSeriesBailHook, HookMap } from "tapable";
 import * as liteTapable from "./lite-tapable";
 import type * as binding from "@rspack/binding";
-type ResourceData = {
-    resource: string;
-    path: string;
-    query?: string;
-    fragment?: string;
-};
-type ResourceDataWithData = ResourceData & {
-    data?: Record<string, any>;
-};
-type ResolveData = {
-    context?: string;
-    request: string;
-    fileDependencies: string[];
-    missingDependencies: string[];
-    contextDependencies: string[];
-};
-type CreateModuleData = binding.CreateModuleData & {
+import { ResolveData, ResourceDataWithData } from "./Module";
+export type NormalModuleCreateData = binding.JsNormalModuleFactoryCreateModuleArgs & {
     settings: {};
-    matchResource: string;
 };
 export declare class NormalModuleFactory {
     hooks: {
-        resolveForScheme: HookMap<AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
+        resolveForScheme: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
         beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
-        afterResolve: AsyncSeriesBailHook<[ResolveData], boolean | void>;
-        createModule: AsyncSeriesBailHook<[CreateModuleData, {}], void>;
+        afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        createModule: liteTapable.AsyncSeriesBailHook<[
+            NormalModuleCreateData,
+            {}
+        ], void>;
     };
     constructor();
 }
-export {};

package/dist/NormalModuleFactory.js

@@ -24,7 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NormalModuleFactory = void 0;
-const tapable_1 = require("tapable");
 const liteTapable = __importStar(require("./lite-tapable"));
 class NormalModuleFactory {
     constructor() {
@@ -32,7 +31,7 @@ class NormalModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
             // resolve: new AsyncSeriesBailHook(["resolveData"]),
             // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-            resolveForScheme: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(["resourceData"])),
+            resolveForScheme: new liteTapable.HookMap(() => new liteTapable.AsyncSeriesBailHook(["resourceData"])),
             // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
             // resolveInScheme: new HookMap(
             // 	() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
@@ -42,9 +41,12 @@ class NormalModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
-            afterResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"]),
+            afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
-            createModule: new tapable_1.AsyncSeriesBailHook(["createData", "resolveData"])
+            createModule: new liteTapable.AsyncSeriesBailHook([
+                "createData",
+                "resolveData"
+            ])
             // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
             // module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
             // createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),

package/dist/Stats.js

@@ -103,8 +103,8 @@ function normalizeStatsPreset(options) {
 }
 exports.normalizeStatsPreset = normalizeStatsPreset;
 function presetToOptions(name) {
-    const pn = (typeof name === "string" && name.toLowerCase()) || name;
-    switch (pn) {
+    const preset = (typeof name === "string" && name.toLowerCase()) || name;
+    switch (preset) {
         case "none":
             return {
                 all: false

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

@@ -0,0 +1,10 @@
+import { BuiltinPluginName } from "@rspack/binding";
+export declare const APIPlugin: {
+    new (): {
+        name: BuiltinPluginName;
+        _options: void;
+        affectedHooks: "make" | "compile" | "emit" | "afterEmit" | "invalid" | "done" | "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(): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("../Compiler").Compiler): void;
+    };
+};

package/dist/builtin-plugin/APIPlugin.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIPlugin = void 0;
+const binding_1 = require("@rspack/binding");
+const base_1 = require("./base");
+exports.APIPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.APIPlugin, () => { });

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

@@ -0,0 +1,10 @@
+import { BuiltinPluginName } from "@rspack/binding";
+export declare const CssModulesPlugin: {
+    new (): {
+        name: BuiltinPluginName;
+        _options: void;
+        affectedHooks: "make" | "compile" | "emit" | "afterEmit" | "invalid" | "done" | "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(): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("../Compiler").Compiler): void;
+    };
+};

package/dist/builtin-plugin/CssModulesPlugin.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CssModulesPlugin = void 0;
+const binding_1 = require("@rspack/binding");
+const base_1 = require("./base");
+exports.CssModulesPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.CssModulesPlugin, () => { }, "compilation");

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

@@ -9,6 +9,7 @@ export type EntryOptions = {
     baseUri?: string;
     filename?: FilenameTemplate;
     library?: LibraryOptions;
+    dependOn?: string[];
 };
 export declare const EntryPlugin: {
     new (context: string, entry: string, options?: string | EntryOptions | undefined): {

package/dist/builtin-plugin/EntryPlugin.js

@@ -12,7 +12,7 @@ exports.EntryPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.EntryPlugin
         entry,
         options: getRawEntryOptions(entryOptions)
     };
-});
+}, "make");
 function getRawEntryOptions(entry) {
     const runtime = entry.runtime;
     const chunkLoading = entry.chunkLoading;
@@ -26,6 +26,7 @@ function getRawEntryOptions(entry) {
             : undefined,
         asyncChunks: entry.asyncChunks,
         filename: entry.filename,
-        library: entry.library && (0, config_1.getRawLibrary)(entry.library)
+        library: entry.library && (0, config_1.getRawLibrary)(entry.library),
+        dependOn: entry.dependOn
     };
 }

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

@@ -4,7 +4,7 @@ export declare const ExternalsPlugin: {
         context?: string | undefined;
         dependencyType?: string | undefined;
         request?: string | undefined;
-    }, args_1: (args_0: Error | undefined, args_1: string | boolean | string[] | Record<string, string | string[]> | undefined, args_2: "module" | "promise" | "script" | "commonjs" | "jsonp" | "import" | "amd" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "global" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd" | "umd2" | "system" | "node-commonjs" | undefined, ...args_3: unknown[]) => void, ...args_2: unknown[]) => unknown) | ((args_0: {
+    }, args_1: (args_0: Error | undefined, args_1: string | boolean | string[] | Record<string, string | string[]> | undefined, args_2: "module" | "promise" | "script" | "commonjs" | "global" | "import" | "amd" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd" | "umd2" | "jsonp" | "system" | "node-commonjs" | undefined, ...args_3: unknown[]) => void, ...args_2: unknown[]) => unknown) | ((args_0: {
         context?: string | undefined;
         dependencyType?: string | undefined;
         request?: string | undefined;
@@ -12,7 +12,7 @@ export declare const ExternalsPlugin: {
         context?: string | undefined;
         dependencyType?: string | undefined;
         request?: string | undefined;
-    }, args_1: (args_0: Error | undefined, args_1: string | boolean | string[] | Record<string, string | string[]> | undefined, args_2: "module" | "promise" | "script" | "commonjs" | "jsonp" | "import" | "amd" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "global" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd" | "umd2" | "system" | "node-commonjs" | undefined, ...args_3: unknown[]) => void, ...args_2: unknown[]) => unknown) | ((args_0: {
+    }, args_1: (args_0: Error | undefined, args_1: string | boolean | string[] | Record<string, string | string[]> | undefined, args_2: "module" | "promise" | "script" | "commonjs" | "global" | "import" | "amd" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd" | "umd2" | "jsonp" | "system" | "node-commonjs" | undefined, ...args_3: unknown[]) => void, ...args_2: unknown[]) => unknown) | ((args_0: {
         context?: string | undefined;
         dependencyType?: string | undefined;
         request?: string | undefined;

package/dist/builtin-plugin/JsLoaderRspackPlugin.js

@@ -4,4 +4,6 @@ exports.JsLoaderRspackPlugin = void 0;
 const binding_1 = require("@rspack/binding");
 const base_1 = require("./base");
 const loader_runner_1 = require("../loader-runner");
-exports.JsLoaderRspackPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.JsLoaderRspackPlugin, (compiler) => loader_runner_1.runLoaders.bind(null, compiler), "compilation");
+exports.JsLoaderRspackPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.JsLoaderRspackPlugin, (compiler) => loader_runner_1.runLoaders.bind(null, compiler), 
+/* Not Inheretable */
+"thisCompilation");

package/dist/builtin-plugin/SplitChunksPlugin.js

@@ -65,10 +65,11 @@ function toRawSplitChunksOptions(sc, compiler) {
             return chunks;
         }
     }
-    const { name, chunks, cacheGroups = {}, fallbackCacheGroup, ...passThrough } = sc;
+    const { name, chunks, defaultSizeTypes, cacheGroups = {}, fallbackCacheGroup, ...passThrough } = sc;
     return {
         name: getName(name),
         chunks: getChunks(chunks),
+        defaultSizeTypes: defaultSizeTypes || ["javascript", "unknown"],
         cacheGroups: Object.entries(cacheGroups)
             .filter(([_key, group]) => group !== false)
             .map(([key, group]) => {

package/dist/builtin-plugin/css-extract/hmr/hotModuleReplacement.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(moduleId: TODO, options: TODO): TODO;
+export = _exports;
+export type TODO = any;

package/dist/builtin-plugin/css-extract/hmr/hotModuleReplacement.js

@@ -0,0 +1,222 @@
+"use strict";
+/* eslint-env browser */
+/*
+  eslint-disable
+  no-console,
+  func-names
+*/
+/** @typedef {any} TODO */
+const normalizeUrl = require("./normalize-url");
+const srcByModuleId = Object.create(null);
+const noDocument = typeof document === "undefined";
+const { forEach } = Array.prototype;
+/**
+ * @param {function} fn
+ * @param {number} time
+ * @returns {(function(): void)|*}
+ */
+function debounce(fn, time) {
+    let timeout = 0;
+    return function () {
+        // @ts-ignore
+        const self = this;
+        // eslint-disable-next-line prefer-rest-params
+        const args = arguments;
+        const functionCall = function functionCall() {
+            return fn.apply(self, args);
+        };
+        clearTimeout(timeout);
+        // @ts-ignore
+        timeout = setTimeout(functionCall, time);
+    };
+}
+function noop() { }
+/**
+ * @param {TODO} moduleId
+ * @returns {TODO}
+ */
+function getCurrentScriptUrl(moduleId) {
+    let src = srcByModuleId[moduleId];
+    if (!src) {
+        if (document.currentScript) {
+            ({ src } = /** @type {HTMLScriptElement} */ (document.currentScript));
+        }
+        else {
+            const scripts = document.getElementsByTagName("script");
+            const lastScriptTag = scripts[scripts.length - 1];
+            if (lastScriptTag) {
+                ({ src } = lastScriptTag);
+            }
+        }
+        srcByModuleId[moduleId] = src;
+    }
+    /**
+     * @param {string} fileMap
+     * @returns {null | string[]}
+     */
+    return function (fileMap) {
+        if (!src) {
+            return null;
+        }
+        const splitResult = src.split(/([^\\/]+)\.js$/);
+        const filename = splitResult && splitResult[1];
+        if (!filename) {
+            return [src.replace(".js", ".css")];
+        }
+        if (!fileMap) {
+            return [src.replace(".js", ".css")];
+        }
+        return fileMap.split(",").map(mapRule => {
+            const reg = new RegExp(`${filename}\\.js$`, "g");
+            return normalizeUrl(src.replace(reg, `${mapRule.replace(/{fileName}/g, filename)}.css`));
+        });
+    };
+}
+/**
+ * @param {TODO} el
+ * @param {string} [url]
+ */
+function updateCss(el, url) {
+    if (!url) {
+        if (!el.href) {
+            return;
+        }
+        // eslint-disable-next-line
+        url = el.href.split("?")[0];
+    }
+    if (!isUrlRequest(/** @type {string} */ (url))) {
+        return;
+    }
+    if (el.isLoaded === false) {
+        // We seem to be about to replace a css link that hasn't loaded yet.
+        // We're probably changing the same file more than once.
+        return;
+    }
+    if (!url || !(url.indexOf(".css") > -1)) {
+        return;
+    }
+    // eslint-disable-next-line no-param-reassign
+    el.visited = true;
+    const newEl = el.cloneNode();
+    newEl.isLoaded = false;
+    newEl.addEventListener("load", () => {
+        if (newEl.isLoaded) {
+            return;
+        }
+        newEl.isLoaded = true;
+        el.parentNode.removeChild(el);
+    });
+    newEl.addEventListener("error", () => {
+        if (newEl.isLoaded) {
+            return;
+        }
+        newEl.isLoaded = true;
+        el.parentNode.removeChild(el);
+    });
+    newEl.href = `${url}?${Date.now()}`;
+    if (el.nextSibling) {
+        el.parentNode.insertBefore(newEl, el.nextSibling);
+    }
+    else {
+        el.parentNode.appendChild(newEl);
+    }
+}
+/**
+ * @param {string} href
+ * @param {TODO} src
+ * @returns {TODO}
+ */
+function getReloadUrl(href, src) {
+    let ret;
+    // eslint-disable-next-line no-param-reassign
+    href = normalizeUrl(href);
+    src.some(
+    /**
+     * @param {string} url
+     */
+    // eslint-disable-next-line array-callback-return
+    url => {
+        if (href.indexOf(src) > -1) {
+            ret = url;
+        }
+    });
+    return ret;
+}
+/**
+ * @param {string} [src]
+ * @returns {boolean}
+ */
+function reloadStyle(src) {
+    if (!src) {
+        return false;
+    }
+    const elements = document.querySelectorAll("link");
+    let loaded = false;
+    forEach.call(elements, el => {
+        if (!el.href) {
+            return;
+        }
+        const url = getReloadUrl(el.href, src);
+        if (!isUrlRequest(url)) {
+            return;
+        }
+        if (el.visited === true) {
+            return;
+        }
+        if (url) {
+            updateCss(el, url);
+            loaded = true;
+        }
+    });
+    return loaded;
+}
+function reloadAll() {
+    const elements = document.querySelectorAll("link");
+    forEach.call(elements, el => {
+        if (el.visited === true) {
+            return;
+        }
+        updateCss(el);
+    });
+}
+/**
+ * @param {string} url
+ * @returns {boolean}
+ */
+function isUrlRequest(url) {
+    // An URL is not an request if
+    // It is not http or https
+    if (!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {TODO} moduleId
+ * @param {TODO} options
+ * @returns {TODO}
+ */
+module.exports = function (moduleId, options) {
+    if (noDocument) {
+        console.log("no window.document found, will not HMR CSS");
+        return noop;
+    }
+    const getScriptSrc = getCurrentScriptUrl(moduleId);
+    function update() {
+        const src = getScriptSrc(options.filename);
+        const reloaded = reloadStyle(src);
+        if (options.locals) {
+            console.log("[HMR] Detected local css modules. Reload all css");
+            reloadAll();
+            return;
+        }
+        if (reloaded) {
+            console.log("[HMR] css reload %s", src.join(" "));
+        }
+        else {
+            console.log("[HMR] Reload all css");
+            reloadAll();
+        }
+    }
+    return debounce(update, 50);
+};

package/dist/builtin-plugin/css-extract/hmr/normalize-url.d.ts

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

package/dist/builtin-plugin/css-extract/hmr/normalize-url.js

@@ -0,0 +1,38 @@
+"use strict";
+/* eslint-disable */
+/**
+ * @param {string[]} pathComponents
+ * @returns {string}
+ */
+function normalizeUrl(pathComponents) {
+    return pathComponents
+        .reduce(function (accumulator, item) {
+        switch (item) {
+            case "..":
+                accumulator.pop();
+                break;
+            case ".":
+                break;
+            default:
+                accumulator.push(item);
+        }
+        return accumulator;
+    }, /** @type {string[]} */ ([]))
+        .join("/");
+}
+/**
+ * @param {string} urlString
+ * @returns {string}
+ */
+module.exports = function (urlString) {
+    urlString = urlString.trim();
+    if (/^data:/i.test(urlString)) {
+        return urlString;
+    }
+    var protocol = urlString.indexOf("//") !== -1 ? urlString.split("//")[0] + "//" : "";
+    var components = urlString.replace(new RegExp(protocol, "i"), "").split("/");
+    var host = components[0].toLowerCase().replace(/\.$/, "");
+    components[0] = "";
+    var path = normalizeUrl(components);
+    return protocol + host + path;
+};

package/dist/builtin-plugin/css-extract/index.d.ts

@@ -0,0 +1,22 @@
+import type { RawCssExtractPluginOption } from "@rspack/binding";
+import { Compiler } from "../..";
+export * from "./loader";
+export interface PluginOptions {
+    filename?: string;
+    chunkFilename?: string;
+    ignoreOrder?: boolean;
+    insert?: string | ((linkTag: HTMLLinkElement) => void);
+    attributes?: Record<string, string>;
+    linkType?: string | "text/css" | false;
+    runtime?: boolean;
+    pathinfo?: boolean;
+}
+export declare class CssExtractRspackPlugin {
+    static pluginName: string;
+    static loader: string;
+    options: PluginOptions;
+    constructor(options?: PluginOptions);
+    apply(compiler: Compiler): void;
+    normalizeOptions(options: PluginOptions): RawCssExtractPluginOption;
+}
+export default CssExtractRspackPlugin;