@volar/source-map 2.3.0 → 2.3.2

package/index.d.ts

@@ -1,5 +1,2 @@
-export * from 'muggle-string';
 export * from './lib/sourceMap';
 export * from './lib/translateOffset';
-export * from './lib/buildMappings';
-export * from './lib/buildStacks';

package/index.js

@@ -14,9 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("muggle-string"), exports);
 __exportStar(require("./lib/sourceMap"), exports);
 __exportStar(require("./lib/translateOffset"), exports);
-__exportStar(require("./lib/buildMappings"), exports);
-__exportStar(require("./lib/buildStacks"), exports);
 //# sourceMappingURL=index.js.map

package/lib/binarySearch.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.binarySearch = void 0;
+exports.binarySearch = binarySearch;
 function binarySearch(values, searchValue) {
     let low = 0;
     let high = values.length - 1;
@@ -25,5 +25,4 @@ function binarySearch(values, searchValue) {
     const finalHigh = Math.min(Math.max(low, high, 0), values.length - 1);
     return { low: finalLow, high: finalHigh, match };
 }
-exports.binarySearch = binarySearch;
 //# sourceMappingURL=binarySearch.js.map

package/lib/sourceMap.d.ts

@@ -1,4 +1,4 @@
-export type CodeRangeKey = 'sourceOffsets' | 'generatedOffsets';
+type CodeRangeKey = 'sourceOffsets' | 'generatedOffsets';
 export interface Mapping<Data = unknown> {
     sourceOffsets: number[];
     generatedOffsets: number[];
@@ -11,9 +11,13 @@ export declare class SourceMap<Data = unknown> {
     private sourceCodeOffsetsMemo;
     private generatedCodeOffsetsMemo;
     constructor(mappings: Mapping<Data>[]);
-    getSourceOffsets(generatedOffset: number): Generator<readonly [number, Mapping<Data>], void, unknown>;
-    getGeneratedOffsets(sourceOffset: number): Generator<readonly [number, Mapping<Data>], void, unknown>;
-    findMatching(offset: number, fromRange: CodeRangeKey, toRange: CodeRangeKey): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    toSourceRange(generatedStart: number, generatedEnd: number, fallbackToAnyMatch: boolean, filter?: (data: Data) => boolean): Generator<[mappedStart: number, mappedEnd: number, startMapping: Mapping<Data>, endMapping: Mapping<Data>], any, unknown>;
+    toGeneratedRange(sourceStart: number, sourceEnd: number, fallbackToAnyMatch: boolean, filter?: (data: Data) => boolean): Generator<[mappedStart: number, mappedEnd: number, startMapping: Mapping<Data>, endMapping: Mapping<Data>], any, unknown>;
+    toSourceLocation(generatedOffset: number, filter?: (data: Data) => boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    toGeneratedLocation(sourceOffset: number, filter?: (data: Data) => boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    findMatchingOffsets(offset: number, fromRange: CodeRangeKey, filter?: (data: Data) => boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    findMatchingStartEnd(start: number, end: number, fallbackToAnyMatch: boolean, fromRange: CodeRangeKey, filter?: (data: Data) => boolean): Generator<[mappedStart: number, mappedEnd: number, startMapping: Mapping<Data>, endMapping: Mapping<Data>]>;
     private getMemoBasedOnRange;
     private createMemo;
 }
+export {};

package/lib/sourceMap.js

@@ -7,25 +7,35 @@ class SourceMap {
     constructor(mappings) {
         this.mappings = mappings;
     }
-    getSourceOffsets(generatedOffset) {
-        return this.findMatching(generatedOffset, 'generatedOffsets', 'sourceOffsets');
+    toSourceRange(generatedStart, generatedEnd, fallbackToAnyMatch, filter) {
+        return this.findMatchingStartEnd(generatedStart, generatedEnd, fallbackToAnyMatch, 'generatedOffsets', filter);
     }
-    getGeneratedOffsets(sourceOffset) {
-        return this.findMatching(sourceOffset, 'sourceOffsets', 'generatedOffsets');
+    toGeneratedRange(sourceStart, sourceEnd, fallbackToAnyMatch, filter) {
+        return this.findMatchingStartEnd(sourceStart, sourceEnd, fallbackToAnyMatch, 'sourceOffsets', filter);
     }
-    *findMatching(offset, fromRange, toRange) {
+    toSourceLocation(generatedOffset, filter) {
+        return this.findMatchingOffsets(generatedOffset, 'generatedOffsets', filter);
+    }
+    toGeneratedLocation(sourceOffset, filter) {
+        return this.findMatchingOffsets(sourceOffset, 'sourceOffsets', filter);
+    }
+    *findMatchingOffsets(offset, fromRange, filter) {
         const memo = this.getMemoBasedOnRange(fromRange);
         if (memo.offsets.length === 0) {
             return;
         }
         const { low: start, high: end } = (0, binarySearch_1.binarySearch)(memo.offsets, offset);
         const skip = new Set();
+        const toRange = fromRange == 'sourceOffsets' ? 'generatedOffsets' : 'sourceOffsets';
         for (let i = start; i <= end; i++) {
             for (const mapping of memo.mappings[i]) {
                 if (skip.has(mapping)) {
                     continue;
                 }
                 skip.add(mapping);
+                if (filter && !filter(mapping.data)) {
+                    continue;
+                }
                 const mapped = (0, translateOffset_1.translateOffset)(offset, mapping[fromRange], mapping[toRange], getLengths(mapping, fromRange), getLengths(mapping, toRange));
                 if (mapped !== undefined) {
                     yield [mapped, mapping];
@@ -33,6 +43,34 @@ class SourceMap {
             }
         }
     }
+    *findMatchingStartEnd(start, end, fallbackToAnyMatch, fromRange, filter) {
+        const toRange = fromRange == 'sourceOffsets' ? 'generatedOffsets' : 'sourceOffsets';
+        const mappedStarts = [];
+        let hadMatch = false;
+        for (const [mappedStart, mapping] of this.findMatchingOffsets(start, fromRange)) {
+            if (filter && !filter(mapping.data)) {
+                continue;
+            }
+            mappedStarts.push([mappedStart, mapping]);
+            const mappedEnd = (0, translateOffset_1.translateOffset)(end, mapping[fromRange], mapping[toRange], getLengths(mapping, fromRange), getLengths(mapping, toRange));
+            if (mappedEnd !== undefined) {
+                hadMatch = true;
+                yield [mappedStart, mappedEnd, mapping, mapping];
+            }
+        }
+        if (!hadMatch && fallbackToAnyMatch) {
+            for (const [mappedStart, mappingStart] of mappedStarts) {
+                for (const [mappedEnd, mappingEnd] of this.findMatchingOffsets(end, fromRange)) {
+                    if (filter && !filter(mappingEnd.data) || mappedEnd < mappedStart) {
+                        continue;
+                    }
+                    yield [mappedStart, mappedEnd, mappingStart, mappingEnd];
+                    break;
+                }
+                ;
+            }
+        }
+    }
     getMemoBasedOnRange(fromRange) {
         return fromRange === 'sourceOffsets'
             ? this.sourceCodeOffsetsMemo ??= this.createMemo('sourceOffsets')

package/lib/translateOffset.js

@@ -1,17 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateOffset = void 0;
+exports.translateOffset = translateOffset;
 function translateOffset(start, fromOffsets, toOffsets, fromLengths, toLengths = fromLengths) {
-    for (let i = 0; i < fromOffsets.length; i++) {
-        const fromOffset = fromOffsets[i];
-        const fromLength = fromLengths[i];
+    const isSorted = fromOffsets.every((value, index) => index === 0 || fromOffsets[index - 1] <= value);
+    if (!isSorted) {
+        throw new Error('fromOffsets must be sorted in ascending order');
+    }
+    let low = 0;
+    let high = fromOffsets.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const fromOffset = fromOffsets[mid];
+        const fromLength = fromLengths[mid];
         if (start >= fromOffset && start <= fromOffset + fromLength) {
-            const toLength = toLengths[i];
-            const toOffset = toOffsets[i];
+            const toLength = toLengths[mid];
+            const toOffset = toOffsets[mid];
             let rangeOffset = Math.min(start - fromOffset, toLength);
             return toOffset + rangeOffset;
         }
+        else if (start < fromOffset) {
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
     }
 }
-exports.translateOffset = translateOffset;
 //# sourceMappingURL=translateOffset.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/source-map",
-	"version": "2.3.0",
+	"version": "2.3.2",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -11,8 +11,5 @@
 		"url": "https://github.com/volarjs/volar.js.git",
 		"directory": "packages/source-map"
 	},
-	"dependencies": {
-		"muggle-string": "^0.4.0"
-	},
-	"gitHead": "4f6488605e22e0f76ea877460848a443fd3e8762"
+	"gitHead": "d07e7d7c4176eec4905e7a629ae6f278d1c72b48"
 }

package/lib/buildMappings.d.ts

@@ -1,3 +0,0 @@
-import type { Segment } from 'muggle-string';
-import type { Mapping } from './sourceMap';
-export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];

package/lib/buildMappings.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildMappings = void 0;
-function buildMappings(chunks) {
-    let length = 0;
-    const mappings = [];
-    for (const segment of chunks) {
-        if (typeof segment === 'string') {
-            length += segment.length;
-        }
-        else {
-            mappings.push({
-                sourceOffsets: [segment[2]],
-                generatedOffsets: [length],
-                lengths: [segment[0].length],
-                data: segment[3],
-            });
-            length += segment[0].length;
-        }
-    }
-    return mappings;
-}
-exports.buildMappings = buildMappings;
-//# sourceMappingURL=buildMappings.js.map

package/lib/buildStacks.d.ts

@@ -1,6 +0,0 @@
-import type { Segment, StackNode } from 'muggle-string';
-export interface Stack {
-    source: string;
-    range: [number, number];
-}
-export declare function buildStacks<T>(chunks: Segment<T>[], stacks: StackNode[]): Stack[];

package/lib/buildStacks.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildStacks = void 0;
-function buildStacks(chunks, stacks) {
-    let offset = 0;
-    let index = 0;
-    const result = [];
-    for (const stack of stacks) {
-        const start = offset;
-        for (let i = 0; i < stack.length; i++) {
-            const segment = chunks[index + i];
-            if (typeof segment === 'string') {
-                offset += segment.length;
-            }
-            else {
-                offset += segment[0].length;
-            }
-        }
-        index += stack.length;
-        result.push({
-            source: stack.stack,
-            range: [start, offset],
-        });
-    }
-    return result;
-}
-exports.buildStacks = buildStacks;
-//# sourceMappingURL=buildStacks.js.map