@spyglassmc/core 0.1.0 → 0.2.0

package/lib/parser/string.d.ts

@@ -1,16 +1,16 @@
-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';
+import type { StringNode, StringOptions } from '../node/index.js';
+import type { InfallibleParser } from '../parser/index.js';
+import type { ParserContext } from '../service/index.js';
+import type { IndexMap } from '../source/index.js';
+import type { Parser, Result, Returnable } from './Parser.js';
 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 BrigadierUnquotableCharacterSet: Set<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | "o" | "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 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">;
+    allowList: Set<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "k" | "l" | "m" | "n" | "o" | "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 BrigadierStringOptions: StringOptions;
 export declare const brigadierString: InfallibleParser<StringNode>;

package/lib/parser/string.js

@@ -1,16 +1,13 @@
-"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) {
+import { localeQuote, localize } from '@spyglassmc/locales';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { EscapeChar, EscapeTable } from '../node/index.js';
+import { Range, Source } from '../source/index.js';
+import { Failure } from './Parser.js';
+export function string(options) {
     return (src, ctx) => {
         const ans = {
             type: 'string',
-            range: source_1.Range.create(src),
+            range: Range.create(src),
             options,
             value: '',
             valueMap: [],
@@ -20,56 +17,58 @@ function string(options) {
             const currentQuote = src.read();
             const contentStart = src.cursor;
             while (src.canRead() && src.peek() !== currentQuote) {
-                const cStart = src.cursor;
-                const c = src.read();
+                const c = src.peek();
                 if (options.escapable && c === '\\') {
+                    const cStart = src.cursor;
+                    src.skip();
                     const c2 = src.read();
-                    if (c2 === '\\' || c2 === currentQuote || node_1.EscapeChar.is(options.escapable.characters, c2)) {
+                    if (c2 === '\\' || c2 === currentQuote || 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),
+                            inner: Range.create(ans.value.length, ans.value.length + 1),
+                            outer: Range.create(cStart, src),
                         });
-                        ans.value += node_1.EscapeTable.get(c2);
+                        ans.value += 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),
+                                inner: Range.create(ans.value.length, ans.value.length + 1),
+                                outer: 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));
+                            ctx.err.report(localize('parser.string.illegal-unicode-escape'), 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),
+                                inner: Range.create(ans.value.length, ans.value.length + 1),
+                                outer: 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));
+                            ctx.err.report(localize('parser.string.illegal-escape', 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),
+                            inner: Range.create(ans.value.length, ans.value.length + 1),
+                            outer: Range.create(cStart, src),
                         });
                         ans.value += c2;
                     }
                 }
                 else {
+                    src.skip();
                     ans.value += c;
                 }
             }
             if (!src.trySkip(currentQuote)) {
-                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(currentQuote)), src);
+                ctx.err.report(localize('expected', localeQuote(currentQuote)), src);
             }
             if (!options.quotes.includes(currentQuote)) {
-                ctx.err.report((0, locales_1.localize)('parser.string.illegal-quote', options.quotes), ans);
+                ctx.err.report(localize('parser.string.illegal-quote', options.quotes), ans);
             }
             start = contentStart;
         }
@@ -78,17 +77,17 @@ function string(options) {
                 ans.value += src.read();
             }
             if (!ans.value && !options.unquotable.allowEmpty) {
-                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('string')), src);
+                ctx.err.report(localize('expected', localize('string')), src);
             }
         }
         else {
-            ctx.err.report((0, locales_1.localize)('expected', options.quotes), src);
+            ctx.err.report(localize('expected', options.quotes), src);
         }
-        ans.valueMap.unshift({ inner: source_1.Range.create(0), outer: source_1.Range.create(start) });
+        ans.valueMap.unshift({ inner: Range.create(0), outer: 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) {
+            if (valueResult !== Failure) {
                 ans.children = [valueResult];
             }
         }
@@ -96,34 +95,31 @@ function string(options) {
         return ans;
     };
 }
-exports.string = string;
-function parseStringValue(parser, value, map, ctx) {
-    const valueSrc = new source_1.Source(value, map);
+export function parseStringValue(parser, value, map, ctx) {
+    const valueSrc = new Source(value, map);
     const valueCtx = {
         ...ctx,
-        doc: vscode_languageserver_textdocument_1.TextDocument.create(ctx.doc.uri, ctx.doc.languageId, ctx.doc.version, value),
+        doc: 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([
+export const 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 = {
+export const BrigadierUnquotableCharacterSet = new Set(BrigadierUnquotableCharacters);
+export const BrigadierUnquotablePattern = /^[0-9A-Za-z_\.\+\-]*$/;
+export const BrigadierUnquotableOption = { allowEmpty: true, allowList: BrigadierUnquotableCharacterSet };
+export const BrigadierStringOptions = {
     escapable: {},
     quotes: ['"', "'"],
-    unquotable: exports.BrigadierUnquotableOption,
+    unquotable: BrigadierUnquotableOption,
 };
-exports.brigadierString = string(exports.BrigadierStringOptions);
-function isAllowedCharacter(c, options) {
+export const brigadierString = string(BrigadierStringOptions);
+export 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

@@ -1,6 +1,6 @@
-import type { SymbolNode, SymbolOptions } from '../node/SymbolNode';
-import type { AllCategory } from '../symbol';
-import type { InfallibleParser } from './Parser';
+import type { SymbolNode, SymbolOptions } from '../node/SymbolNode.js';
+import type { AllCategory } from '../symbol/index.js';
+import type { InfallibleParser } from './Parser.js';
 /**
  * This parser reads _everything_ until the end of the {@link Source}.
  *

package/lib/parser/symbol.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbol = void 0;
-const source_1 = require("../source");
-function symbol(param) {
+import { Range } from '../source/index.js';
+export function symbol(param) {
     const options = getOptions(param);
     return (src, ctx) => {
         const ans = {
             type: 'symbol',
-            range: source_1.Range.create(src),
+            range: Range.create(src),
             options,
             value: src.readRemaining(),
         };
@@ -21,7 +18,6 @@ function symbol(param) {
         return ans;
     };
 }
-exports.symbol = symbol;
 function getOptions(param) {
     if (typeof param === 'string') {
         return { category: param };

package/lib/parser/util.d.ts

@@ -1,8 +1,8 @@
-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';
+import type { AstNode } from '../node/index.js';
+import { SequenceUtil } from '../node/index.js';
+import type { ParserContext } from '../service/index.js';
+import type { ErrorSeverity, ReadonlySource, Source } from '../source/index.js';
+import type { InfallibleParser, Parser, Result, Returnable } from './Parser.js';
 declare type ExtractNodeType<P extends Parser<Returnable>> = P extends Parser<infer V> ? V : never;
 /**
  * @template PA Parser array.
@@ -57,7 +57,9 @@ export declare function sequence<GN extends AstNode = never, PA extends SP<AstNo
  *
  * @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: InfallibleParser<CN | SequenceUtil<CN>>, parseGap?: InfallibleParser<CN[]>): {
+    _inputParserIsInfallible: never;
+} & void;
 export declare function repeat<CN extends AstNode>(parser: Parser<CN | SequenceUtil<CN>>, parseGap?: InfallibleParser<CN[]>): InfallibleParser<SequenceUtil<CN>>;
 export interface AnyOutObject {
     /**
@@ -80,26 +82,41 @@ export declare function any<PA extends Parser<Returnable>[]>(parsers: PA, out?:
  * @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 fails when the passed-in parser produced any errors.
+ */
+export declare function failOnError<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: InfallibleParser<N>): {
+    _inputParserIsInfallible: never;
+} & 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: InfallibleParser<N>, defaultValue: (src: Source, ctx: ParserContext) => N): {
+    _inputParserIsInfallible: never;
+} & void;
 export declare function recover<N extends Returnable>(parser: Parser<N>, defaultValue: (src: Source, ctx: ParserContext) => N): InfallibleParser<N>;
+declare type GettableParser = Parser<Returnable> | {
+    get: () => Parser<Returnable>;
+};
+declare type ExtractFromGettableParser<T extends GettableParser> = T extends {
+    get: () => infer V;
+} ? V : T extends Parser<Returnable> ? T : never;
 declare type Case = {
     predicate?: (this: void, src: ReadonlySource) => boolean;
-    parser: Parser<Returnable>;
+    prefix?: string;
+    parser: GettableParser;
 };
 /**
  * @template CA Case array.
  */
-export declare function select<CA extends readonly Case[]>(cases: CA): Parser<ExtractNodeType<CA[number]['parser']>>;
+export declare function select<CA extends readonly Case[]>(cases: CA): ExtractFromGettableParser<CA[number]['parser']> extends InfallibleParser<Returnable> ? InfallibleParser<ExtractNodeType<ExtractFromGettableParser<CA[number]['parser']>>> : Parser<ExtractNodeType<ExtractFromGettableParser<CA[number]['parser']>>>;
 /**
  * @returns A parser that returns the return value of `fn`.
  *
@@ -107,10 +124,10 @@ export declare function select<CA extends readonly Case[]>(cases: CA): Parser<Ex
  */
 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'> & {
+export declare function setType<N extends Omit<AstNode, 'type'>, 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'> & {
+export declare function setType<N extends Omit<AstNode, 'type'>, T extends string>(type: T, parser: Parser<N>): Parser<Omit<N, 'type'> & {
     type: T;
 }>;
 /**
@@ -130,5 +147,6 @@ export declare function stopBefore<N extends Returnable>(parser: Parser<N>, ...t
  */
 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 declare function acceptIf<P extends Parser<AstNode>>(parser: P, predicate: (this: void, char: string) => boolean): P extends InfallibleParser<infer N> ? InfallibleParser<N> : P extends Parser<infer N> ? Parser<N> : never;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/lib/parser/util.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.acceptOnly = exports.stopBefore = exports.validate = exports.setType = exports.map = exports.select = exports.recover = exports.optional = exports.failOnEmpty = exports.any = exports.repeat = exports.sequence = exports.attempt = void 0;
-const node_1 = require("../node");
-const service_1 = require("../service");
-const source_1 = require("../source");
-const Parser_1 = require("./Parser");
-function attempt(parser, src, ctx) {
+import { SequenceUtil, SequenceUtilDiscriminator } from '../node/index.js';
+import { ErrorReporter } from '../service/index.js';
+import { Range } from '../source/index.js';
+import { Failure } from './Parser.js';
+export function attempt(parser, src, ctx) {
     const tmpSrc = src.clone();
     const tmpCtx = {
         ...ctx,
-        err: new service_1.ErrorReporter(),
+        err: new ErrorReporter(),
         symbols: ctx.symbols.clone(),
     };
     const result = parser(tmpSrc, tmpCtx);
@@ -24,13 +21,12 @@ function attempt(parser, src, ctx) {
         },
     };
 }
-exports.attempt = attempt;
-function sequence(parsers, parseGap) {
+export function sequence(parsers, parseGap) {
     return (src, ctx) => {
         const ans = {
-            isSequenceUtil: true,
+            [SequenceUtilDiscriminator]: true,
             children: [],
-            range: source_1.Range.create(src),
+            range: Range.create(src),
         };
         for (const [i, p] of parsers.entries()) {
             const parser = typeof p === 'function' ? p : p.get(ans);
@@ -41,13 +37,13 @@ function sequence(parsers, parseGap) {
                 ans.children.push(...parseGap(src, ctx));
             }
             const result = parser(src, ctx);
-            if (result === Parser_1.Failure) {
-                return Parser_1.Failure;
+            if (result === Failure) {
+                return Failure;
             }
             else if (result === undefined) {
                 continue;
             }
-            else if (node_1.SequenceUtil.is(result)) {
+            else if (SequenceUtil.is(result)) {
                 ans.children.push(...result.children);
             }
             else {
@@ -58,24 +54,23 @@ function sequence(parsers, parseGap) {
         return ans;
     };
 }
-exports.sequence = sequence;
-function repeat(parser, parseGap) {
+export function repeat(parser, parseGap) {
     return (src, ctx) => {
         const ans = {
-            isSequenceUtil: true,
+            [SequenceUtilDiscriminator]: true,
             children: [],
-            range: source_1.Range.create(src),
+            range: Range.create(src),
         };
         while (src.canRead()) {
             if (parseGap) {
                 ans.children.push(...parseGap(src, ctx));
             }
             const { result, updateSrcAndCtx } = attempt(parser, src, ctx);
-            if (result === Parser_1.Failure) {
+            if (result === Failure) {
                 break;
             }
             updateSrcAndCtx();
-            if (node_1.SequenceUtil.is(result)) {
+            if (SequenceUtil.is(result)) {
                 ans.children.push(...result.children);
             }
             else {
@@ -86,18 +81,17 @@ function repeat(parser, parseGap) {
         return ans;
     };
 }
-exports.repeat = repeat;
-function any(parsers, out) {
+export function any(parsers, out) {
     return (src, ctx) => {
         const results = parsers
             .map((parser, i) => ({ attempt: attempt(parser, src, ctx), index: i }))
-            .filter(({ attempt }) => attempt.result !== Parser_1.Failure)
+            .filter(({ attempt }) => attempt.result !== Failure)
             .sort((a, b) => (b.attempt.endCursor - a.attempt.endCursor) || (a.attempt.errorAmount - b.attempt.errorAmount));
         if (results.length === 0) {
             if (out) {
                 out.index = -1;
             }
-            return Parser_1.Failure;
+            return Failure;
         }
         results[0].attempt.updateSrcAndCtx();
         if (out) {
@@ -106,11 +100,10 @@ function any(parsers, out) {
         return results[0].attempt.result;
     };
 }
-exports.any = any;
 /**
  * @returns A parser that fails when the passed-in parser didn't move the cursor at all.
  */
-function failOnEmpty(parser) {
+export function failOnEmpty(parser) {
     return (src, ctx) => {
         const start = src.cursor;
         const { endCursor, updateSrcAndCtx, result } = attempt(parser, src, ctx);
@@ -118,68 +111,78 @@ function failOnEmpty(parser) {
             updateSrcAndCtx();
             return result;
         }
-        return Parser_1.Failure;
+        return Failure;
     };
 }
-exports.failOnEmpty = failOnEmpty;
-function optional(parser) {
-    // return any<N | undefined>([
-    // 	parser,
-    // 	empty,
-    // ])
+/**
+ * @returns A parser that fails when the passed-in parser produced any errors.
+ */
+export function failOnError(parser) {
     return (src, ctx) => {
+        const start = src.cursor;
+        const { errorAmount, updateSrcAndCtx, result } = attempt(parser, src, ctx);
+        if (!errorAmount) {
+            updateSrcAndCtx();
+            return result;
+        }
+        return Failure;
+    };
+}
+export function optional(parser) {
+    return ((src, ctx) => {
         const { result, updateSrcAndCtx } = attempt(parser, src, ctx);
-        if (result === Parser_1.Failure) {
+        if (result === Failure) {
             return undefined;
         }
         else {
             updateSrcAndCtx();
             return result;
         }
-    };
+    });
 }
-exports.optional = optional;
-function recover(parser, defaultValue) {
+export function recover(parser, defaultValue) {
     return (src, ctx) => {
         const result = parser(src, ctx);
-        if (result === Parser_1.Failure) {
+        if (result === Failure) {
             const ans = defaultValue(src, ctx);
             return ans;
         }
         return result;
     };
 }
-exports.recover = recover;
-function select(cases) {
+export function select(cases) {
     return (src, ctx) => {
-        for (const { predicate, parser } of cases) {
-            if (predicate?.(src) ?? true) {
-                return parser(src, ctx);
+        for (const { predicate, prefix, parser } of cases) {
+            if (predicate?.(src) ?? (prefix !== undefined ? src.tryPeek(prefix) : undefined) ?? true) {
+                const callableParser = typeof parser === 'object' ? parser.get() : parser;
+                return callableParser(src, ctx);
             }
         }
-        return Parser_1.Failure;
+        throw new Error('The select parser util was called with non-exhaustive cases');
     };
 }
-exports.select = select;
-function map(parser, fn) {
+export function map(parser, fn) {
     return (src, ctx) => {
         const result = parser(src, ctx);
-        if (result === Parser_1.Failure) {
-            return Parser_1.Failure;
+        if (result === Failure) {
+            return Failure;
         }
         const ans = fn(result, src, ctx);
         return ans;
     };
 }
-exports.map = map;
-function setType(type, parser) {
-    return map(parser, res => ({
-        ...res,
-        type,
-    }));
+export function setType(type, parser) {
+    return map(parser, res => {
+        const { type: _type, ...restResult } = res;
+        const ans = {
+            type,
+            ...restResult,
+        };
+        delete ans[SequenceUtilDiscriminator];
+        return ans;
+    });
 }
-exports.setType = setType;
-function validate(parser, validator, message, severity) {
+export function validate(parser, validator, message, severity) {
     return map(parser, (res, src, ctx) => {
         const isLegal = validator(res, src, ctx);
         if (!isLegal) {
@@ -188,8 +191,7 @@ function validate(parser, validator, message, severity) {
         return res;
     });
 }
-exports.validate = validate;
-function stopBefore(parser, ...teminators) {
+export function stopBefore(parser, ...teminators) {
     const flatTerminators = teminators.flat();
     return (src, ctx) => {
         const tmpSrc = src.clone();
@@ -203,8 +205,7 @@ function stopBefore(parser, ...teminators) {
         return ans;
     };
 }
-exports.stopBefore = stopBefore;
-function acceptOnly(parser, ...characters) {
+export function acceptOnly(parser, ...characters) {
     const set = new Set(characters.flat());
     return (src, ctx) => {
         const tmpSrc = src.clone();
@@ -220,5 +221,19 @@ function acceptOnly(parser, ...characters) {
         return ans;
     };
 }
-exports.acceptOnly = acceptOnly;
+export function acceptIf(parser, predicate) {
+    return ((src, ctx) => {
+        const tmpSrc = src.clone();
+        // Cut tmpSrc.string before the nearest unacceptable character.
+        for (let i = tmpSrc.innerCursor; i < tmpSrc.string.length; i++) {
+            if (!predicate(tmpSrc.string.charAt(i))) {
+                tmpSrc.string = tmpSrc.string.slice(0, i);
+                break;
+            }
+        }
+        const ans = parser(tmpSrc, ctx);
+        src.innerCursor = tmpSrc.innerCursor;
+        return ans;
+    });
+}
 //# sourceMappingURL=util.js.map

package/lib/processor/ColorInfoProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Range } from '../source';
+import type { Range } from '../source/index.js';
 export interface ColorInfo {
     range: Range;
     color: Color;

package/lib/processor/ColorInfoProvider.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColorPresentation = exports.ColorFormat = exports.Color = void 0;
-var Color;
+export var Color;
 (function (Color) {
     Color.NamedColors = new Map([
         ['aqua', 0x55ffff],
@@ -75,8 +72,8 @@ var Color;
         return fromIntRGB(r, g, b);
     }
     Color.fromCompositeInt = fromCompositeInt;
-})(Color = exports.Color || (exports.Color = {}));
-var ColorFormat;
+})(Color || (Color = {}));
+export var ColorFormat;
 (function (ColorFormat) {
     /**
      * `1 0.6 0.2 1.0`
@@ -106,8 +103,8 @@ var ColorFormat;
      * `16620441`
      */
     ColorFormat[ColorFormat["CompositeInt"] = 6] = "CompositeInt";
-})(ColorFormat = exports.ColorFormat || (exports.ColorFormat = {}));
-var ColorPresentation;
+})(ColorFormat || (ColorFormat = {}));
+export var ColorPresentation;
 (function (ColorPresentation) {
     function fromColorFormat(format, color, range) {
         const presentation = colorPresentation(format, color);
@@ -137,5 +134,5 @@ var ColorPresentation;
                 return `${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255)}`;
         }
     }
-})(ColorPresentation = exports.ColorPresentation || (exports.ColorPresentation = {}));
+})(ColorPresentation || (ColorPresentation = {}));
 //# sourceMappingURL=ColorInfoProvider.js.map