@spyglassmc/core 0.1.2 → 0.2.0

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: [],
@@ -25,39 +22,39 @@ function string(options) {
                     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;
                     }
@@ -68,10 +65,10 @@ function string(options) {
                 }
             }
             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;
         }
@@ -80,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];
             }
         }
@@ -98,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.

package/lib/parser/util.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.acceptIf = exports.acceptOnly = exports.stopBefore = exports.validate = exports.setType = exports.map = exports.select = exports.recover = exports.optional = exports.failOnError = 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 = {
-            [node_1.SequenceUtilDiscriminator]: 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 = {
-            [node_1.SequenceUtilDiscriminator]: 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,14 +111,13 @@ function failOnEmpty(parser) {
             updateSrcAndCtx();
             return result;
         }
-        return Parser_1.Failure;
+        return Failure;
     };
 }
-exports.failOnEmpty = failOnEmpty;
 /**
  * @returns A parser that fails when the passed-in parser produced any errors.
  */
-function failOnError(parser) {
+export function failOnError(parser) {
     return (src, ctx) => {
         const start = src.cursor;
         const { errorAmount, updateSrcAndCtx, result } = attempt(parser, src, ctx);
@@ -133,14 +125,13 @@ function failOnError(parser) {
             updateSrcAndCtx();
             return result;
         }
-        return Parser_1.Failure;
+        return Failure;
     };
 }
-exports.failOnError = failOnError;
-function optional(parser) {
+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 {
@@ -149,19 +140,17 @@ function optional(parser) {
         }
     });
 }
-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, prefix, parser } of cases) {
             if (predicate?.(src) ?? (prefix !== undefined ? src.tryPeek(prefix) : undefined) ?? true) {
@@ -172,31 +161,28 @@ function select(cases) {
         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) {
+export function setType(type, parser) {
     return map(parser, res => {
         const { type: _type, ...restResult } = res;
         const ans = {
             type,
             ...restResult,
         };
-        delete ans[node_1.SequenceUtilDiscriminator];
+        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) {
@@ -205,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();
@@ -220,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();
@@ -237,8 +221,7 @@ function acceptOnly(parser, ...characters) {
         return ans;
     };
 }
-exports.acceptOnly = acceptOnly;
-function acceptIf(parser, predicate) {
+export function acceptIf(parser, predicate) {
     return ((src, ctx) => {
         const tmpSrc = src.clone();
         // Cut tmpSrc.string before the nearest unacceptable character.
@@ -253,5 +236,4 @@ function acceptIf(parser, predicate) {
         return ans;
     });
 }
-exports.acceptIf = acceptIf;
 //# 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

package/lib/processor/InlayHintProvider.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode } from '../node';
-import type { ProcessorContext } from '../service';
+import type { AstNode } from '../node/index.js';
+import type { ProcessorContext } from '../service/index.js';
 export interface InlayHint {
     offset: number;
     text: string;

package/lib/processor/InlayHintProvider.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=InlayHintProvider.js.map

package/lib/processor/SignatureHelpProvider.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode } from '../node';
-import type { SignatureHelpProviderContext } from '../service';
+import type { AstNode } from '../node/index.js';
+import type { SignatureHelpProviderContext } from '../service/index.js';
 export interface SignatureHelp {
     signatures: SignatureInfo[];
     activeSignature: number;

package/lib/processor/SignatureHelpProvider.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=SignatureHelpProvider.js.map

package/lib/processor/checker/Checker.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode } from '../../node';
-import type { CheckerContext } from '../../service';
+import type { AstNode } from '../../node/index.js';
+import type { CheckerContext } from '../../service/index.js';
 export declare type Checker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void> | void;
 export declare type SyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => void;
 export declare type AsyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void>;

package/lib/processor/checker/Checker.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbackChecker = void 0;
 /* istanbul ignore next */
-const FallbackChecker = () => Promise.resolve();
-exports.FallbackChecker = FallbackChecker;
+export const FallbackChecker = () => Promise.resolve();
 //# sourceMappingURL=Checker.js.map

package/lib/processor/checker/builtin.d.ts

@@ -1,7 +1,7 @@
-import type { AstNode, SymbolBaseNode } from '../../node';
-import { ResourceLocationNode } from '../../node';
-import type { CheckerContext, MetaRegistry } from '../../service';
-import type { Checker, SyncChecker } from './Checker';
+import type { AstNode, SymbolBaseNode } from '../../node/index.js';
+import { ResourceLocationNode } from '../../node/index.js';
+import type { CheckerContext, MetaRegistry } from '../../service/index.js';
+import type { Checker, SyncChecker } from './Checker.js';
 export declare type AttemptResult = {
     errorAmount: number;
     totalErrorSpan: number;