@spyglassmc/core 0.1.0

package/lib/parser/record.d.ts

@@ -0,0 +1,22 @@
+import type { AstNode } from '../node';
+import type { RecordNode } from '../node/RecordNode';
+import type { InfallibleParser, Parser } from './Parser';
+/** @internal For test only */
+export interface Options<K extends AstNode, V extends AstNode> {
+    start: string;
+    pair: {
+        key: Parser<K>;
+        sep: string;
+        value: Parser<V> | {
+            get: (recordResult: RecordNode<K, V>, keyResult: K | undefined) => Parser<V>;
+        };
+        end: string;
+        trailingEnd: boolean;
+    };
+    end: string;
+}
+/**
+ * @returns A parser that parses something coming in a key-value pair form. e.g. SNBT objects, entity selector arguments.
+ */
+export declare function record<K extends AstNode, V extends AstNode>({ start, pair, end }: Options<K, V>): InfallibleParser<RecordNode<K, V>>;
+//# sourceMappingURL=record.d.ts.map

package/lib/parser/record.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+const util_1 = require("./util");
+/**
+ * @returns A parser that parses something coming in a key-value pair form. e.g. SNBT objects, entity selector arguments.
+ */
+function record({ start, pair, end }) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'record',
+            range: source_1.Range.create(src),
+            children: [],
+        };
+        if (src.trySkip(start)) {
+            src.skipWhitespace();
+            let requiresPairEnd = false;
+            let hasPairEnd = false;
+            while (src.canRead() && src.peek(end.length) !== end) {
+                const pairStart = src.cursor;
+                let key;
+                let value;
+                // Pair end of the last pair.
+                if (requiresPairEnd && !hasPairEnd) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(pair.end)), src);
+                }
+                // Key.
+                const keyStart = src.cursor;
+                const { result: keyResult, updateSrcAndCtx: updateForKey, endCursor: keyEnd } = (0, util_1.attempt)(pair.key, src, ctx);
+                if (keyResult === Parser_1.Failure || (keyEnd - keyStart === 0 && ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('parser.record.key')), source_1.Range.create(src, () => src.skipUntilOrEnd(pair.sep, pair.end, end, '\r', '\n')));
+                }
+                else {
+                    updateForKey();
+                    key = keyResult;
+                }
+                // K-V sep.
+                let sepCharRange = undefined;
+                src.skipWhitespace();
+                if (src.peek(pair.sep.length) === pair.sep) {
+                    sepCharRange = source_1.Range.create(src, () => src.skip(pair.sep.length));
+                }
+                else {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(pair.sep)), src);
+                }
+                // Value.
+                src.skipWhitespace();
+                const valueParser = typeof pair.value === 'function' ? pair.value : pair.value.get(ans, key);
+                const valueStart = src.cursor;
+                const { result: valueResult, updateSrcAndCtx: updateForValue, endCursor: valueEnd } = (0, util_1.attempt)(valueParser, src, ctx);
+                if (valueResult === Parser_1.Failure || (valueEnd - valueStart === 0 && ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('parser.record.value')), source_1.Range.create(src, () => src.skipUntilOrEnd(pair.sep, pair.end, end, '\r', '\n')));
+                }
+                else {
+                    updateForValue();
+                    value = valueResult;
+                }
+                // Pair end.
+                let endCharRange = undefined;
+                src.skipWhitespace();
+                requiresPairEnd = true;
+                if (hasPairEnd = src.peek(pair.end.length) === pair.end) {
+                    endCharRange = source_1.Range.create(src, () => src.skip(pair.end.length));
+                }
+                // Create pair.
+                ans.children.push({
+                    type: 'pair',
+                    range: source_1.Range.create(pairStart, src),
+                    ...(key || value) ? { children: [key, value].filter(v => !!v) } : {},
+                    key,
+                    sep: sepCharRange,
+                    value,
+                    end: endCharRange,
+                });
+                src.skipWhitespace();
+            }
+            // Trailing pair end.
+            if (hasPairEnd && !pair.trailingEnd) {
+                ctx.err.report((0, locales_1.localize)('parser.record.trailing-end'), ans.children[ans.children.length - 1].end);
+            }
+            // End.
+            if (!src.trySkip(end)) {
+                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(end)), src);
+            }
+        }
+        else {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(start)), src);
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.record = record;
+//# sourceMappingURL=record.js.map

package/lib/parser/resourceLocation.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceLocationNode, ResourceLocationOptions } from '../node';
+import type { InfallibleParser } from './Parser';
+export declare function resourceLocation(options: ResourceLocationOptions): InfallibleParser<ResourceLocationNode>;
+//# sourceMappingURL=resourceLocation.d.ts.map

package/lib/parser/resourceLocation.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceLocation = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const common_1 = require("../common");
+const source_1 = require("../source");
+const Terminators = new Set([' ', '\r', '\n', '=', ',', '"', "'", '{', '}', '[', ']', '(', ')', ';']);
+const LegalCharacters = new Set([
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_', '-', '.',
+]);
+function resourceLocation(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'resource_location',
+            range: source_1.Range.create(src),
+            options,
+        };
+        if (src.trySkip(common_1.ResourceLocation.TagPrefix)) {
+            ans.isTag = true;
+        }
+        const start = src.cursor;
+        while (src.canReadInLine() && !Terminators.has(src.peek())) {
+            src.skip();
+        }
+        const raw = src.sliceToCursor(start);
+        ans.range.end = src.cursor;
+        if (raw.length === 0) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('resource-location')), ans);
+        }
+        else {
+            const sepIndex = raw.indexOf(options.namespacePathSep ?? common_1.ResourceLocation.NamespacePathSep);
+            if (sepIndex >= 0) {
+                ans.namespace = raw.slice(0, sepIndex);
+            }
+            const rawPath = raw.slice(sepIndex + 1);
+            ans.path = rawPath.split(common_1.ResourceLocation.PathSep);
+            // Check characters.
+            /* istanbul ignore next */
+            const illegalChars = [...new Set([
+                    ...[...ans.namespace ?? []].filter(c => !LegalCharacters.has(c)),
+                    ...[...rawPath].filter(c => c !== '/' && !LegalCharacters.has(c)),
+                ])];
+            if (illegalChars.length) {
+                ctx.err.report((0, locales_1.localize)('parser.resource-location.illegal', (0, locales_1.arrayToMessage)(illegalChars, true, 'and')), ans);
+            }
+            if (ans.isTag && !options.allowTag) {
+                ctx.err.report((0, locales_1.localize)('parser.resource-location.tag-diallowed'), ans);
+            }
+            if (!ans.namespace && options.isPredicate) {
+                ctx.err.report((0, locales_1.localize)('parser.resource-location.namespace-expected'), ans);
+            }
+            if (options.category) {
+                const fullRaw = common_1.ResourceLocation.lengthen(options.namespacePathSep === '.'
+                    ? raw.replace('.', common_1.ResourceLocation.NamespacePathSep)
+                    : raw);
+                ctx.symbols
+                    .query(ctx.doc, ans.isTag ? `tag/${options.category}` : options.category, fullRaw)
+                    .enter({ usage: { type: options.usageType, node: ans, accessType: options.accessType } });
+            }
+        }
+        return ans;
+    };
+}
+exports.resourceLocation = resourceLocation;
+//# sourceMappingURL=resourceLocation.js.map

package/lib/parser/string.d.ts

@@ -0,0 +1,18 @@
+import type { StringNode, StringOptions } from '../node';
+import type { InfallibleParser } from '../parser';
+import type { ParserContext } from '../service';
+import type { IndexMap } from '../source';
+import type { Parser, Result, Returnable } from './Parser';
+export declare function string(options: StringOptions): InfallibleParser<StringNode>;
+export declare function parseStringValue<T extends Returnable>(parser: Parser<T>, value: string, map: IndexMap, ctx: ParserContext): Result<T>;
+export declare const BrigadierUnquotableCharacters: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "_", ".", "+", "-"];
+export declare const BrigadierUnquotableCharacterSet: Set<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "b" | "B" | "d" | "D" | "f" | "F" | "l" | "L" | "s" | "S" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "c" | "g" | "h" | "j" | "k" | "m" | "n" | "o" | "q" | "r" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "_" | "A" | "C" | "E" | "G" | "H" | "I" | "J" | "K" | "M" | "N" | "O" | "P" | "Q" | "R" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+export declare const BrigadierUnquotablePattern: RegExp;
+export declare const BrigadierUnquotableOption: {
+    allowEmpty: boolean;
+    allowList: Set<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "b" | "B" | "d" | "D" | "f" | "F" | "l" | "L" | "s" | "S" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "c" | "g" | "h" | "j" | "k" | "m" | "n" | "o" | "q" | "r" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "_" | "A" | "C" | "E" | "G" | "H" | "I" | "J" | "K" | "M" | "N" | "O" | "P" | "Q" | "R" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
+};
+export declare const BrigadierStringOptions: StringOptions;
+export declare const brigadierString: InfallibleParser<StringNode>;
+export declare function isAllowedCharacter(c: string, options: Exclude<StringOptions['unquotable'], false | undefined>): boolean;
+//# sourceMappingURL=string.d.ts.map

package/lib/parser/string.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedCharacter = exports.brigadierString = exports.BrigadierStringOptions = exports.BrigadierUnquotableOption = exports.BrigadierUnquotablePattern = exports.BrigadierUnquotableCharacterSet = exports.BrigadierUnquotableCharacters = exports.parseStringValue = exports.string = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const node_1 = require("../node");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+function string(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'string',
+            range: source_1.Range.create(src),
+            options,
+            value: '',
+            valueMap: [],
+        };
+        let start = src.cursor;
+        if (options.quotes?.length && (src.peek() === '"' || src.peek() === "'")) {
+            const currentQuote = src.read();
+            const contentStart = src.cursor;
+            while (src.canRead() && src.peek() !== currentQuote) {
+                const cStart = src.cursor;
+                const c = src.read();
+                if (options.escapable && c === '\\') {
+                    const c2 = src.read();
+                    if (c2 === '\\' || c2 === currentQuote || node_1.EscapeChar.is(options.escapable.characters, c2)) {
+                        ans.valueMap.push({
+                            inner: source_1.Range.create(ans.value.length, ans.value.length + 1),
+                            outer: source_1.Range.create(cStart, src),
+                        });
+                        ans.value += node_1.EscapeTable.get(c2);
+                    }
+                    else if (options.escapable.unicode && c2 === 'u') {
+                        const hex = src.peek(4);
+                        if (/^[0-9a-f]{4}$/i.test(hex)) {
+                            src.skip(4);
+                            ans.valueMap.push({
+                                inner: source_1.Range.create(ans.value.length, ans.value.length + 1),
+                                outer: source_1.Range.create(cStart, src),
+                            });
+                            ans.value += String.fromCharCode(parseInt(hex, 16));
+                        }
+                        else {
+                            ctx.err.report((0, locales_1.localize)('parser.string.illegal-unicode-escape'), source_1.Range.create(src, src.getCharRange(3).end));
+                            ans.valueMap.push({
+                                inner: source_1.Range.create(ans.value.length, ans.value.length + 1),
+                                outer: source_1.Range.create(cStart, src),
+                            });
+                            ans.value += c2;
+                        }
+                    }
+                    else {
+                        if (!options.escapable.allowUnknown) {
+                            ctx.err.report((0, locales_1.localize)('parser.string.illegal-escape', (0, locales_1.localeQuote)(c2)), src.getCharRange(-1));
+                        }
+                        ans.valueMap.push({
+                            inner: source_1.Range.create(ans.value.length, ans.value.length + 1),
+                            outer: source_1.Range.create(cStart, src),
+                        });
+                        ans.value += c2;
+                    }
+                }
+                else {
+                    ans.value += c;
+                }
+            }
+            if (!src.trySkip(currentQuote)) {
+                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(currentQuote)), src);
+            }
+            if (!options.quotes.includes(currentQuote)) {
+                ctx.err.report((0, locales_1.localize)('parser.string.illegal-quote', options.quotes), ans);
+            }
+            start = contentStart;
+        }
+        else if (options.unquotable) {
+            while (src.canRead() && isAllowedCharacter(src.peek(), options.unquotable)) {
+                ans.value += src.read();
+            }
+            if (!ans.value && !options.unquotable.allowEmpty) {
+                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('string')), src);
+            }
+        }
+        else {
+            ctx.err.report((0, locales_1.localize)('expected', options.quotes), src);
+        }
+        ans.valueMap.unshift({ inner: source_1.Range.create(0), outer: source_1.Range.create(start) });
+        if (options.value?.parser) {
+            const valueResult = parseStringValue(options.value.parser, ans.value, ans.valueMap, ctx);
+            /* istanbul ignore else */
+            if (valueResult !== Parser_1.Failure) {
+                ans.children = [valueResult];
+            }
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.string = string;
+function parseStringValue(parser, value, map, ctx) {
+    const valueSrc = new source_1.Source(value, map);
+    const valueCtx = {
+        ...ctx,
+        doc: vscode_languageserver_textdocument_1.TextDocument.create(ctx.doc.uri, ctx.doc.languageId, ctx.doc.version, value),
+    };
+    // TODO: Mark trailing string as errors.
+    return parser(valueSrc, valueCtx);
+}
+exports.parseStringValue = parseStringValue;
+exports.BrigadierUnquotableCharacters = Object.freeze([
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '_', '.', '+', '-',
+]);
+exports.BrigadierUnquotableCharacterSet = new Set(exports.BrigadierUnquotableCharacters);
+exports.BrigadierUnquotablePattern = /^[0-9A-Za-z_\.\+\-]*$/;
+exports.BrigadierUnquotableOption = { allowEmpty: true, allowList: exports.BrigadierUnquotableCharacterSet };
+exports.BrigadierStringOptions = {
+    escapable: {},
+    quotes: ['"', "'"],
+    unquotable: exports.BrigadierUnquotableOption,
+};
+exports.brigadierString = string(exports.BrigadierStringOptions);
+function isAllowedCharacter(c, options) {
+    return options.allowList?.has(c) ?? !options.blockList?.has(c);
+}
+exports.isAllowedCharacter = isAllowedCharacter;
+//# sourceMappingURL=string.js.map

package/lib/parser/symbol.d.ts

@@ -0,0 +1,12 @@
+import type { SymbolNode, SymbolOptions } from '../node/SymbolNode';
+import type { AllCategory } from '../symbol';
+import type { InfallibleParser } from './Parser';
+/**
+ * This parser reads _everything_ until the end of the {@link Source}.
+ *
+ * You might want to use {@link acceptOnly}, {@link stopBefore}, or {@link string} to restrict what this parser can read.
+ */
+export declare function symbol(category: AllCategory): InfallibleParser<SymbolNode>;
+export declare function symbol(category: string): InfallibleParser<SymbolNode>;
+export declare function symbol(options: SymbolOptions): InfallibleParser<SymbolNode>;
+//# sourceMappingURL=symbol.d.ts.map

package/lib/parser/symbol.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbol = void 0;
+const source_1 = require("../source");
+function symbol(param) {
+    const options = getOptions(param);
+    return (src, ctx) => {
+        const ans = {
+            type: 'symbol',
+            range: source_1.Range.create(src),
+            options,
+            value: src.readRemaining(),
+        };
+        if (ans.value) {
+            const path = options.parentPath ? [...options.parentPath, ans.value] : [ans.value];
+            ctx.symbols
+                .query(ctx.doc, options.category, ...path)
+                .enter({ usage: { type: options.usageType, node: ans, accessType: options.accessType } });
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.symbol = symbol;
+function getOptions(param) {
+    if (typeof param === 'string') {
+        return { category: param };
+    }
+    else {
+        return param;
+    }
+}
+//# sourceMappingURL=symbol.js.map

package/lib/parser/table.d.ts

@@ -0,0 +1,22 @@
+import type { AstNode } from '../node';
+import type { TableNode } from '../node/RecordNode';
+import type { InfallibleParser, Parser } from './Parser';
+/** @internal For test only */
+export interface Options<K extends AstNode, V extends AstNode> {
+    start: string;
+    pair: {
+        key: Parser<K>;
+        sep: string;
+        value: Parser<V> | {
+            get: (tableResult: TableNode<K, V>, keyResult: K | undefined) => Parser<V>;
+        };
+        end: string;
+        trailingEnd: boolean;
+    };
+    end: string;
+}
+/**
+ * @returns A parser that parses something coming in a key-value pair form. e.g. SNBT objects, entity selector arguments.
+ */
+export declare function table<K extends AstNode, V extends AstNode>({ start, pair, end }: Options<K, V>): InfallibleParser<TableNode<K, V>>;
+//# sourceMappingURL=table.d.ts.map

package/lib/parser/table.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.table = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+const util_1 = require("./util");
+/**
+ * @returns A parser that parses something coming in a key-value pair form. e.g. SNBT objects, entity selector arguments.
+ */
+function table({ start, pair, end }) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'table',
+            range: source_1.Range.create(src),
+            children: [],
+        };
+        if (src.trySkip(start)) {
+            src.skipWhitespace();
+            let requiresPairEnd = false;
+            let hasPairEnd = false;
+            while (src.canRead() && src.peek(end.length) !== end) {
+                const pairStart = src.cursor;
+                let key;
+                let value;
+                // Pair end of the last pair.
+                if (requiresPairEnd && !hasPairEnd) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(pair.end)), src);
+                }
+                // Key.
+                const keyStart = src.cursor;
+                const { result: keyResult, updateSrcAndCtx: updateForKey, endCursor: keyEnd } = (0, util_1.attempt)(pair.key, src, ctx);
+                if (keyResult === Parser_1.Failure || (keyEnd - keyStart === 0 && ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('parser.table.key')), source_1.Range.create(src, () => src.skipUntilOrEnd(pair.sep, pair.end, end, '\r', '\n')));
+                }
+                else {
+                    updateForKey();
+                    key = keyResult;
+                }
+                // K-V sep.
+                let sepCharRange = undefined;
+                src.skipWhitespace();
+                if (src.peek(pair.sep.length) === pair.sep) {
+                    sepCharRange = source_1.Range.create(src, () => src.skip(pair.sep.length));
+                }
+                else {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(pair.sep)), src);
+                }
+                // Value.
+                src.skipWhitespace();
+                const valueParser = typeof pair.value === 'function' ? pair.value : pair.value.get(ans, key);
+                const valueStart = src.cursor;
+                const { result: valueResult, updateSrcAndCtx: updateForValue, endCursor: valueEnd } = (0, util_1.attempt)(valueParser, src, ctx);
+                if (valueResult === Parser_1.Failure || (valueEnd - valueStart === 0 && ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('parser.table.value')), source_1.Range.create(src, () => src.skipUntilOrEnd(pair.sep, pair.end, end, '\r', '\n')));
+                }
+                else {
+                    updateForValue();
+                    value = valueResult;
+                }
+                // Pair end.
+                let endCharRange = undefined;
+                src.skipWhitespace();
+                requiresPairEnd = true;
+                if (hasPairEnd = src.peek(pair.end.length) === pair.end) {
+                    endCharRange = source_1.Range.create(src, () => src.skip(pair.end.length));
+                }
+                // Create pair.
+                ans.children.push({
+                    type: 'pair',
+                    range: source_1.Range.create(pairStart, src),
+                    ...(key || value) ? { children: [key, value].filter(v => !!v) } : {},
+                    key,
+                    sep: sepCharRange,
+                    value,
+                    end: endCharRange,
+                });
+                src.skipWhitespace();
+            }
+            // Trailing pair end.
+            if (hasPairEnd && !pair.trailingEnd) {
+                ctx.err.report((0, locales_1.localize)('parser.table.trailing-end'), ans.children[ans.children.length - 1].end);
+            }
+            // End.
+            if (!src.trySkip(end)) {
+                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(end)), src);
+            }
+        }
+        else {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(start)), src);
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.table = table;
+//# sourceMappingURL=table.js.map

package/lib/parser/util.d.ts

@@ -0,0 +1,134 @@
+import type { AstNode } from '../node';
+import { SequenceUtil } from '../node';
+import type { ParserContext } from '../service';
+import type { ErrorSeverity, ReadonlySource, Source } from '../source';
+import type { InfallibleParser, Parser, Result, Returnable } from './Parser';
+declare type ExtractNodeType<P extends Parser<Returnable>> = P extends Parser<infer V> ? V : never;
+/**
+ * @template PA Parser array.
+ */
+declare type ExtractNodeTypes<PA extends Parser<Returnable>[]> = ExtractNodeType<PA[number]>;
+export interface AttemptResult<N extends Returnable = AstNode> {
+    result: Result<N>;
+    updateSrcAndCtx: () => void;
+    endCursor: number;
+    errorAmount: number;
+}
+interface InfallibleAttemptResult<N extends Returnable = AstNode> extends AttemptResult<N> {
+    result: N;
+}
+/**
+ * Attempts to parse using the given `parser`.
+ * @returns
+ * - `result`: The result returned by the `parser`.
+ * - `updateSrcAndCtx`: A function that will update the passed-in `src` and `ctx` to the state where `parser` has been executed.
+ * - `endCursor`: The offset where the `parser` stopped  parsing.
+ * - `errorAmount`: The amount of errors created by the `parser`.
+ */
+export declare function attempt<N extends Returnable = AstNode>(parser: InfallibleParser<N>, src: Source, ctx: ParserContext): InfallibleAttemptResult<N>;
+export declare function attempt<N extends Returnable = AstNode>(parser: Parser<N>, src: Source, ctx: ParserContext): AttemptResult<N>;
+declare type SP<CN extends AstNode> = SIP<CN> | Parser<CN | SequenceUtil<CN> | undefined> | {
+    get: (result: SequenceUtil<CN>) => Parser<CN | SequenceUtil<CN> | undefined> | undefined;
+};
+declare type SIP<CN extends AstNode> = InfallibleParser<CN | SequenceUtil<CN> | undefined> | {
+    get: (result: SequenceUtil<CN>) => InfallibleParser<CN | SequenceUtil<CN> | undefined> | undefined;
+};
+/**
+ * @template GN Gap node.
+ * @template PA Parser array.
+ *
+ * @param parseGap A parser that parses gaps between nodes in the sequence.
+ *
+ * @returns A parser that takes a sequence built with the passed-in parsers.
+ *
+ * `Failure` when any of the `parsers` returns a `Failure`.
+ */
+export declare function sequence<GN extends AstNode = never, PA extends SIP<AstNode>[] = SIP<AstNode>[]>(parsers: PA, parseGap?: InfallibleParser<GN[]>): InfallibleParser<SequenceUtil<GN | {
+    [K in number]: PA[K] extends SP<infer V> ? V : never;
+}[number]>>;
+export declare function sequence<GN extends AstNode = never, PA extends SP<AstNode>[] = SP<AstNode>[]>(parsers: PA, parseGap?: InfallibleParser<GN[]>): Parser<SequenceUtil<GN | {
+    [K in number]: PA[K] extends SP<infer V> ? V : never;
+}[number]>>;
+/**
+ * @template CN Child node.
+ *
+ * @param parser Must be fallible, as an infallible parser being repeated will result in an infinite loop.
+ * @param parseGap A parser that parses gaps between nodes in the sequence.
+ *
+ * @returns A parser that takes a sequence with the passed-in parser being repeated zero or more times.
+ */
+export declare function repeat<CN extends AstNode>(parser: InfallibleParser<CN | SequenceUtil<CN>>, parseGap?: InfallibleParser<CN[]>): void;
+export declare function repeat<CN extends AstNode>(parser: Parser<CN | SequenceUtil<CN>>, parseGap?: InfallibleParser<CN[]>): InfallibleParser<SequenceUtil<CN>>;
+export interface AnyOutObject {
+    /**
+     * The index of the parser in the provided `parsers` array that was ultimately taken. `-1` if all parsers failed.
+     */
+    index: number;
+}
+/**
+ * @param out An optional object that will be modified with additional information if provided.
+ *
+ * @returns A parser that returns the result of the passed-in parser which produces the least amount of error.
+ * If there are more than one `parsers` produced the same amount of errors, it then takes the parser that went the furthest in `Source`.
+ * If there is still a tie, it takes the one closer to the beginning of the `parsers` array.
+ *
+ * `Failure` when all of the `parsers` failed.
+ */
+export declare function any<PA extends [...Parser<Returnable>[], InfallibleParser<Returnable>]>(parsers: PA, out?: AnyOutObject): InfallibleParser<ExtractNodeTypes<PA>>;
+export declare function any<PA extends Parser<Returnable>[]>(parsers: PA, out?: AnyOutObject): Parser<ExtractNodeTypes<PA>>;
+/**
+ * @returns A parser that fails when the passed-in parser didn't move the cursor at all.
+ */
+export declare function failOnEmpty<T extends Returnable>(parser: Parser<T>): Parser<T>;
+/**
+ * @returns A parser that takes an optional syntax component.
+ */
+export declare function optional<N extends Returnable>(parser: InfallibleParser<N>): void;
+export declare function optional<N extends Returnable>(parser: Parser<N>): InfallibleParser<N | undefined>;
+/**
+ * @param parser Must be fallible.
+ *
+ * @returns A parser that returns the return value of the `parser`, or the return value of `defaultValue` it it's a `Failure`.
+ */
+export declare function recover<N extends Returnable>(parser: InfallibleParser<N>, defaultValue: (src: Source, ctx: ParserContext) => N): void;
+export declare function recover<N extends Returnable>(parser: Parser<N>, defaultValue: (src: Source, ctx: ParserContext) => N): InfallibleParser<N>;
+declare type Case = {
+    predicate?: (this: void, src: ReadonlySource) => boolean;
+    parser: Parser<Returnable>;
+};
+/**
+ * @template CA Case array.
+ */
+export declare function select<CA extends readonly Case[]>(cases: CA): Parser<ExtractNodeType<CA[number]['parser']>>;
+/**
+ * @returns A parser that returns the return value of `fn`.
+ *
+ * `Failure` when the `parser` returns a `Failure`.
+ */
+export declare function map<NA extends Returnable, NB extends Returnable = NA>(parser: InfallibleParser<NA>, fn: (res: NA, src: Source, ctx: ParserContext) => NB): InfallibleParser<NB>;
+export declare function map<NA extends Returnable, NB extends Returnable = NA>(parser: Parser<NA>, fn: (res: NA, src: Source, ctx: ParserContext) => NB): Parser<NB>;
+export declare function setType<N extends AstNode, T extends string>(type: T, parser: InfallibleParser<N>): InfallibleParser<Omit<N, 'type'> & {
+    type: T;
+}>;
+export declare function setType<N extends AstNode, T extends string>(type: T, parser: Parser<N>): Parser<Omit<N, 'type'> & {
+    type: T;
+}>;
+/**
+ * Checks if the result of `parser` is valid, and reports an error if it's not.
+ *
+ * `Failure` when the `parser` returns a `Failure`.
+ */
+export declare function validate<N extends AstNode>(parser: InfallibleParser<N>, validator: (res: N, src: Source, ctx: ParserContext) => boolean, message: string, severity?: ErrorSeverity): InfallibleParser<N>;
+export declare function validate<N extends AstNode>(parser: Parser<N>, validator: (res: N, src: Source, ctx: ParserContext) => boolean, message: string, severity?: ErrorSeverity): Parser<N>;
+/**
+ * @returns A parser that is based on the passed-in `parser`, but will never read to any of the terminator strings.
+ */
+export declare function stopBefore<N extends Returnable>(parser: InfallibleParser<N>, ...teminators: (string | readonly string[])[]): InfallibleParser<N>;
+export declare function stopBefore<N extends Returnable>(parser: Parser<N>, ...teminators: (string | readonly string[])[]): Parser<N>;
+/**
+ * @returns A parser that is based on the passed-in `parser`, but will only read the acceptable characters.
+ */
+export declare function acceptOnly<N extends Returnable>(parser: InfallibleParser<N>, ...characters: (string | readonly string[])[]): InfallibleParser<N>;
+export declare function acceptOnly<N extends Returnable>(parser: Parser<N>, ...characters: (string | readonly string[])[]): Parser<N>;
+export {};
+//# sourceMappingURL=util.d.ts.map