@rsbuild/core 2.2.8 → 2.2.10

package/dist/trace-mapping.js

@@ -1,23 +1,46 @@
+import { definePropertyGetters, makeNamespaceObject } from "./rslib-runtime.js";
+var trace_mapping_namespaceObject = {};
+makeNamespaceObject(trace_mapping_namespaceObject), definePropertyGetters(trace_mapping_namespaceObject, {
+    AnyMap: ()=>FlattenMap,
+    FlattenMap: ()=>FlattenMap,
+    GREATEST_LOWER_BOUND: ()=>GREATEST_LOWER_BOUND,
+    LEAST_UPPER_BOUND: ()=>LEAST_UPPER_BOUND,
+    TraceMap: ()=>TraceMap,
+    allGeneratedPositionsFor: ()=>allGeneratedPositionsFor,
+    decodedMap: ()=>decodedMap,
+    decodedMappings: ()=>decodedMappings,
+    eachMapping: ()=>eachMapping,
+    encodedMap: ()=>encodedMap,
+    encodedMappings: ()=>encodedMappings,
+    generatedPositionFor: ()=>generatedPositionFor,
+    isIgnored: ()=>isIgnored,
+    originalPositionFor: ()=>originalPositionFor,
+    presortedDecodedMap: ()=>presortedDecodedMap,
+    sourceContentFor: ()=>sourceContentFor,
+    traceSegment: ()=>traceSegment
+});
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
 for(let i = 0; i < chars.length; i++){
     let c = chars.charCodeAt(i);
     intToChar[i] = c, charToInt[c] = i;
 }
-function decodeInteger(reader, relative) {
+function decodeInteger(reader) {
     let value = 0, shift = 0, integer = 0;
     do value |= (31 & (integer = charToInt[reader.next()])) << shift, shift += 5;
     while (32 & integer);
-    let shouldNegate = 1 & value;
-    return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
+    return value;
 }
-function encodeInteger(builder, num, relative) {
-    let delta = num - relative;
-    delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+function decodeSign(num) {
+    return 1 & num ? -2147483648 | -(num >>> 1) : num >>> 1;
+}
+function encodeInteger(builder, num) {
     do {
-        let clamped = 31 & delta;
-        (delta >>>= 5) > 0 && (clamped |= 32), builder.write(intToChar[clamped]);
-    }while (delta > 0);
-    return num;
+        let clamped = 31 & num;
+        (num >>>= 5) > 0 && (clamped |= 32), builder.write(intToChar[clamped]);
+    }while (num > 0);
+}
+function encodeSign(num) {
+    return num < 0 ? -num << 1 | 1 : num << 1;
 }
 function hasMoreVlq(reader, max) {
     return !(reader.pos >= max) && 44 !== reader.peek();
@@ -63,13 +86,13 @@ function decode(mappings) {
         let semi = reader.indexOf(";"), line = [], sorted = !0, lastCol = 0;
         for(genColumn = 0; reader.pos < semi;){
             let seg;
-            (genColumn = decodeInteger(reader, genColumn)) < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), seg = hasMoreVlq(reader, semi) ? [
+            (genColumn += decodeSign(decodeInteger(reader))) < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex += decodeSign(decodeInteger(reader)), sourceLine += decodeSign(decodeInteger(reader)), sourceColumn += decodeSign(decodeInteger(reader)), hasMoreVlq(reader, semi) ? (namesIndex += decodeSign(decodeInteger(reader)), seg = [
                 genColumn,
                 sourcesIndex,
                 sourceLine,
                 sourceColumn,
-                namesIndex = decodeInteger(reader, namesIndex)
-            ] : [
+                namesIndex
+            ]) : seg = [
                 genColumn,
                 sourcesIndex,
                 sourceLine,
@@ -88,7 +111,7 @@ function sort(line) {
 function sortComparator(a, b) {
     return a[0] - b[0];
 }
-function sourcemap_codec_encode(decoded) {
+function encode(decoded) {
     let writer = new StringWriter(), sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
     for(let i = 0; i < decoded.length; i++){
         let line = decoded[i];
@@ -96,7 +119,7 @@ function sourcemap_codec_encode(decoded) {
         let genColumn = 0;
         for(let j = 0; j < line.length; j++){
             let segment = line[j];
-            j > 0 && writer.write(44), genColumn = encodeInteger(writer, segment[0], genColumn), 1 !== segment.length && (sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex), sourceLine = encodeInteger(writer, segment[2], sourceLine), sourceColumn = encodeInteger(writer, segment[3], sourceColumn), 4 !== segment.length && (namesIndex = encodeInteger(writer, segment[4], namesIndex)));
+            j > 0 && writer.write(44), encodeInteger(writer, encodeSign(segment[0] - genColumn)), genColumn = segment[0], 1 !== segment.length && (encodeInteger(writer, encodeSign(segment[1] - sourcesIndex)), encodeInteger(writer, encodeSign(segment[2] - sourceLine)), encodeInteger(writer, encodeSign(segment[3] - sourceColumn)), sourcesIndex = segment[1], sourceLine = segment[2], sourceColumn = segment[3], 4 !== segment.length && (encodeInteger(writer, encodeSign(segment[4] - namesIndex)), namesIndex = segment[4]));
         }
     }
     return writer.flush();
@@ -248,6 +271,30 @@ function sortSegments(line, owned) {
 function trace_mapping_sortComparator(a, b) {
     return a[0] - b[0];
 }
+function buildBySources(decoded, memos) {
+    let sources = memos.map(()=>[]);
+    for(let i = 0; i < decoded.length; i++){
+        let line = decoded[i];
+        for(let j = 0; j < line.length; j++){
+            let seg = line[j];
+            if (1 === seg.length) continue;
+            let sourceIndex2 = seg[1], sourceLine = seg[2], sourceColumn = seg[3], source = sources[sourceIndex2];
+            (source[sourceLine] || (source[sourceLine] = [])).push([
+                sourceColumn,
+                i,
+                seg[0]
+            ]);
+        }
+    }
+    for(let i = 0; i < sources.length; i++){
+        let source = sources[i];
+        for(let j = 0; j < source.length; j++){
+            let line = source[j];
+            line && line.sort(trace_mapping_sortComparator);
+        }
+    }
+    return sources;
+}
 var found = !1;
 function binarySearch(haystack, needle, low, high) {
     for(; low <= high;){
@@ -283,7 +330,75 @@ function memoizedBinarySearch(haystack, needle, state, key) {
 function parse(map) {
     return "string" == typeof map ? JSON.parse(map) : map;
 }
-var TraceMap = class {
+var FlattenMap = function(map, mapUrl) {
+    let parsed = parse(map);
+    if (!("sections" in parsed)) return new TraceMap(parsed, mapUrl);
+    let mappings = [], sources = [], sourcesContent = [], names = [], ignoreList = [];
+    return recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, 1 / 0, 1 / 0), presortedDecodedMap({
+        version: 3,
+        file: parsed.file,
+        names,
+        sources,
+        sourcesContent,
+        mappings,
+        ignoreList
+    });
+};
+function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+    let { sections } = input;
+    for(let i = 0; i < sections.length; i++){
+        let { map, offset } = sections[i], sl = stopLine, sc = stopColumn;
+        if (i + 1 < sections.length) {
+            let nextOffset = sections[i + 1].offset;
+            (sl = Math.min(stopLine, lineOffset + nextOffset.line)) === stopLine ? sc = Math.min(stopColumn, columnOffset + nextOffset.column) : sl < stopLine && (sc = columnOffset + nextOffset.column);
+        }
+        addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+    }
+}
+function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+    let parsed = parse(input);
+    if ("sections" in parsed) return recurse(...arguments);
+    let map = new TraceMap(parsed, mapUrl), sourcesOffset = sources.length, namesOffset = names.length, decoded = decodedMappings(map), { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+    if (append(sources, resolvedSources), append(names, map.names), contents) append(sourcesContent, contents);
+    else for(let i = 0; i < resolvedSources.length; i++)sourcesContent.push(null);
+    if (ignores) for(let i = 0; i < ignores.length; i++)ignoreList.push(ignores[i] + sourcesOffset);
+    for(let i = 0; i < decoded.length; i++){
+        let lineI = lineOffset + i;
+        if (lineI > stopLine) return;
+        let out = getLine(mappings, lineI), cOffset = 0 === i ? columnOffset : 0, line = decoded[i];
+        for(let j = 0; j < line.length; j++){
+            let seg = line[j], column = cOffset + seg[0];
+            if (lineI === stopLine && column >= stopColumn) return;
+            if (1 === seg.length) {
+                out.push([
+                    column
+                ]);
+                continue;
+            }
+            let sourcesIndex = sourcesOffset + seg[1], sourceLine = seg[2], sourceColumn = seg[3];
+            out.push(4 === seg.length ? [
+                column,
+                sourcesIndex,
+                sourceLine,
+                sourceColumn
+            ] : [
+                column,
+                sourcesIndex,
+                sourceLine,
+                sourceColumn,
+                namesOffset + seg[4]
+            ]);
+        }
+    }
+}
+function append(arr, other) {
+    for(let i = 0; i < other.length; i++)arr.push(other[i]);
+}
+function getLine(arr, index) {
+    for(let i = arr.length; i <= index; i++)arr[i] = [];
+    return arr[index];
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)", COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)", LEAST_UPPER_BOUND = -1, GREATEST_LOWER_BOUND = 1, TraceMap = class {
     constructor(map, mapUrl){
         let isString = "string" == typeof map;
         if (!isString && map._decodedMemo) return map;
@@ -299,28 +414,95 @@ var TraceMap = class {
         this._decodedMemo = memoizedState(), this._bySources = void 0, this._bySourceMemos = void 0;
     }
 };
+function encodedMappings(map) {
+    var _b;
+    return null != (_b = map._encoded) ? _b : map._encoded = encode(map._decoded);
+}
 function decodedMappings(map) {
     return map._decoded || (map._decoded = decode(map._encoded));
 }
 function traceSegment(map, line, column) {
     let decoded = decodedMappings(map);
     if (line >= decoded.length) return null;
-    let segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, 1);
+    let segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
     return -1 === index ? null : segments[index];
 }
 function originalPositionFor(map, needle) {
     let { line, column, bias } = needle;
-    if (--line < 0) throw Error("`line` must be greater than 0 (lines start at line 1)");
-    if (column < 0) throw Error("`column` must be greater than or equal to 0 (columns start at column 0)");
+    if (--line < 0) throw Error(LINE_GTR_ZERO);
+    if (column < 0) throw Error(COL_GTR_EQ_ZERO);
     let decoded = decodedMappings(map);
     if (line >= decoded.length) return OMapping(null, null, null, null);
-    let segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || 1);
+    let segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
     if (-1 === index) return OMapping(null, null, null, null);
     let segment = segments[index];
     if (1 === segment.length) return OMapping(null, null, null, null);
     let { names, resolvedSources } = map;
     return OMapping(resolvedSources[segment[1]], segment[2] + 1, segment[3], 5 === segment.length ? names[segment[4]] : null);
 }
+function generatedPositionFor(map, needle) {
+    let { source, line, column, bias } = needle;
+    return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, !1);
+}
+function allGeneratedPositionsFor(map, needle) {
+    let { source, line, column, bias } = needle;
+    return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, !0);
+}
+function eachMapping(map, cb) {
+    let decoded = decodedMappings(map), { names, resolvedSources } = map;
+    for(let i = 0; i < decoded.length; i++){
+        let line = decoded[i];
+        for(let j = 0; j < line.length; j++){
+            let seg = line[j], generatedLine = i + 1, generatedColumn = seg[0], source = null, originalLine = null, originalColumn = null, name = null;
+            1 !== seg.length && (source = resolvedSources[seg[1]], originalLine = seg[2] + 1, originalColumn = seg[3]), 5 === seg.length && (name = names[seg[4]]), cb({
+                generatedLine,
+                generatedColumn,
+                source,
+                originalLine,
+                originalColumn,
+                name
+            });
+        }
+    }
+}
+function sourceIndex(map, source) {
+    let { sources, resolvedSources } = map, index = sources.indexOf(source);
+    return -1 === index && (index = resolvedSources.indexOf(source)), index;
+}
+function sourceContentFor(map, source) {
+    let { sourcesContent } = map;
+    if (null == sourcesContent) return null;
+    let index = sourceIndex(map, source);
+    return -1 === index ? null : sourcesContent[index];
+}
+function isIgnored(map, source) {
+    let { ignoreList } = map;
+    if (null == ignoreList) return !1;
+    let index = sourceIndex(map, source);
+    return -1 !== index && ignoreList.includes(index);
+}
+function presortedDecodedMap(map, mapUrl) {
+    let tracer = new TraceMap(clone(map, []), mapUrl);
+    return tracer._decoded = map.mappings, tracer;
+}
+function decodedMap(map) {
+    return clone(map, decodedMappings(map));
+}
+function encodedMap(map) {
+    return clone(map, encodedMappings(map));
+}
+function clone(map, mappings) {
+    return {
+        version: map.version,
+        file: map.file,
+        names: map.names,
+        sourceRoot: map.sourceRoot,
+        sources: map.sources,
+        sourcesContent: map.sourcesContent,
+        mappings,
+        ignoreList: map.ignoreList || map.x_google_ignoreList
+    };
+}
 function OMapping(source, line, column, name) {
     return {
         source,
@@ -329,8 +511,40 @@ function OMapping(source, line, column, name) {
         name
     };
 }
+function GMapping(line, column) {
+    return {
+        line,
+        column
+    };
+}
 function traceSegmentInternal(segments, memo, line, column, bias) {
     let index = memoizedBinarySearch(segments, column, memo, line);
-    return (found ? index = (-1 === bias ? upperBound : lowerBound)(segments, column, index) : -1 === bias && index++, -1 === index || index === segments.length) ? -1 : index;
+    return (found ? index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index) : bias === LEAST_UPPER_BOUND && index++, -1 === index || index === segments.length) ? -1 : index;
+}
+function sliceGeneratedPositions(segments, memo, line, column, bias) {
+    let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+    if (!found && bias === LEAST_UPPER_BOUND && min++, -1 === min || min === segments.length) return [];
+    let matchedColumn = found ? column : segments[min][0];
+    found || (min = lowerBound(segments, matchedColumn, min));
+    let max = upperBound(segments, matchedColumn, min), result = [];
+    for(; min <= max; min++){
+        let segment = segments[min];
+        result.push(GMapping(segment[1] + 1, segment[2]));
+    }
+    return result;
+}
+function generatedPosition(map, source, line, column, bias, all) {
+    if (--line < 0) throw Error(LINE_GTR_ZERO);
+    if (column < 0) throw Error(COL_GTR_EQ_ZERO);
+    let { sources, resolvedSources } = map, sourceIndex2 = sources.indexOf(source);
+    if (-1 === sourceIndex2 && (sourceIndex2 = resolvedSources.indexOf(source)), -1 === sourceIndex2) return all ? [] : GMapping(null, null);
+    let bySourceMemos = map._bySourceMemos || (map._bySourceMemos = sources.map(memoizedState)), segments = (map._bySources || (map._bySources = buildBySources(decodedMappings(map), bySourceMemos)))[sourceIndex2][line];
+    if (null == segments) return all ? [] : GMapping(null, null);
+    let memo = bySourceMemos[sourceIndex2];
+    if (all) return sliceGeneratedPositions(segments, memo, line, column, bias);
+    let index = traceSegmentInternal(segments, memo, line, column, bias);
+    if (-1 === index) return GMapping(null, null);
+    let segment = segments[index];
+    return GMapping(segment[1] + 1, segment[2]);
 }
-export { TraceMap, decodedMappings, originalPositionFor, sourcemap_codec_encode, traceSegment };
+export { TraceMap, decodedMappings, encode, traceSegment, trace_mapping_namespaceObject };

package/dist/transformLoader.mjs

@@ -1,5 +1,6 @@
-let mergeSourceMap = async (originalSourceMap, generatedSourceMap)=>{
-    let { default: remapping } = await import("./remapping.js");
+import { cachedImport } from "./r.js";
+let getRemapping = cachedImport(()=>import("./remapping.js").then((m)=>m.remapping_namespaceObject)), mergeSourceMap = async (originalSourceMap, generatedSourceMap)=>{
+    let { default: remapping } = await getRemapping();
     return remapping([
         generatedSourceMap,
         originalSourceMap

package/dist/types/config.d.ts

@@ -1429,7 +1429,19 @@ export type NormalizedHtmlConfig = HtmlConfig & {
 export type ProgressBarConfig = {
     id?: string;
 };
-export type RequestHandler = Connect.NextHandleFunction;
+export interface RsbuildServerResponse extends ServerResponse {
+    /**
+   * Flush buffered gzip data without ending the response.
+   * May be absent when compression is disabled or the middleware has not run.
+   */ flush?: () => void;
+}
+export type RequestHandler = (req: Connect.IncomingMessage, res: RsbuildServerResponse, next: Connect.NextFunction) => unknown;
+export interface RsbuildMiddlewares extends Connect.Server {
+    use(fn: RequestHandler): this;
+    use(fn: Connect.ServerHandle): this;
+    use(route: string, fn: RequestHandler): this;
+    use(route: string, fn: Connect.ServerHandle): this;
+}
 export type EnvironmentAPI = Record<string, {
     /**
      * Get stats info about current environment.