@rsbuild/core 2.0.10 → 2.0.12

package/dist/756.js

@@ -3084,10 +3084,10 @@ function exitHook(onExit) {
         exitHook_callbacks.delete(onExit);
     };
 }
-let addTrailingSlash = (s)=>s.endsWith('/') ? s : `${s}/`, isURL = (str)=>str.startsWith('http') || str.startsWith('//'), urlJoin = (base, path)=>{
+let removeTailingSlash = (s)=>s.endsWith('/') ? s.replace(/\/+$/, '') : s, addTrailingSlash = (s)=>s.endsWith('/') ? s : `${s}/`, isURL = (str)=>str.startsWith('http') || str.startsWith('//'), urlJoin = (base, path)=>{
     let [urlProtocol, baseUrl] = base.split('://');
     return `${urlProtocol}://${posix.join(baseUrl, path)}`;
-}, ensureAssetPrefix = (url, assetPrefix = "/")=>url.startsWith('//') || external_node_url_URL.canParse(url) || 'auto' === assetPrefix || 'function' == typeof assetPrefix ? url : assetPrefix.startsWith('http') ? urlJoin(assetPrefix, url) : assetPrefix.startsWith('//') ? urlJoin(`https:${assetPrefix}`, url).replace('https:', '') : posix.join(assetPrefix, url), formatPublicPath = (publicPath, withSlash = !0)=>'auto' === publicPath || '' === publicPath ? publicPath : withSlash ? addTrailingSlash(publicPath) : publicPath.replace(/\/+$/, ''), getPublicPathFromChain = (chain, withSlash = !0)=>{
+}, ensureAssetPrefix = (url, assetPrefix = "/")=>url.startsWith('//') || external_node_url_URL.canParse(url) || 'auto' === assetPrefix || 'function' == typeof assetPrefix ? url : assetPrefix.startsWith('http') ? urlJoin(assetPrefix, url) : assetPrefix.startsWith('//') ? urlJoin(`https:${assetPrefix}`, url).replace('https:', '') : posix.join(assetPrefix, url), formatPublicPath = (publicPath, withSlash = !0)=>'auto' === publicPath || '' === publicPath ? publicPath : withSlash ? addTrailingSlash(publicPath) : removeTailingSlash(publicPath), getPublicPathFromChain = (chain, withSlash = !0)=>{
     let publicPath = chain.output.get('publicPath');
     return 'string' == typeof publicPath ? formatPublicPath(publicPath, withSlash) : formatPublicPath("/", withSlash);
 };
@@ -3483,7 +3483,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig, logger) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "2.0.10",
+        version: "2.0.12",
         rootPath,
         distPath: '',
         cachePath,
@@ -4355,6 +4355,450 @@ function loadEnv({ cwd = process.cwd(), mode = process.env.NODE_ENV || '', prefi
         rawPublicVars
     };
 }
+let mimes = {
+    "3g2": "video/3gpp2",
+    "3gp": "video/3gpp",
+    "3gpp": "video/3gpp",
+    "3mf": "model/3mf",
+    aac: "audio/aac",
+    ac: "application/pkix-attr-cert",
+    adp: "audio/adpcm",
+    adts: "audio/aac",
+    ai: "application/postscript",
+    aml: "application/automationml-aml+xml",
+    amlx: "application/automationml-amlx+zip",
+    amr: "audio/amr",
+    apng: "image/apng",
+    appcache: "text/cache-manifest",
+    appinstaller: "application/appinstaller",
+    appx: "application/appx",
+    appxbundle: "application/appxbundle",
+    asc: "application/pgp-keys",
+    atom: "application/atom+xml",
+    atomcat: "application/atomcat+xml",
+    atomdeleted: "application/atomdeleted+xml",
+    atomsvc: "application/atomsvc+xml",
+    au: "audio/basic",
+    avci: "image/avci",
+    avcs: "image/avcs",
+    avif: "image/avif",
+    aw: "application/applixware",
+    bdoc: "application/bdoc",
+    bin: "application/octet-stream",
+    bmp: "image/bmp",
+    bpk: "application/octet-stream",
+    btf: "image/prs.btif",
+    btif: "image/prs.btif",
+    buffer: "application/octet-stream",
+    ccxml: "application/ccxml+xml",
+    cdfx: "application/cdfx+xml",
+    cdmia: "application/cdmi-capability",
+    cdmic: "application/cdmi-container",
+    cdmid: "application/cdmi-domain",
+    cdmio: "application/cdmi-object",
+    cdmiq: "application/cdmi-queue",
+    cer: "application/pkix-cert",
+    cgm: "image/cgm",
+    cjs: "application/node",
+    class: "application/java-vm",
+    coffee: "text/coffeescript",
+    conf: "text/plain",
+    cpl: "application/cpl+xml",
+    cpt: "application/mac-compactpro",
+    crl: "application/pkix-crl",
+    css: "text/css",
+    csv: "text/csv",
+    cu: "application/cu-seeme",
+    cwl: "application/cwl",
+    cww: "application/prs.cww",
+    davmount: "application/davmount+xml",
+    dbk: "application/docbook+xml",
+    deb: "application/octet-stream",
+    def: "text/plain",
+    deploy: "application/octet-stream",
+    dib: "image/bmp",
+    "disposition-notification": "message/disposition-notification",
+    dist: "application/octet-stream",
+    distz: "application/octet-stream",
+    dll: "application/octet-stream",
+    dmg: "application/octet-stream",
+    dms: "application/octet-stream",
+    doc: "application/msword",
+    dot: "application/msword",
+    dpx: "image/dpx",
+    drle: "image/dicom-rle",
+    dsc: "text/prs.lines.tag",
+    dssc: "application/dssc+der",
+    dtd: "application/xml-dtd",
+    dump: "application/octet-stream",
+    dwd: "application/atsc-dwd+xml",
+    ear: "application/java-archive",
+    ecma: "application/ecmascript",
+    elc: "application/octet-stream",
+    emf: "image/emf",
+    eml: "message/rfc822",
+    emma: "application/emma+xml",
+    emotionml: "application/emotionml+xml",
+    eps: "application/postscript",
+    epub: "application/epub+zip",
+    exe: "application/octet-stream",
+    exi: "application/exi",
+    exp: "application/express",
+    exr: "image/aces",
+    ez: "application/andrew-inset",
+    fdf: "application/fdf",
+    fdt: "application/fdt+xml",
+    fits: "image/fits",
+    g3: "image/g3fax",
+    gbr: "application/rpki-ghostbusters",
+    geojson: "application/geo+json",
+    gif: "image/gif",
+    glb: "model/gltf-binary",
+    gltf: "model/gltf+json",
+    gml: "application/gml+xml",
+    gpx: "application/gpx+xml",
+    gram: "application/srgs",
+    grxml: "application/srgs+xml",
+    gxf: "application/gxf",
+    gz: "application/gzip",
+    h261: "video/h261",
+    h263: "video/h263",
+    h264: "video/h264",
+    heic: "image/heic",
+    heics: "image/heic-sequence",
+    heif: "image/heif",
+    heifs: "image/heif-sequence",
+    hej2: "image/hej2k",
+    held: "application/atsc-held+xml",
+    hjson: "application/hjson",
+    hlp: "application/winhlp",
+    hqx: "application/mac-binhex40",
+    hsj2: "image/hsj2",
+    htm: "text/html",
+    html: "text/html",
+    ics: "text/calendar",
+    ief: "image/ief",
+    ifb: "text/calendar",
+    iges: "model/iges",
+    igs: "model/iges",
+    img: "application/octet-stream",
+    in: "text/plain",
+    ini: "text/plain",
+    ink: "application/inkml+xml",
+    inkml: "application/inkml+xml",
+    ipfix: "application/ipfix",
+    iso: "application/octet-stream",
+    its: "application/its+xml",
+    jade: "text/jade",
+    jar: "application/java-archive",
+    jhc: "image/jphc",
+    jls: "image/jls",
+    jp2: "image/jp2",
+    jpe: "image/jpeg",
+    jpeg: "image/jpeg",
+    jpf: "image/jpx",
+    jpg: "image/jpeg",
+    jpg2: "image/jp2",
+    jpgm: "image/jpm",
+    jpgv: "video/jpeg",
+    jph: "image/jph",
+    jpm: "image/jpm",
+    jpx: "image/jpx",
+    js: "text/javascript",
+    json: "application/json",
+    json5: "application/json5",
+    jsonld: "application/ld+json",
+    jsonml: "application/jsonml+json",
+    jsx: "text/jsx",
+    jt: "model/jt",
+    jxl: "image/jxl",
+    jxr: "image/jxr",
+    jxra: "image/jxra",
+    jxrs: "image/jxrs",
+    jxs: "image/jxs",
+    jxsc: "image/jxsc",
+    jxsi: "image/jxsi",
+    jxss: "image/jxss",
+    kar: "audio/midi",
+    ktx: "image/ktx",
+    ktx2: "image/ktx2",
+    less: "text/less",
+    lgr: "application/lgr+xml",
+    list: "text/plain",
+    litcoffee: "text/coffeescript",
+    log: "text/plain",
+    lostxml: "application/lost+xml",
+    lrf: "application/octet-stream",
+    m1v: "video/mpeg",
+    m21: "application/mp21",
+    m2a: "audio/mpeg",
+    m2t: "video/mp2t",
+    m2ts: "video/mp2t",
+    m2v: "video/mpeg",
+    m3a: "audio/mpeg",
+    m4a: "audio/mp4",
+    m4p: "application/mp4",
+    m4s: "video/iso.segment",
+    ma: "application/mathematica",
+    mads: "application/mads+xml",
+    maei: "application/mmt-aei+xml",
+    man: "text/troff",
+    manifest: "text/cache-manifest",
+    map: "application/json",
+    mar: "application/octet-stream",
+    markdown: "text/markdown",
+    mathml: "application/mathml+xml",
+    mb: "application/mathematica",
+    mbox: "application/mbox",
+    md: "text/markdown",
+    mdx: "text/mdx",
+    me: "text/troff",
+    mesh: "model/mesh",
+    meta4: "application/metalink4+xml",
+    metalink: "application/metalink+xml",
+    mets: "application/mets+xml",
+    mft: "application/rpki-manifest",
+    mid: "audio/midi",
+    midi: "audio/midi",
+    mime: "message/rfc822",
+    mj2: "video/mj2",
+    mjp2: "video/mj2",
+    mjs: "text/javascript",
+    mml: "text/mathml",
+    mods: "application/mods+xml",
+    mov: "video/quicktime",
+    mp2: "audio/mpeg",
+    mp21: "application/mp21",
+    mp2a: "audio/mpeg",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    mp4a: "audio/mp4",
+    mp4s: "application/mp4",
+    mp4v: "video/mp4",
+    mpd: "application/dash+xml",
+    mpe: "video/mpeg",
+    mpeg: "video/mpeg",
+    mpf: "application/media-policy-dataset+xml",
+    mpg: "video/mpeg",
+    mpg4: "video/mp4",
+    mpga: "audio/mpeg",
+    mpp: "application/dash-patch+xml",
+    mrc: "application/marc",
+    mrcx: "application/marcxml+xml",
+    ms: "text/troff",
+    mscml: "application/mediaservercontrol+xml",
+    msh: "model/mesh",
+    msi: "application/octet-stream",
+    msix: "application/msix",
+    msixbundle: "application/msixbundle",
+    msm: "application/octet-stream",
+    msp: "application/octet-stream",
+    mtl: "model/mtl",
+    mts: "video/mp2t",
+    musd: "application/mmt-usd+xml",
+    mxf: "application/mxf",
+    mxmf: "audio/mobile-xmf",
+    mxml: "application/xv+xml",
+    n3: "text/n3",
+    nb: "application/mathematica",
+    nq: "application/n-quads",
+    nt: "application/n-triples",
+    obj: "model/obj",
+    oda: "application/oda",
+    oga: "audio/ogg",
+    ogg: "audio/ogg",
+    ogv: "video/ogg",
+    ogx: "application/ogg",
+    omdoc: "application/omdoc+xml",
+    onepkg: "application/onenote",
+    onetmp: "application/onenote",
+    onetoc: "application/onenote",
+    onetoc2: "application/onenote",
+    opf: "application/oebps-package+xml",
+    opus: "audio/ogg",
+    otf: "font/otf",
+    owl: "application/rdf+xml",
+    oxps: "application/oxps",
+    p10: "application/pkcs10",
+    p7c: "application/pkcs7-mime",
+    p7m: "application/pkcs7-mime",
+    p7s: "application/pkcs7-signature",
+    p8: "application/pkcs8",
+    pdf: "application/pdf",
+    pfr: "application/font-tdpfr",
+    pgp: "application/pgp-encrypted",
+    pkg: "application/octet-stream",
+    pki: "application/pkixcmp",
+    pkipath: "application/pkix-pkipath",
+    pls: "application/pls+xml",
+    png: "image/png",
+    prc: "model/prc",
+    prf: "application/pics-rules",
+    provx: "application/provenance+xml",
+    ps: "application/postscript",
+    pskcxml: "application/pskc+xml",
+    pti: "image/prs.pti",
+    qt: "video/quicktime",
+    raml: "application/raml+yaml",
+    rapd: "application/route-apd+xml",
+    rdf: "application/rdf+xml",
+    relo: "application/p2p-overlay+xml",
+    rif: "application/reginfo+xml",
+    rl: "application/resource-lists+xml",
+    rld: "application/resource-lists-diff+xml",
+    rmi: "audio/midi",
+    rnc: "application/relax-ng-compact-syntax",
+    rng: "application/xml",
+    roa: "application/rpki-roa",
+    roff: "text/troff",
+    rq: "application/sparql-query",
+    rs: "application/rls-services+xml",
+    rsat: "application/atsc-rsat+xml",
+    rsd: "application/rsd+xml",
+    rsheet: "application/urc-ressheet+xml",
+    rss: "application/rss+xml",
+    rtf: "text/rtf",
+    rtx: "text/richtext",
+    rusd: "application/route-usd+xml",
+    s3m: "audio/s3m",
+    sbml: "application/sbml+xml",
+    scq: "application/scvp-cv-request",
+    scs: "application/scvp-cv-response",
+    sdp: "application/sdp",
+    senmlx: "application/senml+xml",
+    sensmlx: "application/sensml+xml",
+    ser: "application/java-serialized-object",
+    setpay: "application/set-payment-initiation",
+    setreg: "application/set-registration-initiation",
+    sgi: "image/sgi",
+    sgm: "text/sgml",
+    sgml: "text/sgml",
+    shex: "text/shex",
+    shf: "application/shf+xml",
+    shtml: "text/html",
+    sieve: "application/sieve",
+    sig: "application/pgp-signature",
+    sil: "audio/silk",
+    silo: "model/mesh",
+    siv: "application/sieve",
+    slim: "text/slim",
+    slm: "text/slim",
+    sls: "application/route-s-tsid+xml",
+    smi: "application/smil+xml",
+    smil: "application/smil+xml",
+    snd: "audio/basic",
+    so: "application/octet-stream",
+    spdx: "text/spdx",
+    spp: "application/scvp-vp-response",
+    spq: "application/scvp-vp-request",
+    spx: "audio/ogg",
+    sql: "application/sql",
+    sru: "application/sru+xml",
+    srx: "application/sparql-results+xml",
+    ssdl: "application/ssdl+xml",
+    ssml: "application/ssml+xml",
+    stk: "application/hyperstudio",
+    stl: "model/stl",
+    stpx: "model/step+xml",
+    stpxz: "model/step-xml+zip",
+    stpz: "model/step+zip",
+    styl: "text/stylus",
+    stylus: "text/stylus",
+    svg: "image/svg+xml",
+    svgz: "image/svg+xml",
+    swidtag: "application/swid+xml",
+    t: "text/troff",
+    t38: "image/t38",
+    td: "application/urc-targetdesc+xml",
+    tei: "application/tei+xml",
+    teicorpus: "application/tei+xml",
+    text: "text/plain",
+    tfi: "application/thraud+xml",
+    tfx: "image/tiff-fx",
+    tif: "image/tiff",
+    tiff: "image/tiff",
+    toml: "application/toml",
+    tr: "text/troff",
+    trig: "application/trig",
+    ts: "video/mp2t",
+    tsd: "application/timestamped-data",
+    tsv: "text/tab-separated-values",
+    ttc: "font/collection",
+    ttf: "font/ttf",
+    ttl: "text/turtle",
+    ttml: "application/ttml+xml",
+    txt: "text/plain",
+    u3d: "model/u3d",
+    u8dsn: "message/global-delivery-status",
+    u8hdr: "message/global-headers",
+    u8mdn: "message/global-disposition-notification",
+    u8msg: "message/global",
+    ubj: "application/ubjson",
+    uri: "text/uri-list",
+    uris: "text/uri-list",
+    urls: "text/uri-list",
+    vcard: "text/vcard",
+    vrml: "model/vrml",
+    vtt: "text/vtt",
+    vxml: "application/voicexml+xml",
+    war: "application/java-archive",
+    wasm: "application/wasm",
+    wav: "audio/wav",
+    weba: "audio/webm",
+    webm: "video/webm",
+    webmanifest: "application/manifest+json",
+    webp: "image/webp",
+    wgsl: "text/wgsl",
+    wgt: "application/widget",
+    wif: "application/watcherinfo+xml",
+    wmf: "image/wmf",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    wrl: "model/vrml",
+    wsdl: "application/wsdl+xml",
+    wspolicy: "application/wspolicy+xml",
+    x3d: "model/x3d+xml",
+    x3db: "model/x3d+fastinfoset",
+    x3dbz: "model/x3d+binary",
+    x3dv: "model/x3d-vrml",
+    x3dvz: "model/x3d+vrml",
+    x3dz: "model/x3d+xml",
+    xaml: "application/xaml+xml",
+    xav: "application/xcap-att+xml",
+    xca: "application/xcap-caps+xml",
+    xcs: "application/calendar+xml",
+    xdf: "application/xcap-diff+xml",
+    xdssc: "application/dssc+xml",
+    xel: "application/xcap-el+xml",
+    xenc: "application/xenc+xml",
+    xer: "application/patch-ops-error+xml",
+    xfdf: "application/xfdf",
+    xht: "application/xhtml+xml",
+    xhtml: "application/xhtml+xml",
+    xhvml: "application/xv+xml",
+    xlf: "application/xliff+xml",
+    xm: "audio/xm",
+    xml: "text/xml",
+    xns: "application/xcap-ns+xml",
+    xop: "application/xop+xml",
+    xpl: "application/xproc+xml",
+    xsd: "application/xml",
+    xsf: "application/prs.xsf+xml",
+    xsl: "application/xml",
+    xslt: "application/xml",
+    xspf: "application/xspf+xml",
+    xvm: "application/xv+xml",
+    xvml: "application/xv+xml",
+    yaml: "text/yaml",
+    yang: "application/yang",
+    yin: "application/yin+xml",
+    yml: "text/yaml",
+    zip: "application/zip"
+};
+function mrmime_lookup(extn) {
+    let tmp = ('' + extn).trim().toLowerCase(), idx = tmp.lastIndexOf('.');
+    return mimes[!~idx ? tmp : tmp.substring(++idx)];
+}
 let chainStaticAssetRule = ({ emit, rule, maxSize, filename, assetType })=>{
     let generatorOptions = {
         filename
@@ -5171,9 +5615,14 @@ let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), formatPrefix = (inp
     if (prefix?.startsWith('./') && (prefix = prefix.replace('./', '')), !prefix) return '/';
     let hasLeadingSlash = prefix.startsWith('/'), hasTailSlash = prefix.endsWith('/');
     return `${hasLeadingSlash ? '' : '/'}${prefix}${hasTailSlash ? '' : '/'}`;
-}, joinUrlPath = (basePath, pathname)=>'' === basePath ? pathname : '' === pathname ? basePath : addTrailingSlash(basePath) + pathname.replace(/^\/+/, ''), removeBasePath = (url, base)=>{
-    let basePath = base.replace(/\/+$/, '');
-    return '' === basePath ? url : url === basePath ? '/' : url.startsWith(`${basePath}/`) ? url.slice(basePath.length) : url;
+}, joinUrlPath = (basePath, pathname)=>'' === basePath ? pathname : '' === pathname ? basePath : addTrailingSlash(basePath) + pathname.replace(/^\/+/, ''), isUrlPathUnderBase = (pathname, base)=>{
+    let basePath = removeTailingSlash(base);
+    return '' === basePath || pathname === basePath || pathname.startsWith(`${basePath}/`);
+}, removeBasePath = (url, base)=>{
+    let basePath = removeTailingSlash(base);
+    if ('' === basePath || !url.startsWith(basePath)) return url;
+    let nextChar = url[basePath.length];
+    return void 0 === nextChar ? '/' : '/' === nextChar ? url.slice(basePath.length) : '?' === nextChar || '#' === nextChar ? `/${url.slice(basePath.length)}` : url;
 }, getRoutes = (context)=>{
     let environmentWithHtml = context.environmentList.filter((item)=>Object.keys(item.htmlPaths).length > 0);
     if (0 === environmentWithHtml.length) return [];
@@ -5561,6 +6010,17 @@ let HtmlResourceHintsPlugin_defaultOptions = {
 function filterResourceHints(resourceHints, scripts) {
     return resourceHints.filter((resourceHint)=>!scripts.find((script)=>script.attributes.src === resourceHint.attributes.href));
 }
+function getResourceHintKey(resourceHint) {
+    return `${resourceHint.attributes.rel}:${resourceHint.attributes.href}`;
+}
+function mergeResourceHints(resourceHintGroups, scripts) {
+    let links = [], seen = new Set();
+    for (let { links: groupLinks, dedupe } of resourceHintGroups)for (let link of dedupe ? filterResourceHints(groupLinks, scripts) : groupLinks){
+        let key = getResourceHintKey(link);
+        seen.has(key) || (seen.add(key), links.push(link));
+    }
+    return links;
+}
 function generateLinks(options, type, compilation, data, HTMLCount, isDev) {
     let extractedChunks = extractChunks(compilation, options.type), sortedFilteredFiles = ((files, include, exclude)=>{
         let includeRegExp = [], excludeRegExp = [], includeFn = [], excludeFn = [];
@@ -5612,16 +6072,19 @@ class HtmlResourceHintsPlugin {
     isDev;
     getHTMLPlugin;
     constructor(options, type, HTMLCount, isDev, getHTMLPlugin){
-        this.options = {
-            ...HtmlResourceHintsPlugin_defaultOptions,
-            ...options
-        }, this.type = type, this.HTMLCount = HTMLCount, this.isDev = isDev, this.getHTMLPlugin = getHTMLPlugin;
+        this.options = helpers_castArray(options).map((option)=>({
+                ...HtmlResourceHintsPlugin_defaultOptions,
+                ...option
+            })), this.type = type, this.HTMLCount = HTMLCount, this.isDev = isDev, this.getHTMLPlugin = getHTMLPlugin;
     }
     apply(compiler) {
         compiler.hooks.compilation.tap(this.name, (compilation)=>{
             let pluginHooks = this.getHTMLPlugin().getCompilationHooks(compilation), pluginName = `HTML${upperFirst(this.type)}Plugin`;
-            pluginHooks.beforeAssetTagGeneration.tap(pluginName, (data)=>(this.resourceHints = generateLinks(this.options, this.type, compilation, data, this.HTMLCount, this.isDev), data)), pluginHooks.alterAssetTags.tap(pluginName, (data)=>(this.resourceHints && (data.assetTags.styles = [
-                    ...this.options.dedupe ? filterResourceHints(this.resourceHints, data.assetTags.scripts) : this.resourceHints,
+            pluginHooks.beforeAssetTagGeneration.tap(pluginName, (data)=>(this.resourceHints = this.options.map((option)=>({
+                        links: generateLinks(option, this.type, compilation, data, this.HTMLCount, this.isDev),
+                        dedupe: !1 !== option.dedupe
+                    })), data)), pluginHooks.alterAssetTags.tap(pluginName, (data)=>(this.resourceHints.length && (data.assetTags.styles = [
+                    ...mergeResourceHints(this.resourceHints, data.assetTags.scripts),
                     ...data.assetTags.styles
                 ]), data));
         });
@@ -5633,7 +6096,17 @@ let resourceHints_generateLinks = (options, rel)=>options.map((option)=>({
                 rel,
                 ...option
             }
+        })), appendExcludes = (options, excludes)=>{
+    if (!excludes.length) return options;
+    let optionsList = helpers_castArray(options).map((option)=>({
+            ...option,
+            exclude: option.exclude ? [
+                ...helpers_castArray(option.exclude),
+                ...excludes
+            ] : excludes
         }));
+    return Array.isArray(options) ? optionsList : optionsList[0];
+};
 function isTerminalTraceOutput(output) {
     return 'stdout' === output || 'stderr' === output;
 }
@@ -5937,7 +6410,7 @@ async function getFileFromUrl(url, outputFileSystem, context) {
         }), { environmentList, publicPathnames } = context, distPaths = environmentList.map((env)=>env.distPath), possibleFilenames = new Set();
     for (let [index, distPath] of distPaths.entries()){
         let prefix = publicPathnames[index];
-        prefix && '/' !== prefix && pathname.startsWith(prefix) && possibleFilenames.add(node_path.join(distPath, pathname.slice(prefix.length)));
+        prefix && '/' !== prefix && isUrlPathUnderBase(pathname, prefix) && possibleFilenames.add(node_path.join(distPath, pathname.slice(prefix.length)));
     }
     for (let distPath of distPaths)possibleFilenames.add(node_path.join(distPath, pathname));
     for (let filename of possibleFilenames){
@@ -5988,17 +6461,15 @@ function getEtag(stat) {
     let mtime = stat.mtime.getTime().toString(16), size = stat.size.toString(16);
     return `W/"${size}-${mtime}"`;
 }
-function createReadStreamOrReadFileSync(filename, outputFileSystem, start, end) {
-    return {
-        bufferOrStream: outputFileSystem.createReadStream(filename, {
-            start,
-            end
-        }),
-        byteLength: 0 === end ? 0 : end - start + 1
-    };
+function createReadStream(filename, outputFileSystem, start, end) {
+    return (0, outputFileSystem.createReadStream)(filename, {
+        start,
+        end,
+        highWaterMark: 524288
+    });
 }
-async function getContentType(str) {
-    let { lookup } = await import("./mrmime.js"), mime = lookup(str);
+function getContentType(str) {
+    let mime = mrmime_lookup(str);
     return !!mime && ((mime.startsWith('text/') || 'application/json' === mime || 'application/manifest+json' === mime) && (mime += '; charset=utf-8'), mime);
 }
 let BYTES_RANGE_REGEXP = /^ *bytes/i;
@@ -6010,6 +6481,84 @@ function parseHttpDate(date) {
     return 'number' == typeof timestamp ? timestamp : NaN;
 }
 let CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
+function getRequestHeader(headers, name) {
+    let value = headers[name];
+    return Array.isArray(value) ? value.join(',') : value;
+}
+function isConditionalGET(headers) {
+    return !!(headers['if-match'] || headers['if-unmodified-since'] || headers['if-none-match'] || headers['if-modified-since']);
+}
+function isPreconditionFailure(headers, res) {
+    let ifMatch = getRequestHeader(headers, 'if-match');
+    if (ifMatch) {
+        let etag = res.getHeader('ETag');
+        return !etag || '*' !== ifMatch && parseTokenList(ifMatch).every((match)=>match !== etag && match !== `W/${etag}` && `W/${match}` !== etag);
+    }
+    let ifUnmodifiedSince = getRequestHeader(headers, 'if-unmodified-since');
+    if (ifUnmodifiedSince) {
+        let unmodifiedSince = parseHttpDate(ifUnmodifiedSince);
+        if (!Number.isNaN(unmodifiedSince)) {
+            let lastModified = parseHttpDate(String(res.getHeader('Last-Modified')));
+            return Number.isNaN(lastModified) || lastModified > unmodifiedSince;
+        }
+    }
+    return !1;
+}
+function isCachable(statusCode) {
+    return statusCode >= 200 && statusCode < 300 || 304 === statusCode;
+}
+function isFresh(headers, resHeaders) {
+    let cacheControl = getRequestHeader(headers, 'cache-control');
+    if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) return !1;
+    let noneMatch = getRequestHeader(headers, 'if-none-match'), modifiedSince = getRequestHeader(headers, 'if-modified-since');
+    if (!noneMatch && !modifiedSince) return !1;
+    if (noneMatch && '*' !== noneMatch) {
+        if (!resHeaders.etag) return !1;
+        let matches = parseTokenList(noneMatch), etagStale = !0;
+        for(let i = 0; i < matches.length; i++){
+            let match = matches[i];
+            if (match === resHeaders.etag || match === `W/${resHeaders.etag}` || `W/${match}` === resHeaders.etag) {
+                etagStale = !1;
+                break;
+            }
+        }
+        if (etagStale) return !1;
+    }
+    if (noneMatch) return !0;
+    if (modifiedSince) {
+        let lastModified = resHeaders['last-modified'];
+        if (!lastModified || !(parseHttpDate(String(lastModified)) <= parseHttpDate(modifiedSince))) return !1;
+    }
+    return !0;
+}
+function isRangeFresh(headers, res) {
+    let ifRange = getRequestHeader(headers, 'if-range');
+    if (!ifRange) return !0;
+    if (-1 !== ifRange.indexOf('"')) {
+        let etag = res.getHeader('ETag');
+        return !etag || !(ifRange.startsWith('W/') || etag.startsWith('W/')) && ifRange === etag;
+    }
+    let lastModified = res.getHeader('Last-Modified');
+    return !lastModified || parseHttpDate(lastModified) <= parseHttpDate(ifRange);
+}
+function getRangeHeader(headers) {
+    let range = getRequestHeader(headers, 'range');
+    if (range && BYTES_RANGE_REGEXP.test(range)) return range;
+}
+function getOffsetAndLenFromRange(range) {
+    let { start, end } = range;
+    return [
+        start,
+        end - start + 1
+    ];
+}
+function calcStartAndEnd(start, len) {
+    let end = Math.max(start, start + len - 1);
+    return [
+        start,
+        end
+    ];
+}
 function destroyStream(stream, suppress) {
     'function' == typeof stream.destroy && stream.destroy(), 'function' == typeof stream.close && stream.on('open', function onOpenClose(fd) {
         'number' == typeof fd && this.close();
@@ -6020,10 +6569,7 @@ let parseRangeHeaders = async (value)=>{
     return rangeParser(Number(len), rangeHeader, {
         combine: !0
     });
-}, acceptedMethods = [
-    'GET',
-    'HEAD'
-];
+};
 function sendError(res, code) {
     let content = {
         400: 'Bad Request',
@@ -6048,7 +6594,7 @@ function sendError(res, code) {
     let byteLength = Buffer.byteLength(document);
     res.setHeader('Content-Length', byteLength), res.end(document);
 }
-function createMiddleware(context, ready, outputFileSystem) {
+function createAssetsMiddleware(context, ready, outputFileSystem) {
     let { logger } = context;
     return async function assetsMiddleware(req, res, next) {
         async function goNext() {
@@ -6058,83 +6604,8 @@ function createMiddleware(context, ready, outputFileSystem) {
                 });
             });
         }
-        if (req.method && !acceptedMethods.includes(req.method)) return void await goNext();
-        function isConditionalGET() {
-            return req.headers['if-match'] || req.headers['if-unmodified-since'] || req.headers['if-none-match'] || req.headers['if-modified-since'];
-        }
-        function isPreconditionFailure() {
-            let ifMatch = req.headers['if-match'];
-            if (ifMatch) {
-                let etag = res.getHeader('ETag');
-                return !etag || '*' !== ifMatch && parseTokenList(ifMatch).every((match)=>match !== etag && match !== `W/${etag}` && `W/${match}` !== etag);
-            }
-            let ifUnmodifiedSince = req.headers['if-unmodified-since'];
-            if (ifUnmodifiedSince) {
-                let unmodifiedSince = parseHttpDate(ifUnmodifiedSince);
-                if (!Number.isNaN(unmodifiedSince)) {
-                    let lastModified = parseHttpDate(String(res.getHeader('Last-Modified')));
-                    return Number.isNaN(lastModified) || lastModified > unmodifiedSince;
-                }
-            }
-            return !1;
-        }
-        function isCachable() {
-            return res.statusCode >= 200 && res.statusCode < 300 || 304 === res.statusCode;
-        }
-        function isFresh(resHeaders) {
-            let cacheControl = req.headers['cache-control'];
-            if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) return !1;
-            let noneMatch = req.headers['if-none-match'], modifiedSince = req.headers['if-modified-since'];
-            if (!noneMatch && !modifiedSince) return !1;
-            if (noneMatch && '*' !== noneMatch) {
-                if (!resHeaders.etag) return !1;
-                let matches = parseTokenList(noneMatch), etagStale = !0;
-                for(let i = 0; i < matches.length; i++){
-                    let match = matches[i];
-                    if (match === resHeaders.etag || match === `W/${resHeaders.etag}` || `W/${match}` === resHeaders.etag) {
-                        etagStale = !1;
-                        break;
-                    }
-                }
-                if (etagStale) return !1;
-            }
-            if (noneMatch) return !0;
-            if (modifiedSince) {
-                let lastModified = resHeaders['last-modified'];
-                if (!lastModified || !(parseHttpDate(String(lastModified)) <= parseHttpDate(modifiedSince))) return !1;
-            }
-            return !0;
-        }
-        function isRangeFresh() {
-            let ifRange = req.headers['if-range'];
-            if (!ifRange) return !0;
-            if (-1 !== ifRange.indexOf('"')) {
-                let etag = res.getHeader('ETag');
-                return !etag || !!(etag && -1 !== ifRange.indexOf(etag));
-            }
-            let lastModified = res.getHeader('Last-Modified');
-            return !lastModified || parseHttpDate(lastModified) <= parseHttpDate(ifRange);
-        }
-        function getRangeHeader() {
-            let { range } = req.headers;
-            if (range && BYTES_RANGE_REGEXP.test(range)) return range;
-        }
-        function getOffsetAndLenFromRange(range) {
-            let { start, end } = range;
-            return [
-                start,
-                end - start + 1
-            ];
-        }
-        function calcStartAndEnd(start, len) {
-            let end = Math.max(start, start + len - 1);
-            return [
-                start,
-                end
-            ];
-        }
-        ready(async function processRequest() {
-            let bufferOrStream, byteLength;
+        req.method && 'GET' !== req.method && 'HEAD' !== req.method ? await goNext() : ready(async function processRequest() {
+            let readStream;
             if (!req.url) return void await goNext();
             let resolved = await getFileFromUrl(req.url, outputFileSystem, context);
             if (!resolved) return void await goNext();
@@ -6144,18 +6615,18 @@ function createMiddleware(context, ready, outputFileSystem) {
             }
             let { fsStats, filename } = resolved, { size } = fsStats, len = size, offset = 0;
             if (!res.getHeader('Content-Type')) {
-                let contentType = await getContentType(filename);
+                let contentType = getContentType(filename);
                 contentType && res.setHeader('Content-Type', contentType);
             }
             res.getHeader('Accept-Ranges') || res.setHeader('Accept-Ranges', 'bytes');
-            let rangeHeader = getRangeHeader();
+            let rangeHeader = getRangeHeader(req.headers);
             if (!res.getHeader('ETag') && fsStats) {
                 let hash = getEtag(fsStats);
                 res.setHeader('ETag', hash);
             }
-            if (isConditionalGET()) {
-                if (isPreconditionFailure()) return void sendError(res, 412);
-                if (404 === res.statusCode && (res.statusCode = 200), isCachable() && isFresh({
+            if (isConditionalGET(req.headers)) {
+                if (isPreconditionFailure(req.headers, res)) return void sendError(res, 412);
+                if (404 === res.statusCode && (res.statusCode = 200), isCachable(res.statusCode) && isFresh(req.headers, {
                     etag: res.getHeader('ETag'),
                     'last-modified': res.getHeader('Last-Modified')
                 })) {
@@ -6165,7 +6636,7 @@ function createMiddleware(context, ready, outputFileSystem) {
             }
             if (rangeHeader) {
                 let parsedRanges = await parseRangeHeaders(`${size}|${rangeHeader}`);
-                if (isRangeFresh() || (parsedRanges = []), -1 === parsedRanges) {
+                if (isRangeFresh(req.headers, res) || (parsedRanges = []), -1 === parsedRanges) {
                     logger.error("[rsbuild:middleware] Unsatisfiable range for 'Range' header."), res.setHeader('Content-Range', getValueContentRangeHeader('bytes', size)), sendError(res, 416);
                     return;
                 }
@@ -6173,20 +6644,19 @@ function createMiddleware(context, ready, outputFileSystem) {
             }
             let [start, end] = calcStartAndEnd(offset, len);
             try {
-                ({ bufferOrStream, byteLength } = createReadStreamOrReadFileSync(filename, outputFileSystem, start, end));
+                readStream = createReadStream(filename, outputFileSystem, start, end);
             } catch  {
                 await goNext();
                 return;
             }
-            if (res.setHeader('Content-Length', byteLength), 'HEAD' === req.method) {
+            if (res.setHeader('Content-Length', len), 'HEAD' === req.method) {
                 404 === res.statusCode && (res.statusCode = 200), res.end();
                 return;
             }
-            if ('function' != typeof bufferOrStream.pipe) return void res.end(bufferOrStream);
             let cleanup = ()=>{
-                destroyStream(bufferOrStream, !0);
+                destroyStream(readStream, !0);
             };
-            bufferOrStream.on('error', (error)=>{
+            readStream.on('error', (error)=>{
                 switch(cleanup(), error.code){
                     case 'ENAMETOOLONG':
                     case 'ENOENT':
@@ -6196,13 +6666,13 @@ function createMiddleware(context, ready, outputFileSystem) {
                     default:
                         sendError(res, 500);
                 }
-            }), bufferOrStream.pipe(res), on_finished_default()(res, cleanup);
+            }), readStream.pipe(res), on_finished_default()(res, cleanup);
         });
     };
 }
 async function setupOutputFileSystem(writeToDisk, compilers) {
     if (!0 !== writeToDisk) {
-        let { createFsFromVolume, Volume } = await import("./memfs.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/memfs@4.57.3/node_modules/memfs/lib/index.js", 23)), outputFileSystem = createFsFromVolume(new Volume());
+        let { createFsFromVolume, Volume } = await import("./memfs.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/memfs@4.57.6/node_modules/memfs/lib/index.js", 23)), outputFileSystem = createFsFromVolume(new Volume());
         for (let compiler of compilers)compiler.outputFileSystem = outputFileSystem;
     }
     let compiler = compilers.find((compiler)=>!!compiler.outputFileSystem);
@@ -6246,12 +6716,13 @@ function applyHMREntry({ config, compiler, token, resolvedHost, resolvedPort })
         let { target } = compiler.options;
         return !!target && (Array.isArray(target) ? target.includes('web') : 'web' === target);
     })(compiler) || !config.dev.hmr && !config.dev.liveReload) return;
-    let { enabled: liveReloadEnabled } = normalizeLiveReload(config.dev.liveReload), clientConfig = {
+    let { enabled: liveReloadEnabled } = normalizeLiveReload(config.dev.liveReload), { webSocketUrlResolver, ...clientConfig } = {
         ...config.dev.client
     };
     '<port>' === clientConfig.port && (clientConfig.port = resolvedPort);
-    let hmrEntry = `import { init } from '${toPosixPath(join(CLIENT_PATH, 'hmr.js'))}';
+    let resolverPath = webSocketUrlResolver && !external_node_path_isAbsolute(webSocketUrlResolver) ? join(compiler.context, webSocketUrlResolver) : webSocketUrlResolver, hmrEntry = `import { init } from '${toPosixPath(join(CLIENT_PATH, 'hmr.js'))}';
 ${!0 === (overlay1 = overlay = config.dev.client.overlay) || 'object' == typeof overlay1 && !1 !== overlay1.errors || isRuntimeOverlayEnabled(overlay) ? `import '${toPosixPath(join(CLIENT_PATH, 'overlay.js'))}';` : ''}
+${resolverPath ? `import urlResolver from ${JSON.stringify(toPosixPath(resolverPath))};` : ''}
 init(
   '${token}',
   ${JSON.stringify(clientConfig)},
@@ -6260,7 +6731,7 @@ init(
   ${JSON.stringify(config.server.base)},
   ${liveReloadEnabled},
   ${!!config.dev.browserLogs},
-  ${JSON.stringify(config.dev.client.logLevel)}
+  ${JSON.stringify(config.dev.client.logLevel)}${resolverPath ? ',\n  urlResolver' : ''}
 )
 `;
     new core_rspack.EntryPlugin(compiler.context, createVirtualModule(hmrEntry), {
@@ -6338,7 +6809,7 @@ let assets_middleware_assetsMiddleware = async ({ config, compiler, context, soc
         return name && environments[name] && (writeToDisk = environments[name].config.dev.writeToDisk ?? writeToDisk), 'function' == typeof writeToDisk ? writeToDisk(filePath) : writeToDisk;
     });
     writeToDisk && setupWriteToDisk(compilers, writeToDisk, logger);
-    let instance = createMiddleware(context, (callback)=>{
+    let instance = createAssetsMiddleware(context, (callback)=>{
         'done' === context.buildState.status ? callback() : callbacks.push(callback);
     }, await setupOutputFileSystem(writeToDisk, compilers));
     return instance.watch = ()=>{
@@ -6990,21 +7461,38 @@ let faviconFallbackMiddleware = (req, res, next)=>{
     next();
 }, middlewares_isFileExists = async (filePath, outputFileSystem)=>new Promise((resolve)=>{
         outputFileSystem.stat(filePath, (_error, stats)=>{
-            resolve(stats?.isFile());
+            resolve(!!stats?.isFile());
         });
-    }), maybeHTMLRequest = (req)=>{
+    }), isFileExistsInDistPaths = async (distPaths, filename, outputFileSystem)=>{
+    for (let distPath of distPaths)if (await middlewares_isFileExists(node_path.join(distPath, filename), outputFileSystem)) return !0;
+    return !1;
+}, maybeHTMLRequest = (req)=>{
     if (!req.url || !req.headers || 'GET' !== req.method && 'HEAD' !== req.method) return !1;
     let { accept } = req.headers;
     return 'string' == typeof accept && (accept.includes('text/html') || accept.includes('*/*'));
-}, postfixRE = /[?#].*$/, getBaseUrlMiddleware = ({ base })=>function baseUrlMiddleware(req, res, next) {
-        var pathname;
-        let basePath, url = req.url, pathname1 = url.replace(postfixRE, '');
-        if (pathname = pathname1, '' === (basePath = base.replace(/\/+$/, '')) || pathname === basePath || pathname.startsWith(`${basePath}/`)) {
+}, postfixRE = /[?#].*$/, getHtmlCompletionMiddleware = ({ distPaths, assetsMiddleware, outputFileSystem })=>async function htmlCompletionMiddleware(req, res, next) {
+        if (!maybeHTMLRequest(req)) return void next();
+        let pathname = req.url.replace(postfixRE, ''), rewrite = (newUrl)=>{
+            req.url = newUrl, assetsMiddleware(req, res, (...args)=>{
+                next(...args);
+            });
+        };
+        if (pathname.endsWith('/')) {
+            let newUrl = `${pathname}index.html`;
+            if (await isFileExistsInDistPaths(distPaths, newUrl, outputFileSystem)) return void rewrite(newUrl);
+        } else if (!node_path.extname(pathname)) {
+            let newUrl = `${pathname}.html`;
+            if (await isFileExistsInDistPaths(distPaths, newUrl, outputFileSystem)) return void rewrite(newUrl);
+        }
+        next();
+    }, getBaseUrlMiddleware = ({ base })=>function baseUrlMiddleware(req, res, next) {
+        let url = req.url, pathname = url.replace(postfixRE, '');
+        if (isUrlPathUnderBase(pathname, base)) {
             req.url = removeBasePath(url, base), next();
             return;
         }
         let redirectPath = addTrailingSlash(url) !== base ? joinUrlPath(base, url) : base;
-        if ('/' === pathname1 || '/index.html' === pathname1) {
+        if ('/' === pathname || '/index.html' === pathname) {
             res.writeHead(302, {
                 Location: redirectPath
             }), res.end();
@@ -7019,6 +7507,16 @@ let faviconFallbackMiddleware = (req, res, next)=>{
         res.writeHead(404, {
             'Content-Type': 'text/plain'
         }), res.end(`The server is configured with a base URL of ${base} - did you mean to visit ${redirectPath} instead?`);
+    }, getHtmlFallbackMiddleware = ({ distPaths, assetsMiddleware, outputFileSystem, logger })=>async function htmlFallbackMiddleware(req, res, next) {
+        if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url) return void next();
+        if (await isFileExistsInDistPaths(distPaths, 'index.html', outputFileSystem)) {
+            let newUrl = '/index.html';
+            isVerbose(logger) && logger.debug(`    ${req.method} ${req.url} ${color.yellow('fallback to')} ${newUrl}`), req.url = newUrl, assetsMiddleware(req, res, (...args)=>{
+                next(...args);
+            });
+            return;
+        }
+        next();
     };
 function formatProxyOptions(proxyOptions, logger) {
     let logPrefix = color.dim('[http-proxy-middleware]: '), defaultOptions = {
@@ -7063,7 +7561,7 @@ async function createProxyMiddleware(proxyOptions, logger) {
     };
 }
 let applyDefaultMiddlewares = async ({ config, buildManager, context, devServer, middlewares, postCallbacks })=>{
-    let upgradeEvents = [], { server } = config, { logger } = context;
+    let launchEditorHandlerPromise, upgradeEvents = [], { server } = config, { logger } = context;
     if (server.cors) {
         let { default: corsMiddleware } = await import("./cors.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/cors@2.8.6/node_modules/cors/lib/index.js", 23));
         middlewares.use(corsMiddleware('boolean' == typeof server.cors ? {} : server.cors));
@@ -7081,11 +7579,18 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServer,
         let { compiler } = buildManager;
         (compiler_isMultiCompiler(compiler) ? compiler.compilers.some((childCompiler)=>childCompiler.options.lazyCompilation) : compiler.options.lazyCompilation) && middlewares.use(core_rspack.lazyCompilationMiddleware(compiler));
     }
-    server.base && '/' !== server.base && middlewares.use(getBaseUrlMiddleware({
+    if (server.base && '/' !== server.base && middlewares.use(getBaseUrlMiddleware({
         base: server.base
-    }));
-    let { default: launchEditorMiddleware } = await import("./launch-editor-middleware.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/launch-editor-middleware@2.14.0/node_modules/launch-editor-middleware/index.js", 23));
-    if (middlewares.use('/__open-in-editor', launchEditorMiddleware()), middlewares.use((({ environments, logger })=>async function viewingServedFilesMiddleware(req, res, next) {
+    })), middlewares.use('/__open-in-editor', async (req, res, next)=>{
+        try {
+            (await (launchEditorHandlerPromise ??= (async ()=>{
+                let { default: launchEditorMiddleware } = await import("./launch-editor-middleware.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/launch-editor-middleware@2.14.1/node_modules/launch-editor-middleware/index.js", 23));
+                return launchEditorMiddleware();
+            })()))(req, res, next);
+        } catch (err) {
+            next(err);
+        }
+    }), middlewares.use((({ environments, logger })=>async function viewingServedFilesMiddleware(req, res, next) {
             if ('/rsbuild-dev-server' !== req.url.replace(postfixRE, '')) return void next();
             res.writeHead(200, {
                 'Content-Type': 'text/html; charset=utf-8'
@@ -7148,24 +7653,12 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServer,
         logger
     })), buildManager && (middlewares.use(buildManager.assetsMiddleware), upgradeEvents.push(buildManager.socketServer.upgrade), middlewares.use(function hotUpdateJsonFallbackMiddleware(req, res, next) {
         req.url?.endsWith('.hot-update.json') && 'OPTIONS' !== req.method ? notFoundMiddleware(req, res, next) : next();
-    })), buildManager && middlewares.use((({ distPath, buildManager })=>async function htmlCompletionMiddleware(req, res, next) {
-            if (!maybeHTMLRequest(req)) return void next();
-            let pathname = req.url.replace(postfixRE, ''), rewrite = (newUrl)=>{
-                req.url = newUrl, buildManager.assetsMiddleware(req, res, (...args)=>{
-                    next(...args);
-                });
-            };
-            if (pathname.endsWith('/')) {
-                let newUrl = `${pathname}index.html`, filePath = node_path.join(distPath, newUrl);
-                if (await middlewares_isFileExists(filePath, buildManager.outputFileSystem)) return void rewrite(newUrl);
-            } else if (!node_path.extname(pathname)) {
-                let newUrl = `${pathname}.html`, filePath = node_path.join(distPath, newUrl);
-                if (await middlewares_isFileExists(filePath, buildManager.outputFileSystem)) return void rewrite(newUrl);
-            }
-            next();
-        })({
-        buildManager,
-        distPath: context.distPath
+    })), buildManager && middlewares.use(getHtmlCompletionMiddleware({
+        assetsMiddleware: buildManager.assetsMiddleware,
+        distPaths: [
+            context.distPath
+        ],
+        outputFileSystem: buildManager.outputFileSystem
     })), server.publicDir.length) {
         let { default: sirv } = await import("./sirv.js");
         for (let { name } of server.publicDir){
@@ -7179,21 +7672,13 @@ let applyDefaultMiddlewares = async ({ config, buildManager, context, devServer,
         }
     }
     for (let callback of postCallbacks)await callback();
-    return server.historyApiFallback && (middlewares.use(historyApiFallback_historyApiFallbackMiddleware(logger, !0 === server.historyApiFallback ? {} : server.historyApiFallback)), buildManager?.assetsMiddleware && middlewares.use(buildManager.assetsMiddleware)), buildManager && server.htmlFallback && middlewares.use((({ distPath, buildManager, logger })=>async function htmlFallbackMiddleware(req, res, next) {
-            if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url) return void next();
-            let filePath = node_path.join(distPath, 'index.html');
-            if (await middlewares_isFileExists(filePath, buildManager.outputFileSystem)) {
-                let newUrl = '/index.html';
-                isVerbose(logger) && logger.debug(`    ${req.method} ${req.url} ${color.yellow('fallback to')} ${newUrl}`), req.url = newUrl, buildManager.assetsMiddleware(req, res, (...args)=>{
-                    next(...args);
-                });
-                return;
-            }
-            next();
-        })({
-        buildManager,
-        distPath: context.distPath,
-        logger
+    return server.historyApiFallback && (middlewares.use(historyApiFallback_historyApiFallbackMiddleware(logger, !0 === server.historyApiFallback ? {} : server.historyApiFallback)), buildManager?.assetsMiddleware && middlewares.use(buildManager.assetsMiddleware)), buildManager && server.htmlFallback && middlewares.use(getHtmlFallbackMiddleware({
+        assetsMiddleware: buildManager.assetsMiddleware,
+        distPaths: [
+            context.distPath
+        ],
+        logger,
+        outputFileSystem: buildManager.outputFileSystem
     })), middlewares.use(faviconFallbackMiddleware), {
         onUpgrade: (...args)=>{
             for (let cb of upgradeEvents)cb(...args);
@@ -7438,11 +7923,12 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
         all: !1,
         chunks: !0,
         entrypoints: !0,
+        ids: !0,
         outputPath: !0
     });
     if (!entrypoints?.[entryName]) throw Error(`${color.dim('[rsbuild:loadBundle]')} Can't find entry: ${color.yellow(entryName)}`);
-    let { chunks: entryChunks = [] } = entrypoints[entryName], files = entryChunks.reduce((prev, entryChunkName)=>{
-        let chunk = chunks?.find((chunk)=>chunk.entry && chunk.names?.includes(String(entryChunkName)));
+    let { chunks: entryChunks = [] } = entrypoints[entryName], files = entryChunks.reduce((prev, entryChunkId)=>{
+        let chunk = chunks?.find((chunk)=>chunk.entry && chunk.id === entryChunkId);
         return chunk?.files ? prev.concat(chunk.files.filter((file)=>!file.endsWith('.css'))) : prev;
     }, []);
     if (0 === files.length) throw Error(`${color.dim('[rsbuild:loadBundle]')} Failed to get bundle by entryName: ${color.yellow(entryName)}`);
@@ -7501,7 +7987,7 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
     }
     let { createServer } = await import("node:http");
     return createServer(middlewares);
-};
+}, getPublicPathname = (publicPath)=>'auto' === publicPath || '' === publicPath ? '' : getPathnameFromUrl(publicPath.endsWith('/') ? publicPath : `${publicPath}/`), getPublicPathnames = (publicPaths, base)=>publicPaths.map(getPublicPathname).map((prefix)=>base && '/' !== base ? removeBasePath(prefix, base) : prefix);
 async function applyServerSetup(setup, context) {
     let postCallbacks = [];
     for (let handler of helpers_castArray(setup || [])){
@@ -7590,10 +8076,9 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
     let startCompile = async ()=>{
         let compiler = await createCompiler();
         if (!compiler) throw Error(`${color.dim('[rsbuild:server]')} Failed to get compiler instance.`);
-        let publicPaths = compiler_isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
+        context.publicPathnames = getPublicPathnames(compiler_isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
             getPublicPathFromCompiler(compiler)
-        ], { base } = config.server;
-        context.publicPathnames = publicPaths.map(getPathnameFromUrl).map((prefix)=>base && '/' !== base ? removeBasePath(prefix, base) : prefix), compiler?.hooks.watchRun.tap('rsbuild:watchRun', ()=>{
+        ], config.server.base), compiler?.hooks.watchRun.tap('rsbuild:watchRun', ()=>{
             lastStats && (waitLastCompileDoneResolve && (waitLastCompileDoneResolve(), waitLastCompileDoneResolve = null), waitLastCompileDone = new Promise((resolve)=>{
                 waitLastCompileDoneResolve = resolve;
             }));
@@ -7748,7 +8233,9 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
     }), state.buildManager?.watch(), logger.debug('create dev server done'), devServer;
 }
 async function startPreviewServer(context, config, { getPortSilently } = {}) {
-    let { logger } = context, { connect } = await import("./connect-next.js"), middlewares = connect(), { port, portTip } = await resolvePort(config), serverConfig = config.server, { host, headers, proxy, historyApiFallback, compress, base, cors } = serverConfig, protocol = serverConfig.https ? 'https' : 'http', routes = getRoutes(context), urls = await getAddressUrls({
+    let environmentList, { logger } = context, { connect } = await import("./connect-next.js"), middlewares = connect(), { port, portTip } = await resolvePort(config), serverConfig = config.server, { host, headers, proxy, historyApiFallback, compress, base, cors } = serverConfig, assetPrefixes = context.environmentList.map((environment)=>environment.config.output.assetPrefix);
+    context.publicPathnames = getPublicPathnames(assetPrefixes, base);
+    let protocol = serverConfig.https ? 'https' : 'http', routes = getRoutes(context), urls = await getAddressUrls({
         protocol,
         port,
         host
@@ -7789,21 +8276,14 @@ async function startPreviewServer(context, config, { getPortSilently } = {}) {
         server: previewServer,
         environments: context.environments
     });
-    let applyStaticAssetMiddleware = async ()=>{
-        let { default: sirv } = await import("./sirv.js"), assetsMiddleware = sirv(context.distPath, {
-            etag: !0,
-            dev: !0,
-            ignores: [
-                'favicon.ico'
-            ],
-            single: 'index' === serverConfig.htmlFallback
-        }), assetPrefixes = context.environmentList.map((e)=>getPathnameFromUrl(e.config.output.assetPrefix));
-        middlewares.use(function staticAssetMiddleware(req, res, next) {
-            let { url } = req, assetPrefix = url && assetPrefixes.find((prefix)=>url.startsWith(prefix));
-            assetPrefix && url?.startsWith(assetPrefix) ? (req.url = url.slice(assetPrefix.length), assetsMiddleware(req, res, (...args)=>{
-                req.url = url, next(...args);
-            })) : assetsMiddleware(req, res, next);
-        });
+    let assetContext = (environmentList = context.environmentList.filter((environment)=>isWebTarget(environment.config.output.target)), {
+        ...context,
+        environmentList,
+        publicPathnames: environmentList.map((environment)=>context.publicPathnames[environment.index])
+    }), assetsMiddleware = createAssetsMiddleware(assetContext, (callback)=>callback(), node_fs), htmlMiddlewareOptions = {
+        assetsMiddleware,
+        distPaths: assetContext.environmentList.map((environment)=>environment.distPath),
+        outputFileSystem: node_fs
     };
     if (isVerbose(logger) && middlewares.use(getRequestLoggerMiddleware(logger)), cors) {
         let { default: corsMiddleware } = await import("./cors.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/cors@2.8.6/node_modules/cors/lib/index.js", 23));
@@ -7826,8 +8306,11 @@ async function startPreviewServer(context, config, { getPortSilently } = {}) {
     }
     for (let callback of (base && '/' !== base && middlewares.use(getBaseUrlMiddleware({
         base
-    })), await applyStaticAssetMiddleware(), historyApiFallback && (middlewares.use(historyApiFallback_historyApiFallbackMiddleware(logger, !0 === historyApiFallback ? {} : historyApiFallback)), await applyStaticAssetMiddleware()), postSetupCallbacks))await callback();
-    return middlewares.use(faviconFallbackMiddleware), middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), new Promise((resolve)=>{
+    })), middlewares.use(assetsMiddleware), middlewares.use(getHtmlCompletionMiddleware(htmlMiddlewareOptions)), historyApiFallback && (middlewares.use(historyApiFallback_historyApiFallbackMiddleware(logger, !0 === historyApiFallback ? {} : historyApiFallback)), middlewares.use(assetsMiddleware)), postSetupCallbacks))await callback();
+    return serverConfig.htmlFallback && middlewares.use(getHtmlFallbackMiddleware({
+        ...htmlMiddlewareOptions,
+        logger
+    })), middlewares.use(faviconFallbackMiddleware), middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), new Promise((resolve)=>{
         httpServer.listen({
             host,
             port
@@ -7866,7 +8349,10 @@ function applyDefaultPlugins(pluginManager, context) {
                         level: 'error'
                     }), chain.watchOptions({
                         aggregateTimeout: 0
-                    }), chain.performance.hints(!1), chain.module.parser.merge({
+                    }), chain.performance.hints(!1), chain.experiments({
+                        ...chain.get('experiments'),
+                        pureFunctions: !0
+                    }), chain.module.parser.merge({
                         javascript: {
                             typeReexportsPresence: 'tolerant'
                         }
@@ -8303,7 +8789,7 @@ function applyDefaultPlugins(pluginManager, context) {
                 }, async ({ compilation, environment, sources })=>{
                     let { config } = environment, { appIcon } = config.html;
                     if (!appIcon) return;
-                    let { lookup } = await import("./mrmime.js"), distDir = config.output.distPath.image, manifestFile = appIcon.filename ?? 'manifest.webmanifest', publicPath = getPublicPathFromCompiler(compilation), icons = appIcon.icons.map((icon)=>((icon, distDir, publicPath, lookup)=>{
+                    let distDir = config.output.distPath.image, manifestFile = appIcon.filename ?? 'manifest.webmanifest', publicPath = getPublicPathFromCompiler(compilation), icons = appIcon.icons.map((icon)=>((icon, distDir, publicPath, lookup)=>{
                             let { src, size } = icon, cacheKey = `${distDir}|${publicPath}|${src}`, cached = iconFormatMap.get(cacheKey);
                             if (cached) return cached;
                             let sizes = `${size}x${size}`;
@@ -8327,7 +8813,7 @@ function applyDefaultPlugins(pluginManager, context) {
                                 mimeType: lookup(absolutePath)
                             };
                             return iconFormatMap.set(cacheKey, formatted), formatted;
-                        })(icon, distDir, publicPath, lookup)), tags = [];
+                        })(icon, distDir, publicPath, mrmime_lookup)), tags = [];
                     for (let icon of icons){
                         if ('web-app-manifest' === icon.target && !appIcon.name) {
                             addCompilationError(compilation, `${color.dim('[rsbuild:appIcon]')} ${color.yellow('"appIcon.name"')} is required when ${color.yellow('"target"')} is ${color.yellow('"web-app-manifest"')}.`);
@@ -8858,11 +9344,8 @@ try {
                         ].filter((item)=>isRegExp(item));
                     })(config);
                     if (prefetch) {
-                        let options = !0 === prefetch ? {} : prefetch;
-                        excludes.length && (options.exclude = options.exclude ? [
-                            ...helpers_castArray(options.exclude),
-                            ...excludes
-                        ] : excludes), chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(HtmlResourceHintsPlugin, [
+                        let options = appendExcludes(!0 === prefetch ? {} : prefetch, excludes);
+                        chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(HtmlResourceHintsPlugin, [
                             options,
                             'prefetch',
                             HTMLCount,
@@ -8871,11 +9354,8 @@ try {
                         ]);
                     }
                     if (preload) {
-                        let options = !0 === preload ? {} : preload;
-                        excludes.length && (options.exclude = options.exclude ? [
-                            ...helpers_castArray(options.exclude),
-                            ...excludes
-                        ] : excludes), chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(HtmlResourceHintsPlugin, [
+                        let options = appendExcludes(!0 === preload ? {} : preload, excludes);
+                        chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(HtmlResourceHintsPlugin, [
                             options,
                             'preload',
                             HTMLCount,
@@ -8947,7 +9427,7 @@ try {
                 api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, isDev })=>{
                     let { output: { manifest }, dev: { writeToDisk } } = environment.config;
                     if (!1 === manifest) return;
-                    let manifestOptions = normalizeManifestObjectConfig(manifest), { RspackManifestPlugin } = await import("./manifest-plugin.js").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.6/node_modules/rspack-manifest-plugin/dist/index.js")), { htmlPaths } = environment, filter = manifestOptions.filter ?? ((file)=>!file.name.endsWith('.LICENSE.txt'));
+                    let manifestOptions = normalizeManifestObjectConfig(manifest), { RspackManifestPlugin } = await import("./manifest-plugin.js").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.2_@rspack+core@2.0.8/node_modules/rspack-manifest-plugin/dist/index.js")), { htmlPaths } = environment, filter = manifestOptions.filter ?? ((file)=>!file.name.endsWith('.LICENSE.txt'));
                     manifestFilenames.set(environment.name, manifestOptions.filename);
                     let pluginOptions = {
                         fileName: manifestOptions.filename,
@@ -9461,7 +9941,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.0.10"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.0.12"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -9532,7 +10012,7 @@ function initNodeEnv(command) {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.10\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.12\n`);
 }
 function setupLogLevel() {
     if (cli_argv.length <= 3) return;
@@ -9554,5 +10034,5 @@ function runCLI() {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.0.10";
-export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, runCLI, src_logger as logger, src_version as version };
+let src_version = "2.0.12";
+export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, mrmime_lookup, runCLI, src_logger as logger, src_version as version };