@spyglassmc/core 0.1.2 → 0.4.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" | "." | "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: [],
@@ -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,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.
@@ -111,6 +111,7 @@ declare type ExtractFromGettableParser<T extends GettableParser> = T extends {
 declare type Case = {
     predicate?: (this: void, src: ReadonlySource) => boolean;
     prefix?: string;
+    regex?: RegExp;
     parser: GettableParser;
 };
 /**

package/lib/parser/util.js

@@ -1,16 +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(),
-        symbols: ctx.symbols.clone(),
+        err: new ErrorReporter(),
     };
     const result = parser(tmpSrc, tmpCtx);
     return {
@@ -20,17 +16,15 @@ function attempt(parser, src, ctx) {
         updateSrcAndCtx: () => {
             src.innerCursor = tmpSrc.innerCursor;
             ctx.err.absorb(tmpCtx.err);
-            tmpCtx.symbols.applyDelayedEdits();
         },
     };
 }
-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 +35,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 +52,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 +79,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 +98,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 +109,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 +123,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,22 +138,20 @@ 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) {
+        for (const { predicate, prefix, parser, regex } of cases) {
+            if (predicate?.(src) ?? (prefix !== undefined ? src.tryPeek(prefix) : undefined) ?? (regex && src.matchPattern(regex)) ?? true) {
                 const callableParser = typeof parser === 'object' ? parser.get() : parser;
                 return callableParser(src, ctx);
             }
@@ -172,31 +159,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 +189,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 +203,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 +219,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 +234,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,8 +1,9 @@
-import type { AstNode } from '../node';
-import type { ProcessorContext } from '../service';
+import type { DeepReadonly } from '../common/index.js';
+import type { AstNode } from '../node/index.js';
+import type { ProcessorContext } from '../service/index.js';
 export interface InlayHint {
     offset: number;
     text: string;
 }
-export declare type InlayHintProvider<N = AstNode> = (node: N, ctx: ProcessorContext) => readonly InlayHint[];
+export declare type InlayHintProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ProcessorContext) => readonly InlayHint[];
 //# sourceMappingURL=InlayHintProvider.d.ts.map

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,6 @@
-import type { AstNode } from '../node';
-import type { SignatureHelpProviderContext } from '../service';
+import type { DeepReadonly } from '../common/index.js';
+import type { AstNode } from '../node/index.js';
+import type { SignatureHelpProviderContext } from '../service/index.js';
 export interface SignatureHelp {
     signatures: SignatureInfo[];
     activeSignature: number;
@@ -14,5 +15,5 @@ export interface ParameterInfo {
     label: [number, number];
     documentation?: string;
 }
-export declare type SignatureHelpProvider<N = AstNode> = (node: N, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
+export declare type SignatureHelpProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
 //# sourceMappingURL=SignatureHelpProvider.d.ts.map

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/binder/Binder.d.ts

@@ -0,0 +1,26 @@
+import type { AstNode } from '../../node/index.js';
+import type { BinderContext } from '../../service/index.js';
+declare const IsAsync: unique symbol;
+export declare type Binder<N extends AstNode> = SyncBinder<N> | AsyncBinder<N>;
+export interface SyncBinderInitializer<N extends AstNode> {
+    (node: N, ctx: BinderContext): void;
+}
+export interface SyncBinder<N extends AstNode> extends SyncBinderInitializer<N> {
+    [IsAsync]?: never;
+}
+export declare const SyncBinder: Readonly<{
+    create<N extends AstNode>(binder: SyncBinderInitializer<N>): SyncBinder<N>;
+    is(binder: Binder<any>): binder is SyncBinder<any>;
+}>;
+interface AsyncBinderInitializer<N extends AstNode> {
+    (node: N, ctx: BinderContext): Promise<void>;
+}
+export interface AsyncBinder<N extends AstNode> extends AsyncBinderInitializer<N> {
+    [IsAsync]: true;
+}
+export declare const AsyncBinder: Readonly<{
+    create<N extends AstNode>(binder: AsyncBinderInitializer<N>): AsyncBinder<N>;
+    is(binder: Binder<any>): binder is AsyncBinder<any>;
+}>;
+export {};
+//# sourceMappingURL=Binder.d.ts.map

package/lib/processor/binder/Binder.js

@@ -0,0 +1,18 @@
+const IsAsync = Symbol('IsAsyncBinder');
+export const SyncBinder = Object.freeze({
+    create(binder) {
+        return binder;
+    },
+    is(binder) {
+        return !binder[IsAsync];
+    },
+});
+export const AsyncBinder = Object.freeze({
+    create(binder) {
+        return Object.assign(binder, { [IsAsync]: true });
+    },
+    is(binder) {
+        return binder[IsAsync];
+    },
+});
+//# sourceMappingURL=Binder.js.map