@spyglassmc/core 0.1.0

package/lib/service/index.js

@@ -0,0 +1,33 @@
+"use strict";
+/* istanbul ignore file */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.FileService = void 0;
+__exportStar(require("./CacheService"), exports);
+__exportStar(require("./Config"), exports);
+__exportStar(require("./Context"), exports);
+__exportStar(require("./Dependency"), exports);
+__exportStar(require("./Downloader"), exports);
+__exportStar(require("./ErrorReporter"), exports);
+var FileService_1 = require("./FileService");
+Object.defineProperty(exports, "FileService", { enumerable: true, get: function () { return FileService_1.FileService; } });
+__exportStar(require("./fileUtil"), exports);
+__exportStar(require("./Hover"), exports);
+__exportStar(require("./Logger"), exports);
+__exportStar(require("./MetaRegistry"), exports);
+__exportStar(require("./Operations"), exports);
+__exportStar(require("./Profiler"), exports);
+__exportStar(require("./Project"), exports);
+__exportStar(require("./Service"), exports);
+__exportStar(require("./SymbolLocations"), exports);
+__exportStar(require("./SymbolRegistrar"), exports);
+//# sourceMappingURL=index.js.map

package/lib/source/IndexMap.d.ts

@@ -0,0 +1,16 @@
+import { Range } from './Range';
+/**
+ * The pairs should be in ascending order.
+ */
+export declare type IndexMap = {
+    outer: Range;
+    inner: Range;
+}[];
+export declare namespace IndexMap {
+    function toInnerOffset(map: IndexMap, offset: number): number;
+    function toInnerRange(map: IndexMap, outer: Range): Range;
+    function toOuterOffset(map: IndexMap, offset: number): number;
+    function toOuterRange(map: IndexMap, inner: Range): Range;
+    function merge(outerMap: IndexMap, innerMap: IndexMap): IndexMap;
+}
+//# sourceMappingURL=IndexMap.d.ts.map

package/lib/source/IndexMap.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexMap = void 0;
+const Range_1 = require("./Range");
+var IndexMap;
+(function (IndexMap) {
+    function convertOffset(map, offset, from, to, isEndOffset) {
+        let ans = offset;
+        for (const pair of map) {
+            if (Range_1.Range.contains(pair[from], offset, isEndOffset)) {
+                return isEndOffset ? pair[to].end : pair[to].start;
+            }
+            else if (Range_1.Range.endsBefore(pair[from], offset)) {
+                ans = offset - pair[from].end + pair[to].end;
+            }
+            else {
+                break;
+            }
+        }
+        return ans;
+    }
+    function toInnerOffset(map, offset) {
+        return convertOffset(map, offset, 'outer', 'inner', false);
+    }
+    IndexMap.toInnerOffset = toInnerOffset;
+    function toInnerRange(map, outer) {
+        return Range_1.Range.create(toInnerOffset(map, outer.start), convertOffset(map, outer.end, 'outer', 'inner', true));
+    }
+    IndexMap.toInnerRange = toInnerRange;
+    function toOuterOffset(map, offset) {
+        return convertOffset(map, offset, 'inner', 'outer', false);
+    }
+    IndexMap.toOuterOffset = toOuterOffset;
+    function toOuterRange(map, inner) {
+        return Range_1.Range.create(toOuterOffset(map, inner.start), convertOffset(map, inner.end, 'inner', 'outer', true));
+    }
+    IndexMap.toOuterRange = toOuterRange;
+    function merge(outerMap, innerMap) {
+        return innerMap.map(p => ({
+            inner: p.inner,
+            outer: toOuterRange(outerMap, p.outer),
+        }));
+    }
+    IndexMap.merge = merge;
+})(IndexMap = exports.IndexMap || (exports.IndexMap = {}));
+//# sourceMappingURL=IndexMap.js.map

package/lib/source/LanguageError.d.ts

@@ -0,0 +1,27 @@
+import type { Location } from './Location';
+import type { Range } from './Range';
+export interface LanguageError {
+    message: string;
+    range: Range;
+    severity: ErrorSeverity;
+    info?: LanguageErrorInfo;
+}
+export declare namespace LanguageError {
+    function create(message: string, range: Range, severity?: ErrorSeverity, info?: LanguageErrorInfo): LanguageError;
+}
+export declare const enum ErrorSeverity {
+    Hint = 0,
+    Information = 1,
+    Warning = 2,
+    Error = 3
+}
+export interface LanguageErrorInfo {
+    codeAction?: string;
+    deprecated?: boolean;
+    unnecessary?: boolean;
+    related?: {
+        location: Location;
+        message: string;
+    }[];
+}
+//# sourceMappingURL=LanguageError.d.ts.map

package/lib/source/LanguageError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageError = void 0;
+var LanguageError;
+(function (LanguageError) {
+    function create(message, range, severity = 3 /* Error */, info) {
+        const ans = { range, message, severity };
+        if (info) {
+            ans.info = info;
+        }
+        return ans;
+    }
+    LanguageError.create = create;
+})(LanguageError = exports.LanguageError || (exports.LanguageError = {}));
+//# sourceMappingURL=LanguageError.js.map

package/lib/source/Location.d.ts

@@ -0,0 +1,19 @@
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { PositionRange } from './PositionRange';
+import type { RangeLike } from './Range';
+import { Range } from './Range';
+export interface Location {
+    uri: string;
+    range: Range;
+    posRange: PositionRange;
+}
+export declare type LocationLike = Partial<{
+    uri: string;
+    range: RangeLike;
+    posRange: PositionRange;
+}>;
+export declare namespace Location {
+    function get(partial: LocationLike): Location;
+    function create(doc: TextDocument, range: RangeLike): Location;
+}
+//# sourceMappingURL=Location.d.ts.map

package/lib/source/Location.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Location = void 0;
+const PositionRange_1 = require("./PositionRange");
+const Range_1 = require("./Range");
+var Location;
+(function (Location) {
+    function get(partial) {
+        return {
+            uri: partial.uri ?? '',
+            range: Range_1.Range.get(partial.range ?? { start: 0, end: 0 }),
+            posRange: partial.posRange ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
+        };
+    }
+    Location.get = get;
+    function create(doc, range) {
+        return Location.get({
+            uri: doc.uri,
+            range,
+            posRange: PositionRange_1.PositionRange.from(range, doc),
+        });
+    }
+    Location.create = create;
+})(Location = exports.Location || (exports.Location = {}));
+//# sourceMappingURL=Location.js.map

package/lib/source/Offset.d.ts

@@ -0,0 +1,13 @@
+import { ReadonlySource } from './Source';
+export declare type OffsetLike = number | ReadonlySource | ((this: void) => number | ReadonlySource);
+export declare namespace Offset {
+    /**
+     * Get an offset from a `OffsetLike`.
+     *
+     * @returns
+     * - `number`: itself.
+     * - `Source`: its `cursor`.
+     */
+    function get(offset: OffsetLike): number;
+}
+//# sourceMappingURL=Offset.d.ts.map

package/lib/source/Offset.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Offset = void 0;
+const Source_1 = require("./Source");
+var Offset;
+(function (Offset) {
+    /**
+     * Get an offset from a `OffsetLike`.
+     *
+     * @returns
+     * - `number`: itself.
+     * - `Source`: its `cursor`.
+     */
+    function get(offset) {
+        if (typeof offset === 'function') {
+            offset = offset();
+        }
+        if (offset instanceof Source_1.ReadonlySource) {
+            offset = offset.cursor;
+        }
+        return offset;
+    }
+    Offset.get = get;
+})(Offset = exports.Offset || (exports.Offset = {}));
+//# sourceMappingURL=Offset.js.map

package/lib/source/Position.d.ts

@@ -0,0 +1,23 @@
+export interface Position {
+    line: number;
+    character: number;
+}
+export declare namespace Position {
+    function create(line: number, character: number): Position;
+    function create(partial: Partial<Position>): Position;
+    /**
+     * ```typescript
+     * { line: 0, character: 0 }
+     * ```
+     */
+    const Beginning: Position;
+    /**
+     * ```typescript
+     * { line: Infinity, character: Infinity }
+     * ```
+     */
+    const Infinity: Position;
+    function toString(pos: Position): string;
+    function isBefore(pos1: Position, pos2: Position): boolean;
+}
+//# sourceMappingURL=Position.d.ts.map

package/lib/source/Position.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Position = void 0;
+var Position;
+(function (Position) {
+    function create(param1, param2) {
+        if (typeof param1 === 'object') {
+            return _createFromPartial(param1);
+        }
+        else {
+            return _createFromNumbers(param1, param2);
+        }
+    }
+    Position.create = create;
+    function _createFromPartial(partial) {
+        return { line: partial.line ?? 0, character: partial.character ?? 0 };
+    }
+    function _createFromNumbers(line, character) {
+        return _createFromPartial({ line, character });
+    }
+    /**
+     * ```typescript
+     * { line: 0, character: 0 }
+     * ```
+     */
+    Position.Beginning = Position.create(0, 0);
+    /**
+     * ```typescript
+     * { line: Infinity, character: Infinity }
+     * ```
+     */
+    Position.Infinity = Position.create(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+    function toString(pos) {
+        return `<${pos.line}, ${pos.character}>`;
+    }
+    Position.toString = toString;
+    function isBefore(pos1, pos2) {
+        return (pos1.line < pos2.line ||
+            (pos1.line === pos2.line && pos1.character < pos2.character));
+    }
+    Position.isBefore = isBefore;
+})(Position = exports.Position || (exports.Position = {}));
+//# sourceMappingURL=Position.js.map

package/lib/source/PositionRange.d.ts

@@ -0,0 +1,38 @@
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { Position } from './Position';
+import type { RangeLike } from './Range';
+export interface PositionRange {
+    start: Position;
+    end: Position;
+}
+export declare namespace PositionRange {
+    function create(startLine: number, startCharacter: number, endLine: number, endCharacter: number): PositionRange;
+    function create(start: Position, end: Position): PositionRange;
+    function create(partial: Partial<PositionRange>): PositionRange;
+    /**
+     * @returns A `PositionRange` converted from a `RangeLike`.
+     */
+    function from(range: RangeLike, doc: TextDocument): PositionRange;
+    /**
+     * ```typescript
+     * {
+     * 	start: { line: 0, character: 0 },
+     * 	end: { line: 0, character: 1 }
+     * }
+     * ```
+     */
+    const Beginning: Readonly<PositionRange>;
+    /**
+     * ```typescript
+     * {
+     * 	start: { line: 0, character: 0 },
+     * 	end: { line: Infinity, character: Infinity }
+     * }
+     * ```
+     */
+    const Full: Readonly<PositionRange>;
+    function toString(range: PositionRange): string;
+    function contains(range: PositionRange, pos: Position): boolean;
+    function endsBefore(range: PositionRange, pos: Position): boolean;
+}
+//# sourceMappingURL=PositionRange.d.ts.map

package/lib/source/PositionRange.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionRange = void 0;
+const Position_1 = require("./Position");
+const Range_1 = require("./Range");
+var PositionRange;
+(function (PositionRange) {
+    function create(param1, param2, param3, param4) {
+        if (typeof param1 === 'number') {
+            return {
+                start: Position_1.Position.create(param1, param2),
+                end: Position_1.Position.create(param3, param4),
+            };
+        }
+        else if (param2 !== undefined) {
+            return {
+                start: Position_1.Position.create(param1),
+                end: Position_1.Position.create(param2),
+            };
+        }
+        else {
+            const partial = param1;
+            return {
+                start: Position_1.Position.create(partial.start ?? {}),
+                end: Position_1.Position.create(partial.end ?? {}),
+            };
+        }
+    }
+    PositionRange.create = create;
+    /**
+     * @returns A `PositionRange` converted from a `RangeLike`.
+     */
+    function from(range, doc) {
+        const _range = Range_1.Range.get(range);
+        const ans = {
+            start: doc.positionAt(_range.start),
+            end: doc.positionAt(_range.end),
+        };
+        return ans;
+    }
+    PositionRange.from = from;
+    /**
+     * ```typescript
+     * {
+     * 	start: { line: 0, character: 0 },
+     * 	end: { line: 0, character: 1 }
+     * }
+     * ```
+     */
+    PositionRange.Beginning = Object.freeze(PositionRange.create(0, 0, 0, 1));
+    /**
+     * ```typescript
+     * {
+     * 	start: { line: 0, character: 0 },
+     * 	end: { line: Infinity, character: Infinity }
+     * }
+     * ```
+     */
+    PositionRange.Full = Object.freeze(PositionRange.create(Position_1.Position.Beginning, Position_1.Position.Infinity));
+    function toString(range) {
+        return `[${Position_1.Position.toString(range.start)}, ${Position_1.Position.toString(range.end)})`;
+    }
+    PositionRange.toString = toString;
+    function contains(range, pos) {
+        const { start, end } = range;
+        // Check range of line number.
+        if (pos.line < start.line || pos.line > end.line) {
+            return false;
+        }
+        if (start.line < pos.line && pos.line < end.line) {
+            return true;
+        }
+        // Now `pos` is in the same line as `start` and/or `end`.
+        return ((pos.line === start.line ? pos.character >= start.character : true) &&
+            (pos.line === end.line ? pos.character < end.character : true));
+    }
+    PositionRange.contains = contains;
+    function endsBefore(range, pos) {
+        return Position_1.Position.isBefore(Position_1.Position.create(range.end.line, range.end.character - 1), pos);
+    }
+    PositionRange.endsBefore = endsBefore;
+})(PositionRange = exports.PositionRange || (exports.PositionRange = {}));
+//# sourceMappingURL=PositionRange.js.map

package/lib/source/Range.d.ts

@@ -0,0 +1,68 @@
+import type { OffsetLike } from './Offset';
+export declare type RangeLike = Range | RangeContainer | OffsetLike | ((this: void) => Range | RangeContainer | OffsetLike);
+export interface Range {
+    start: number;
+    end: number;
+}
+export declare namespace Range {
+    /**
+     * Gets a range from `RangeLike`.
+     *
+     * @returns
+     * - `Range`: a clone of it.
+     * - `RangeContainer`: a clone of its range.
+     * - `OffsetLike`: a range with both positions set to the offset.
+     */
+    function get(range: RangeLike): Range;
+    /**
+     * Creates a range from `OffsetLike`. If only `start` is passed in, `end` will be the same value as `start`.
+     */
+    function create(start: OffsetLike, end?: OffsetLike): Range;
+    /**
+     * Creates a range that covers the area between `from.start` and `to.end`.
+     */
+    function span(from: RangeLike, to: RangeLike): Range;
+    function is(obj: unknown): obj is Range;
+    /**
+     * ```typescript
+     * { start: 0, end: 1 }
+     * ```
+     */
+    const Beginning: Readonly<Range>;
+    /**
+     * ```typescript
+     * { start: 0, end: Infinity }
+     * ```
+     */
+    const Full: Readonly<Range>;
+    function toString(range: Range): string;
+    function contains(range: RangeLike, offset: number, endInclusive?: boolean): boolean;
+    function containsRange(a: RangeLike, b: RangeLike, endInclusive?: boolean): boolean;
+    function intersects(a: Range, b: Range): boolean;
+    function equals(a: Range, b: Range): boolean;
+    function endsBefore(range: Range, target: RangeLike, endInclusive?: boolean): boolean;
+    function isEmpty(range: RangeLike): boolean;
+    function length(range: Range): number;
+    /**
+     * @returns Negative when `a` is before `b`, `0` if they intersect, and positive if it's after.
+     */
+    function compare(a: Range, b: Range, endInclusive?: boolean): number;
+    /**
+     * @returns Negative when `range` is before `offset`, `0` if it {@link contains} `offset`, and positive if it's after.
+     */
+    function compareOffset(range: Range, offset: number, endInclusive?: boolean): number;
+    /**
+     * @param startOffset The number to offset the start of the `range`.
+     * @param endOffset The number to offset the end of the `range`. Default: `startOffset`.
+     * @returns A copy of `range`.
+     */
+    function translate(range: RangeLike, startOffset: number, endOffset?: number): Range;
+}
+export interface RangeContainer {
+    range: Range;
+    [key: string]: any;
+}
+export declare namespace RangeContainer {
+    function is(obj: unknown): obj is RangeContainer;
+}
+//# sourceMappingURL=Range.d.ts.map

package/lib/source/Range.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeContainer = exports.Range = void 0;
+const Offset_1 = require("./Offset");
+var Range;
+(function (Range) {
+    /**
+     * Gets a range from `RangeLike`.
+     *
+     * @returns
+     * - `Range`: a clone of it.
+     * - `RangeContainer`: a clone of its range.
+     * - `OffsetLike`: a range with both positions set to the offset.
+     */
+    function get(range) {
+        const evaluated = typeof range === 'function' ? range() : range;
+        if (Range.is(evaluated)) {
+            return Range.create(evaluated.start, evaluated.end);
+        }
+        if (RangeContainer.is(evaluated)) {
+            return Range.create(evaluated.range.start, evaluated.range.end);
+        }
+        return Range.create(evaluated);
+    }
+    Range.get = get;
+    /**
+     * Creates a range from `OffsetLike`. If only `start` is passed in, `end` will be the same value as `start`.
+     */
+    function create(start, end) {
+        start = Offset_1.Offset.get(start);
+        return {
+            start,
+            end: end !== undefined ? Offset_1.Offset.get(end) : start,
+        };
+    }
+    Range.create = create;
+    /**
+     * Creates a range that covers the area between `from.start` and `to.end`.
+     */
+    function span(from, to) {
+        return {
+            start: Range.get(from).start,
+            end: Range.get(to).end,
+        };
+    }
+    Range.span = span;
+    function is(obj) {
+        return (!!obj && typeof obj === 'object' &&
+            typeof obj.start === 'number' &&
+            typeof obj.end === 'number');
+    }
+    Range.is = is;
+    /**
+     * ```typescript
+     * { start: 0, end: 1 }
+     * ```
+     */
+    Range.Beginning = Object.freeze(Range.create(0, 1));
+    /**
+     * ```typescript
+     * { start: 0, end: Infinity }
+     * ```
+     */
+    Range.Full = Object.freeze(Range.create(0, Number.POSITIVE_INFINITY));
+    function toString(range) {
+        return `[${range.start}, ${range.end})`;
+    }
+    Range.toString = toString;
+    function contains(range, offset, endInclusive = false) {
+        range = get(range);
+        return range.start <= offset && (endInclusive ? offset <= range.end : offset < range.end);
+    }
+    Range.contains = contains;
+    function containsRange(a, b, endInclusive = false) {
+        a = get(a);
+        b = get(b);
+        return contains(a, b.start, endInclusive) && contains(a, b.end, true);
+    }
+    Range.containsRange = containsRange;
+    function intersects(a, b) {
+        return Range.contains(a, b.start) || Range.contains(b, a.start);
+    }
+    Range.intersects = intersects;
+    function equals(a, b) {
+        return a.start === b.start && a.end === b.end;
+    }
+    Range.equals = equals;
+    function endsBefore(range, target, endInclusive = false) {
+        return endInclusive
+            ? range.end < Range.get(target).start
+            : range.end <= Range.get(target).start;
+    }
+    Range.endsBefore = endsBefore;
+    function isEmpty(range) {
+        range = get(range);
+        return range.start === range.end;
+    }
+    Range.isEmpty = isEmpty;
+    function length(range) {
+        return range.end - range.start;
+    }
+    Range.length = length;
+    /**
+     * @returns Negative when `a` is before `b`, `0` if they intersect, and positive if it's after.
+     */
+    function compare(a, b, endInclusive = false) {
+        if (endInclusive ? a.end < b.start : a.end <= b.start) {
+            return -1;
+        }
+        else if (endInclusive ? a.start > b.end : a.start >= b.end) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    Range.compare = compare;
+    /**
+     * @returns Negative when `range` is before `offset`, `0` if it {@link contains} `offset`, and positive if it's after.
+     */
+    function compareOffset(range, offset, endInclusive = false) {
+        if (endInclusive ? range.end < offset : range.end <= offset) {
+            return -1;
+        }
+        else if (range.start > offset) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    Range.compareOffset = compareOffset;
+    /**
+     * @param startOffset The number to offset the start of the `range`.
+     * @param endOffset The number to offset the end of the `range`. Default: `startOffset`.
+     * @returns A copy of `range`.
+     */
+    function translate(range, startOffset, endOffset = startOffset) {
+        range = get(range);
+        return {
+            start: range.start + startOffset,
+            end: range.end + endOffset,
+        };
+    }
+    Range.translate = translate;
+})(Range = exports.Range || (exports.Range = {}));
+var RangeContainer;
+(function (RangeContainer) {
+    function is(obj) {
+        return (!!obj && typeof obj === 'object' &&
+            Range.is(obj.range));
+    }
+    RangeContainer.is = is;
+})(RangeContainer = exports.RangeContainer || (exports.RangeContainer = {}));
+//# sourceMappingURL=Range.js.map