@spyglassmc/core 0.1.1 → 0.3.0

package/lib/parser/resourceLocation.js

@@ -1,23 +1,20 @@
-"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");
+import { arrayToMessage, localize } from '@spyglassmc/locales';
+import { ResourceLocation } from '../common/index.js';
+import { Range } from '../source/index.js';
 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) {
+export function resourceLocation(options) {
     return (src, ctx) => {
         const ans = {
             type: 'resource_location',
-            range: source_1.Range.create(src),
+            range: Range.create(src),
             options,
         };
-        if (src.trySkip(common_1.ResourceLocation.TagPrefix)) {
+        if (src.trySkip(ResourceLocation.TagPrefix)) {
             ans.isTag = true;
         }
         const start = src.cursor;
@@ -27,15 +24,15 @@ function resourceLocation(options) {
         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);
+            ctx.err.report(localize('expected', localize('resource-location')), ans);
         }
         else {
-            const sepIndex = raw.indexOf(options.namespacePathSep ?? common_1.ResourceLocation.NamespacePathSep);
+            const sepIndex = raw.indexOf(options.namespacePathSep ?? 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);
+            ans.path = rawPath.split(ResourceLocation.PathSep);
             // Check characters.
             /* istanbul ignore next */
             const illegalChars = [...new Set([
@@ -43,25 +40,16 @@ function resourceLocation(options) {
                     ...[...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);
+                ctx.err.report(localize('parser.resource-location.illegal', arrayToMessage(illegalChars, true, 'and')), ans);
             }
             if (ans.isTag && !options.allowTag) {
-                ctx.err.report((0, locales_1.localize)('parser.resource-location.tag-diallowed'), ans);
+                ctx.err.report(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 } });
+                ctx.err.report(localize('parser.resource-location.namespace-expected'), ans);
             }
         }
         return ans;
     };
 }
-exports.resourceLocation = resourceLocation;
 //# sourceMappingURL=resourceLocation.js.map

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" | "." | "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 BrigadierUnquotableCharacterSet: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "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" | "." | "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">;
+    allowList: Set<"0" | "k" | "v" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "i" | "p" | "-" | "+" | "e" | "a" | "b" | "c" | "d" | "f" | "g" | "h" | "j" | "l" | "m" | "n" | "o" | "q" | "r" | "s" | "t" | "u" | "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,27 +1,17 @@
-"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) => {
+    return (src, _ctx) => {
         const ans = {
             type: 'symbol',
-            range: source_1.Range.create(src),
+            range: 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 };

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