@volar/source-map 1.11.1 → 2.0.0-alpha.0

package/README.md

@@ -0,0 +1,46 @@
+# @volar/source-map
+
+Provides functionality related to source maps.
+
+## API
+
+This package exports a `SourceMap` class with the following methods:
+
+- `getSourceOffset(generatedOffset: number)`: Returns the source offset for a given generated offset.
+
+- `getGeneratedOffset(sourceOffset: number)`: Returns the generated offset for a given source offset.
+
+- `getSourceOffsets(generatedOffset: number)`: Returns all source offsets for a given generated offset.
+
+- `getGeneratedOffsets(sourceOffset: number)`: Returns all generated offsets for a given source offset.
+
+## Data Structures
+
+### `Mapping`
+
+The `Mapping` is a tuple that represents a mapping in the source map. It consists of the following elements:
+
+- `source`: A string representing the source file. This can be `undefined`.
+- `sourceOffsets`: Offsets in the source code.
+- `generatedOffsets`: Offsets in the generated code.
+- `data`: The data associated with this mapping. The type of this data is generic and can be specified when creating a `SourceMap` instance.
+
+Here is an example of a `Mapping`:
+
+```ts
+let mapping: Mapping<MyDataType> = {
+    source: '.../sourceFile.ts',
+    sourceOffsets: [10],
+    generatedOffsets: [30],
+	lengths: [10],
+    data: myData,
+};
+```
+
+In this example, `myData` is of type `MyDataType`, which is the type specified for the SourceMap instance.
+
+Remember to replace `MyDataType` and `myData` with actual types and data that are relevant to your project.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

package/index.d.ts

@@ -1,28 +1,5 @@
-import { Segment, StackNode } from 'muggle-string';
 export * from 'muggle-string';
-export interface Mapping<T = any> {
-    source?: string;
-    sourceRange: [number, number];
-    generatedRange: [number, number];
-    data: T;
-}
-export interface Stack {
-    source: string;
-    range: [number, number];
-}
-export declare class SourceMap<Data = any> {
-    readonly mappings: Mapping<Data>[];
-    private _memo;
-    private get memo();
-    constructor(mappings: Mapping<Data>[]);
-    toSourceOffset(start: number, baseOnRight?: boolean): readonly [number, Mapping<Data>] | undefined;
-    toGeneratedOffset(start: number, baseOnRight?: boolean): readonly [number, Mapping<Data>] | undefined;
-    toSourceOffsets(start: number, baseOnRight?: boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
-    toGeneratedOffsets(start: number, baseOnRight?: boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
-    matching(startOffset: number, from: 'sourceRange' | 'generatedRange', to: 'sourceRange' | 'generatedRange', baseOnRight: boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
-    matchOffset(start: number, mappedFromRange: [number, number], mappedToRange: [number, number], baseOnRight: boolean): number | undefined;
-    private binarySearchMemo;
-}
-export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];
-export declare function buildStacks<T>(chunks: Segment<T>[], stacks: StackNode[]): Stack[];
-//# sourceMappingURL=index.d.ts.map
+export * from './lib/sourceMap';
+export * from './lib/translateOffset';
+export * from './lib/buildMappings';
+export * from './lib/buildStacks';

package/index.js

@@ -14,169 +14,9 @@ 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 });
-exports.buildStacks = exports.buildMappings = exports.SourceMap = void 0;
 __exportStar(require("muggle-string"), exports);
-class SourceMap {
-    get memo() {
-        if (!this._memo) {
-            const self = this;
-            this._memo = {
-                sourceRange: createMemo('sourceRange'),
-                generatedRange: createMemo('generatedRange'),
-            };
-            function createMemo(key) {
-                const offsets = new Set();
-                for (const mapping of self.mappings) {
-                    offsets.add(mapping[key][0]);
-                    offsets.add(mapping[key][1]);
-                }
-                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][0]);
-                    const endIndex = binarySearch(mapping[key][1]);
-                    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;
-                        }
-                    }
-                }
-            }
-        }
-        return this._memo;
-    }
-    constructor(mappings) {
-        this.mappings = mappings;
-    }
-    toSourceOffset(start, baseOnRight = false) {
-        for (const mapped of this.matching(start, 'generatedRange', 'sourceRange', baseOnRight)) {
-            return mapped;
-        }
-    }
-    toGeneratedOffset(start, baseOnRight = false) {
-        for (const mapped of this.matching(start, 'sourceRange', 'generatedRange', baseOnRight)) {
-            return mapped;
-        }
-    }
-    toSourceOffsets(start, baseOnRight = false) {
-        return this.matching(start, 'generatedRange', 'sourceRange', baseOnRight);
-    }
-    toGeneratedOffsets(start, baseOnRight = false) {
-        return this.matching(start, 'sourceRange', 'generatedRange', baseOnRight);
-    }
-    *matching(startOffset, from, to, baseOnRight) {
-        const memo = this.memo[from];
-        if (memo.length === 0)
-            return;
-        const { low: start, high: end, } = this.binarySearchMemo(memo, startOffset);
-        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);
-                const mapped = this.matchOffset(startOffset, mapping[from], mapping[to], baseOnRight);
-                if (mapped !== undefined) {
-                    yield [mapped, mapping];
-                }
-            }
-        }
-    }
-    matchOffset(start, mappedFromRange, mappedToRange, baseOnRight) {
-        if (start >= mappedFromRange[0] && start <= mappedFromRange[1]) {
-            let offset = mappedToRange[0] + start - mappedFromRange[0];
-            if (baseOnRight) {
-                offset += (mappedToRange[1] - mappedToRange[0]) - (mappedFromRange[1] - mappedFromRange[0]);
-            }
-            if (offset >= mappedToRange[0] && offset <= mappedToRange[1]) {
-                return offset;
-            }
-        }
-    }
-    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),
-        };
-    }
-}
-exports.SourceMap = SourceMap;
-function buildMappings(chunks) {
-    let length = 0;
-    const mappings = [];
-    for (const segment of chunks) {
-        if (typeof segment === 'string') {
-            length += segment.length;
-        }
-        else {
-            mappings.push({
-                generatedRange: [length, length + segment[0].length],
-                source: segment[1],
-                sourceRange: typeof segment[2] === 'number' ? [segment[2], segment[2] + segment[0].length] : segment[2],
-                // @ts-ignore
-                data: segment[3],
-            });
-            length += segment[0].length;
-        }
-    }
-    return mappings;
-}
-exports.buildMappings = buildMappings;
-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({
-            range: [start, offset],
-            source: stack.stack,
-        });
-    }
-    return result;
-}
-exports.buildStacks = buildStacks;
+__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.d.ts

@@ -0,0 +1,5 @@
+export declare function binarySearch(values: number[], searchValue: number): {
+    low: number;
+    high: number;
+    match: number | undefined;
+};

package/lib/binarySearch.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearch = void 0;
+function binarySearch(values, searchValue) {
+    let low = 0;
+    let high = values.length - 1;
+    let match;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const midValue = values[mid];
+        if (midValue < searchValue) {
+            low = mid + 1;
+        }
+        else if (midValue > searchValue) {
+            high = mid - 1;
+        }
+        else {
+            low = mid;
+            high = mid;
+            match = mid;
+            break;
+        }
+    }
+    const finalLow = Math.max(Math.min(low, high, values.length - 1), 0);
+    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/buildMappings.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,25 @@
+"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({
+                source: segment[1],
+                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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,28 @@
+"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

package/lib/sourceMap.d.ts

@@ -0,0 +1,21 @@
+export type CodeRangeKey = 'sourceOffsets' | 'generatedOffsets';
+export interface Mapping<T = any> {
+    source?: string;
+    sourceOffsets: number[];
+    generatedOffsets: number[];
+    lengths: number[];
+    data: T;
+}
+export declare class SourceMap<Data = any> {
+    readonly mappings: Mapping<Data>[];
+    private sourceCodeOffsetsMemo;
+    private generatedCodeOffsetsMemo;
+    constructor(mappings: Mapping<Data>[]);
+    getSourceOffset(generatedOffset: number): readonly [number, Mapping<Data>] | undefined;
+    getGeneratedOffset(sourceOffset: number): readonly [number, Mapping<Data>] | undefined;
+    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>;
+    private getMemoBasedOnRange;
+    private createMemo;
+}

package/lib/sourceMap.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMap = void 0;
+const binarySearch_1 = require("./binarySearch");
+const translateOffset_1 = require("./translateOffset");
+class SourceMap {
+    constructor(mappings) {
+        this.mappings = mappings;
+    }
+    getSourceOffset(generatedOffset) {
+        for (const mapped of this.findMatching(generatedOffset, 'generatedOffsets', 'sourceOffsets')) {
+            return mapped;
+        }
+    }
+    getGeneratedOffset(sourceOffset) {
+        for (const mapped of this.findMatching(sourceOffset, 'sourceOffsets', 'generatedOffsets')) {
+            return mapped;
+        }
+    }
+    getSourceOffsets(generatedOffset) {
+        return this.findMatching(generatedOffset, 'generatedOffsets', 'sourceOffsets');
+    }
+    getGeneratedOffsets(sourceOffset) {
+        return this.findMatching(sourceOffset, 'sourceOffsets', 'generatedOffsets');
+    }
+    *findMatching(offset, fromRange, toRange) {
+        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();
+        for (let i = start; i <= end; i++) {
+            for (const mapping of memo.mappings[i]) {
+                if (skip.has(mapping))
+                    continue;
+                skip.add(mapping);
+                const mapped = (0, translateOffset_1.translateOffset)(offset, mapping[fromRange], mapping[toRange], mapping.lengths);
+                if (mapped !== undefined)
+                    yield [mapped, mapping];
+            }
+        }
+    }
+    getMemoBasedOnRange(fromRange) {
+        return fromRange === 'sourceOffsets'
+            ? this.sourceCodeOffsetsMemo ??= this.createMemo('sourceOffsets')
+            : this.generatedCodeOffsetsMemo ??= this.createMemo('generatedOffsets');
+    }
+    createMemo(key) {
+        const offsetsSet = new Set();
+        for (const mapping of this.mappings) {
+            for (let i = 0; i < mapping[key].length; i++) {
+                offsetsSet.add(mapping[key][i]);
+                offsetsSet.add(mapping[key][i] + mapping.lengths[i]);
+            }
+        }
+        const offsets = [...offsetsSet].sort((a, b) => a - b);
+        const mappings = offsets.map(() => new Set());
+        for (const mapping of this.mappings) {
+            for (let i = 0; i < mapping[key].length; i++) {
+                const startIndex = (0, binarySearch_1.binarySearch)(offsets, mapping[key][i]).match;
+                const endIndex = (0, binarySearch_1.binarySearch)(offsets, mapping[key][i] + mapping.lengths[i]).match;
+                for (let i = startIndex; i <= endIndex; i++) {
+                    mappings[i].add(mapping);
+                }
+            }
+        }
+        return { offsets, mappings };
+    }
+}
+exports.SourceMap = SourceMap;
+//# sourceMappingURL=sourceMap.js.map

package/lib/translateOffset.d.ts

@@ -0,0 +1 @@
+export declare function translateOffset(start: number, fromOffsets: number[], toOffsets: number[], lengths: number[]): number | undefined;

package/lib/translateOffset.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateOffset = void 0;
+function translateOffset(start, fromOffsets, toOffsets, lengths) {
+    for (let i = 0; i < fromOffsets.length; i++) {
+        const fromOffset = fromOffsets[i];
+        const toOffset = toOffsets[i];
+        const length = lengths[i];
+        if (start >= fromOffset && start <= fromOffset + length) {
+            return toOffset + start - fromOffset;
+        }
+    }
+}
+exports.translateOffset = translateOffset;
+//# sourceMappingURL=translateOffset.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/source-map",
-	"version": "1.11.1",
+	"version": "2.0.0-alpha.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/source-map"
 	},
 	"dependencies": {
-		"muggle-string": "^0.3.1"
+		"muggle-string": "^0.4.0"
 	},
-	"gitHead": "188f49ee79bd2ea8e8fc32b80003c85f79868f9d"
+	"gitHead": "6a6be45a3b7983148d90541e7c68ef84c9155a7a"
 }