first commit

web-app/node_modules/@volar/source-map/lib/binarySearch.d.ts

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

web-app/node_modules/@volar/source-map/lib/binarySearch.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearch = binarySearch;
+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 };
+}
+//# sourceMappingURL=binarySearch.js.map

web-app/node_modules/@volar/source-map/lib/sourceMap.d.ts

@@ -0,0 +1,23 @@
+type CodeRangeKey = 'sourceOffsets' | 'generatedOffsets';
+export interface Mapping<Data = unknown> {
+    sourceOffsets: number[];
+    generatedOffsets: number[];
+    lengths: number[];
+    generatedLengths?: number[];
+    data: Data;
+}
+export declare class SourceMap<Data = unknown> {
+    readonly mappings: Mapping<Data>[];
+    private sourceCodeOffsetsMemo;
+    private generatedCodeOffsetsMemo;
+    constructor(mappings: Mapping<Data>[]);
+    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 {};

web-app/node_modules/@volar/source-map/lib/sourceMap.js

@@ -0,0 +1,105 @@
+"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;
+    }
+    toSourceRange(generatedStart, generatedEnd, fallbackToAnyMatch, filter) {
+        return this.findMatchingStartEnd(generatedStart, generatedEnd, fallbackToAnyMatch, 'generatedOffsets', filter);
+    }
+    toGeneratedRange(sourceStart, sourceEnd, fallbackToAnyMatch, filter) {
+        return this.findMatchingStartEnd(sourceStart, sourceEnd, fallbackToAnyMatch, 'sourceOffsets', filter);
+    }
+    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];
+                }
+            }
+        }
+    }
+    *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')
+            : 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] + getLengths(mapping, key)[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] + getLengths(mapping, key)[i]).match;
+                for (let i = startIndex; i <= endIndex; i++) {
+                    mappings[i].add(mapping);
+                }
+            }
+        }
+        return { offsets, mappings };
+    }
+}
+exports.SourceMap = SourceMap;
+function getLengths(mapping, key) {
+    return key == 'sourceOffsets' ? mapping.lengths : mapping.generatedLengths ?? mapping.lengths;
+}
+//# sourceMappingURL=sourceMap.js.map

web-app/node_modules/@volar/source-map/lib/translateOffset.d.ts

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

web-app/node_modules/@volar/source-map/lib/translateOffset.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateOffset = translateOffset;
+let warned = false;
+function translateOffset(start, fromOffsets, toOffsets, fromLengths, toLengths = fromLengths) {
+    const isSorted = fromOffsets.every((value, index) => index === 0 || fromOffsets[index - 1] <= value);
+    if (!isSorted) {
+        for (let i = 0; i < fromOffsets.length; i++) {
+            const fromOffset = fromOffsets[i];
+            const fromLength = fromLengths[i];
+            if (start >= fromOffset && start <= fromOffset + fromLength) {
+                const toLength = toLengths[i];
+                const toOffset = toOffsets[i];
+                let rangeOffset = Math.min(start - fromOffset, toLength);
+                return toOffset + rangeOffset;
+            }
+        }
+        if (!warned) {
+            warned = true;
+            console.warn('fromOffsets should 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[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;
+        }
+    }
+}
+//# sourceMappingURL=translateOffset.js.map