@volar/source-map 0.40.1 → 0.40.4

package/out/index.d.ts

@@ -50,7 +50,10 @@ export declare type Mapping<T> = MappingBase & {
     additional?: MappingBase[];
 };
 export declare class SourceMapBase<Data = undefined> {
-    mappings: Mapping<Data>[];
+    private __mappings;
+    private __memo;
+    get mappings(): Mapping<Data>[];
+    set mappings(value: Mapping<Data>[]);
     constructor(_mappings?: Mapping<Data>[]);
     getSourceRange(start: number, end?: number, filter?: (data: Data) => boolean): [{
         start: number;
@@ -72,5 +75,6 @@ export declare class SourceMapBase<Data = undefined> {
         start: number;
         end: number;
     }, Data], void, unknown>;
+    private binarySearchMemo;
     private getRange;
 }

package/out/index.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SourceMapBase = exports.Mode = void 0;
+const reactivity_1 = require("@vue/reactivity");
 var Mode;
 (function (Mode) {
     /**
@@ -41,8 +42,72 @@ var Mode;
 })(Mode = exports.Mode || (exports.Mode = {}));
 class SourceMapBase {
     constructor(_mappings) {
+        this.__mappings = (0, reactivity_1.shallowRef)([]);
+        this.__memo = (0, reactivity_1.computed)(() => {
+            const self = this;
+            const source = createMemo('sourceRange');
+            const mapped = createMemo('mappedRange');
+            return {
+                source,
+                mapped,
+            };
+            function createMemo(key) {
+                const offsets = new Set();
+                for (const mapping of self.mappings) {
+                    offsets.add(mapping[key].start);
+                    offsets.add(mapping[key].end);
+                    if (mapping.additional) {
+                        for (const addition of mapping.additional) {
+                            offsets.add(addition[key].start);
+                            offsets.add(addition[key].end);
+                        }
+                    }
+                }
+                const arr = [...offsets].sort((a, b) => a - b).map(offset => ({ offset, mappings: new Set() }));
+                for (const mapping of self.mappings) {
+                    const startIndex = binarySearch(mapping[key].start);
+                    const endIndex = binarySearch(mapping[key].end);
+                    for (let i = startIndex; i <= endIndex; i++) {
+                        arr[i].mappings.add(mapping);
+                    }
+                    if (mapping.additional) {
+                        for (const addition of mapping.additional) {
+                            const startIndex = binarySearch(addition[key].start);
+                            const endIndex = binarySearch(addition[key].end);
+                            for (let i = startIndex; i <= endIndex; i++) {
+                                arr[i].mappings.add(mapping);
+                            }
+                        }
+                    }
+                }
+                return arr;
+                function binarySearch(start) {
+                    let low = 0;
+                    let high = arr.length - 1;
+                    while (low <= high) {
+                        const mid = Math.floor((low + high) / 2);
+                        const midValue = arr[mid];
+                        if (midValue.offset < start) {
+                            low = mid + 1;
+                        }
+                        else if (midValue.offset > start) {
+                            high = mid - 1;
+                        }
+                        else {
+                            return mid;
+                        }
+                    }
+                }
+            }
+        });
         this.mappings = _mappings !== null && _mappings !== void 0 ? _mappings : [];
     }
+    get mappings() {
+        return this.__mappings.value;
+    }
+    set mappings(value) {
+        this.__mappings.value = value;
+    }
     getSourceRange(start, end, filter) {
         for (const mapped of this.getRanges(start, end !== null && end !== void 0 ? end : start, false, filter)) {
             return mapped;
@@ -60,26 +125,61 @@ class SourceMapBase {
         return this.getRanges(start, end !== null && end !== void 0 ? end : start, true, filter);
     }
     *getRanges(startOffset, endOffset, sourceToTarget, filter) {
-        for (const mapping of this.mappings) {
-            if (filter && !filter(mapping.data))
-                continue;
-            const mapped = this.getRange(startOffset, endOffset, sourceToTarget, mapping.mode, mapping.sourceRange, mapping.mappedRange, mapping.data);
-            if (mapped) {
-                yield getMapped(mapped);
-            }
-            else if (mapping.additional) {
-                for (const other of mapping.additional) {
-                    const mapped = this.getRange(startOffset, endOffset, sourceToTarget, other.mode, other.sourceRange, other.mappedRange, mapping.data);
-                    if (mapped) {
-                        yield getMapped(mapped);
-                        break; // only return first match additional range
+        const memo = this.__memo.value;
+        const _memo = sourceToTarget ? memo.source : memo.mapped;
+        if (_memo.length === 0)
+            return;
+        const { low: start, high: end, } = startOffset === endOffset ? this.binarySearchMemo(_memo, startOffset) : {
+            low: this.binarySearchMemo(_memo, startOffset).low,
+            high: this.binarySearchMemo(_memo, endOffset).high,
+        };
+        const skip = new Set();
+        for (let i = start; i <= end; i++) {
+            for (const mapping of _memo[i].mappings) {
+                if (skip.has(mapping)) {
+                    continue;
+                }
+                skip.add(mapping);
+                if (filter && !filter(mapping.data))
+                    continue;
+                const mapped = this.getRange(startOffset, endOffset, sourceToTarget, mapping.mode, mapping.sourceRange, mapping.mappedRange, mapping.data);
+                if (mapped) {
+                    yield mapped;
+                }
+                else if (mapping.additional) {
+                    for (const other of mapping.additional) {
+                        const mapped = this.getRange(startOffset, endOffset, sourceToTarget, other.mode, other.sourceRange, other.mappedRange, mapping.data);
+                        if (mapped) {
+                            yield mapped;
+                            break; // only return first match additional range
+                        }
                     }
                 }
             }
         }
-        function getMapped(mapped) {
-            return mapped;
+    }
+    binarySearchMemo(array, start) {
+        let low = 0;
+        let high = array.length - 1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const midValue = array[mid];
+            if (midValue.offset < start) {
+                low = mid + 1;
+            }
+            else if (midValue.offset > start) {
+                high = mid - 1;
+            }
+            else {
+                low = mid;
+                high = mid;
+                break;
+            }
         }
+        return {
+            low: Math.max(Math.min(low, high, array.length - 1), 0),
+            high: Math.min(Math.max(low, high, 0), array.length - 1),
+        };
     }
     getRange(start, end, sourceToTarget, mode, sourceRange, targetRange, data) {
         const mappedToRange = sourceToTarget ? targetRange : sourceRange;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/source-map",
-	"version": "0.40.1",
+	"version": "0.40.4",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -12,5 +12,8 @@
 		"url": "https://github.com/johnsoncodehk/volar.git",
 		"directory": "packages/source-map"
 	},
-	"gitHead": "4f92ef83a905c6d46cc92653ad87e0aec10f4e53"
+	"dependencies": {
+		"@vue/reactivity": "3.2.37"
+	},
+	"gitHead": "018d260d7bd00b06def4bcd600bf8d1e9347a7ec"
 }