@spyglassmc/core 0.1.0

package/lib/source/Source.d.ts

@@ -0,0 +1,110 @@
+import { IndexMap } from '.';
+import type { RangeContainer } from './Range';
+import { Range } from './Range';
+declare type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+declare type Space = ' ' | '\t';
+declare type Newline = '\r\n' | '\r' | '\n';
+declare type Whitespace = Space | Newline;
+export declare const CRLF = "\r\n";
+export declare const CR = "\r";
+export declare const LF = "\n";
+export declare const Whitespaces: readonly [" ", "\n", "\r", "\t"];
+export declare class ReadonlySource {
+    readonly string: string;
+    readonly indexMap: IndexMap;
+    innerCursor: number;
+    constructor(string: string, indexMap?: IndexMap);
+    get cursor(): number;
+    /**
+     * @param offset The index to offset from cursor. Defaults to 0.
+     *
+     * @returns The range of the specified character.
+     *
+     * @example
+     * getCharRange(-1) // Returns the range of the character before cursor.
+     * getCharRange()   // Returns the range of the character at cursor.
+     * getCharRange(1)  // Returns the range of the character after cursor.
+     */
+    getCharRange(offset?: number): Range;
+    /**
+     * Peeks a substring from the current cursor.
+     * @param length The length of the substring. Defaults to 1
+     * @param offset The index to offset from cursor. Defaults to 0
+     */
+    peek(length?: number, offset?: number): string;
+    /**
+     * If the `expectedValue` is right after the cursor, returns `true`. Otherwise returns `false`.
+     *
+     * @see {@link Source.trySkip}
+     */
+    tryPeek(expectedValue: string): boolean;
+    slice(start: number, end?: number): string;
+    slice(rangeLike: Range | RangeContainer): string;
+    sliceToCursor(start: number): string;
+}
+export declare class Source extends ReadonlySource {
+    string: string;
+    indexMap: IndexMap;
+    constructor(string: string, indexMap?: IndexMap);
+    get cursor(): number;
+    set cursor(cursor: number);
+    clone(): Source;
+    canRead(length?: number): boolean;
+    canReadInLine(): boolean;
+    read(): string;
+    /**
+     * Skips the current character.
+     * @param step The step to skip. @default 1
+     */
+    skip(step?: number): this;
+    /**
+     * If the `expectedValue` is right after the cursor, skips it and returns `true`. Otherwise returns `false`.
+     *
+     * This is a shortcut for the following piece of code:
+     * ```typescript
+     * declare const src: Source
+     * if (src.peek(expectedValue.length) === expectedValue) {
+     * 	src.skip(expectedValue.length)
+     * 	// Do something here.
+     * }
+     * ```
+     *
+     * @see {@link Source.tryPeek}
+     */
+    trySkip(expectedValue: string): boolean;
+    /**
+     * Reads until the end of this line.
+     */
+    readLine(): string;
+    /**
+     * Skips until the end of this line.
+     */
+    skipLine(): this;
+    /**
+     * Jumps to the beginning of the next line.
+     */
+    nextLine(): this;
+    readSpace(): string;
+    skipSpace(): this;
+    readWhitespace(): string;
+    skipWhitespace(): this;
+    /**
+     * @param terminators Ending character. Will not be skipped or included in the result.
+     */
+    readUntil(...terminators: string[]): string;
+    /**
+     * @param terminators Ending character. Will not be skipped.
+     */
+    skipUntilOrEnd(...terminators: string[]): this;
+    readUntilLineEnd(): string;
+    skipUntilLineEnd(): this;
+    readRemaining(): string;
+    skipRemaining(): this;
+    static isDigit(c: string): c is Digit;
+    static isBrigadierQuote(c: string): c is '"' | "'";
+    static isNewline(c: string): c is Newline;
+    static isSpace(c: string): c is Space;
+    static isWhitespace(c: string): c is Whitespace;
+}
+export {};
+//# sourceMappingURL=Source.d.ts.map

package/lib/source/Source.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Source = exports.ReadonlySource = exports.Whitespaces = exports.LF = exports.CR = exports.CRLF = void 0;
+const _1 = require(".");
+const Range_1 = require("./Range");
+exports.CRLF = '\r\n';
+exports.CR = '\r';
+exports.LF = '\n';
+exports.Whitespaces = Object.freeze([' ', '\n', '\r', '\t']);
+class ReadonlySource {
+    constructor(string, indexMap = []) {
+        this.string = string;
+        this.indexMap = indexMap;
+        this.innerCursor = 0;
+    }
+    get cursor() {
+        return _1.IndexMap.toOuterOffset(this.indexMap, this.innerCursor);
+    }
+    /**
+     * @param offset The index to offset from cursor. Defaults to 0.
+     *
+     * @returns The range of the specified character.
+     *
+     * @example
+     * getCharRange(-1) // Returns the range of the character before cursor.
+     * getCharRange()   // Returns the range of the character at cursor.
+     * getCharRange(1)  // Returns the range of the character after cursor.
+     */
+    getCharRange(offset = 0) {
+        return _1.IndexMap.toOuterRange(this.indexMap, Range_1.Range.create(this.innerCursor + offset, this.innerCursor + offset + 1));
+    }
+    /**
+     * Peeks a substring from the current cursor.
+     * @param length The length of the substring. Defaults to 1
+     * @param offset The index to offset from cursor. Defaults to 0
+     */
+    peek(length = 1, offset = 0) {
+        return this.string.slice(this.innerCursor + offset, this.innerCursor + offset + length);
+    }
+    /**
+     * If the `expectedValue` is right after the cursor, returns `true`. Otherwise returns `false`.
+     *
+     * @see {@link Source.trySkip}
+     */
+    tryPeek(expectedValue) {
+        return this.peek(expectedValue.length) === expectedValue;
+    }
+    slice(param0, end) {
+        if (typeof param0 === 'number') {
+            const innerStart = _1.IndexMap.toInnerOffset(this.indexMap, param0);
+            const innerEnd = end !== undefined ? _1.IndexMap.toInnerOffset(this.indexMap, end) : undefined;
+            return this.string.slice(innerStart, innerEnd);
+        }
+        const range = _1.IndexMap.toInnerRange(this.indexMap, Range_1.Range.get(param0));
+        return this.string.slice(range.start, range.end);
+    }
+    sliceToCursor(start) {
+        const innerStart = _1.IndexMap.toInnerOffset(this.indexMap, start);
+        return this.string.slice(innerStart, this.innerCursor);
+    }
+}
+exports.ReadonlySource = ReadonlySource;
+class Source extends ReadonlySource {
+    constructor(string, indexMap = []) {
+        super(string, indexMap);
+        this.string = string;
+        this.indexMap = indexMap;
+    }
+    get cursor() {
+        return super.cursor;
+    }
+    set cursor(cursor) {
+        this.innerCursor = _1.IndexMap.toInnerOffset(this.indexMap, cursor);
+    }
+    clone() {
+        const ans = new Source(this.string, this.indexMap);
+        ans.innerCursor = this.innerCursor;
+        return ans;
+    }
+    canRead(length = 1) {
+        return this.innerCursor + length <= this.string.length;
+    }
+    canReadInLine() {
+        return this.canRead() && this.peek() !== exports.CR && this.peek() !== exports.LF;
+    }
+    read() {
+        return this.string.charAt(this.innerCursor++);
+    }
+    /**
+     * Skips the current character.
+     * @param step The step to skip. @default 1
+     */
+    skip(step = 1) {
+        this.innerCursor += step;
+        return this;
+    }
+    /**
+     * If the `expectedValue` is right after the cursor, skips it and returns `true`. Otherwise returns `false`.
+     *
+     * This is a shortcut for the following piece of code:
+     * ```typescript
+     * declare const src: Source
+     * if (src.peek(expectedValue.length) === expectedValue) {
+     * 	src.skip(expectedValue.length)
+     * 	// Do something here.
+     * }
+     * ```
+     *
+     * @see {@link Source.tryPeek}
+     */
+    trySkip(expectedValue) {
+        if (this.peek(expectedValue.length) === expectedValue) {
+            this.skip(expectedValue.length);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reads until the end of this line.
+     */
+    readLine() {
+        return this.readUntil(exports.CR, exports.LF);
+    }
+    /**
+     * Skips until the end of this line.
+     */
+    skipLine() {
+        this.readLine();
+        return this;
+    }
+    /**
+     * Jumps to the beginning of the next line.
+     */
+    nextLine() {
+        this.skipLine();
+        if (this.peek(2) === exports.CRLF) {
+            this.skip(2);
+        }
+        else if (this.peek() === exports.CR || this.peek() === exports.LF) {
+            this.skip();
+        }
+        return this;
+    }
+    readSpace() {
+        const start = this.innerCursor;
+        this.skipSpace();
+        return this.string.slice(start, this.innerCursor);
+    }
+    skipSpace() {
+        while (this.canRead() && Source.isSpace(this.peek())) {
+            this.skip();
+        }
+        return this;
+    }
+    readWhitespace() {
+        const start = this.innerCursor;
+        this.skipWhitespace();
+        return this.string.slice(start, this.innerCursor);
+    }
+    skipWhitespace() {
+        while (this.canRead() && Source.isWhitespace(this.peek())) {
+            this.skip();
+        }
+        return this;
+    }
+    /**
+     * @param terminators Ending character. Will not be skipped or included in the result.
+     */
+    readUntil(...terminators) {
+        let ans = '';
+        while (this.canRead()) {
+            const c = this.peek();
+            if (terminators.includes(c)) {
+                return ans;
+            }
+            else {
+                ans += c;
+            }
+            this.skip();
+        }
+        return ans;
+    }
+    /**
+     * @param terminators Ending character. Will not be skipped.
+     */
+    skipUntilOrEnd(...terminators) {
+        this.readUntil(...terminators);
+        return this;
+    }
+    readUntilLineEnd() {
+        return this.readUntil(exports.CR, exports.LF);
+    }
+    skipUntilLineEnd() {
+        return this.skipUntilOrEnd(exports.CR, exports.LF);
+    }
+    readRemaining() {
+        const start = this.innerCursor;
+        this.innerCursor = this.string.length;
+        return this.string.slice(start);
+    }
+    skipRemaining() {
+        this.readRemaining();
+        return this;
+    }
+    static isDigit(c) {
+        return c >= '0' && c <= '9';
+    }
+    static isBrigadierQuote(c) {
+        return c === '"' || c === "'";
+    }
+    static isNewline(c) {
+        return c === '\r\n' || c === '\r' || c === '\n';
+    }
+    static isSpace(c) {
+        return c === ' ' || c === '\t';
+    }
+    static isWhitespace(c) {
+        return Source.isSpace(c) || Source.isNewline(c);
+    }
+}
+exports.Source = Source;
+//# sourceMappingURL=Source.js.map

package/lib/source/index.d.ts

@@ -0,0 +1,9 @@
+export * from './IndexMap';
+export * from './LanguageError';
+export * from './Location';
+export * from './Offset';
+export * from './Position';
+export * from './PositionRange';
+export * from './Range';
+export * from './Source';
+//# sourceMappingURL=index.d.ts.map

package/lib/source/index.js

@@ -0,0 +1,21 @@
+"use strict";
+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 });
+__exportStar(require("./IndexMap"), exports);
+__exportStar(require("./LanguageError"), exports);
+__exportStar(require("./Location"), exports);
+__exportStar(require("./Offset"), exports);
+__exportStar(require("./Position"), exports);
+__exportStar(require("./PositionRange"), exports);
+__exportStar(require("./Range"), exports);
+__exportStar(require("./Source"), exports);
+//# sourceMappingURL=index.js.map