@spyglassmc/core 0.4.0 → 0.4.2

package/lib/parser/float.d.ts

@@ -26,7 +26,7 @@ interface InfallibleOptions extends OptionsBase {
     failsOnEmpty?: false;
 }
 /** @internal For test only */
-export declare type Options = FallibleOptions | InfallibleOptions;
+export type Options = FallibleOptions | InfallibleOptions;
 export declare function float(options: InfallibleOptions): InfallibleParser<FloatNode>;
 export declare function float(options: FallibleOptions): Parser<FloatNode>;
 export {};

package/lib/parser/float.js

@@ -43,7 +43,8 @@ export function float(options) {
         else if (!options.pattern.test(raw)) {
             ctx.err.report(localize('parser.float.illegal', options.pattern), ans);
         }
-        else if ((options.min && ans.value < options.min) || (options.max && ans.value > options.max)) {
+        else if ((options.min && ans.value < options.min) ||
+            (options.max && ans.value > options.max)) {
             const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
             onOutOfRange(ans, src, ctx, options);
         }

package/lib/parser/integer.d.ts

@@ -26,7 +26,7 @@ interface InfallibleOptions extends OptionsBase {
     failsOnEmpty?: false;
 }
 /** @internal For test only */
-export declare type Options = FallibleOptions | InfallibleOptions;
+export type Options = FallibleOptions | InfallibleOptions;
 export declare function integer(options: InfallibleOptions): InfallibleParser<IntegerNode>;
 export declare function integer(options: FallibleOptions): Parser<IntegerNode>;
 export {};

package/lib/parser/integer.js

@@ -32,7 +32,8 @@ export function integer(options) {
         else if (!options.pattern.test(raw) || isOnlySign) {
             ctx.err.report(localize('parser.integer.illegal', options.pattern), ans);
         }
-        else if ((options.min !== undefined && ans.value < options.min) || (options.max !== undefined && ans.value > options.max)) {
+        else if ((options.min !== undefined && ans.value < options.min) ||
+            (options.max !== undefined && ans.value > options.max)) {
             const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
             onOutOfRange(ans, src, ctx, options);
         }

package/lib/parser/list.d.ts

@@ -8,5 +8,5 @@ export interface Options<V extends AstNode> {
     trailingSep: boolean;
     end: string;
 }
-export declare function list<V extends AstNode>({ start, value, sep, trailingSep, end }: Options<V>): InfallibleParser<ListNode<V>>;
+export declare function list<V extends AstNode>({ start, value, sep, trailingSep, end, }: Options<V>): InfallibleParser<ListNode<V>>;
 //# sourceMappingURL=list.d.ts.map

package/lib/parser/list.js

@@ -2,7 +2,7 @@ import { localeQuote, localize } from '@spyglassmc/locales';
 import { Range } from '../source/index.js';
 import { Failure } from './Parser.js';
 import { attempt } from './util.js';
-export function list({ start, value, sep, trailingSep, end }) {
+export function list({ start, value, sep, trailingSep, end, }) {
     return (src, ctx) => {
         const ans = {
             type: 'list',
@@ -34,14 +34,14 @@ export function list({ start, value, sep, trailingSep, end }) {
                 let sepRange = undefined;
                 src.skipWhitespace();
                 requiresValueSep = true;
-                if (hasValueSep = src.peek(sep.length) === sep) {
+                if ((hasValueSep = src.peek(sep.length) === sep)) {
                     sepRange = Range.create(src, () => src.skip(sep.length));
                 }
                 // Create item.
                 ans.children.push({
                     type: 'item',
                     range: Range.create(itemStart, src),
-                    ...valueNode ? { children: [valueNode] } : {},
+                    ...(valueNode ? { children: [valueNode] } : {}),
                     value: valueNode,
                     sep: sepRange,
                 });

package/lib/parser/long.d.ts

@@ -26,7 +26,7 @@ interface InfallibleOptions extends OptionsBase {
     failsOnEmpty?: false;
 }
 /** @internal For test only */
-export declare type Options = FallibleOptions | InfallibleOptions;
+export type Options = FallibleOptions | InfallibleOptions;
 export declare function long(options: InfallibleOptions): InfallibleParser<LongNode>;
 export declare function long(options: FallibleOptions): Parser<LongNode>;
 export {};

package/lib/parser/long.js

@@ -36,7 +36,8 @@ export function long(options) {
         else if (!options.pattern.test(raw) || isOnlySign) {
             ctx.err.report(localize('parser.long.illegal', options.pattern), ans);
         }
-        else if ((options.min && ans.value < options.min) || (options.max && ans.value > options.max)) {
+        else if ((options.min && ans.value < options.min) ||
+            (options.max && ans.value > options.max)) {
             const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
             onOutOfRange(ans, src, ctx, options);
         }

package/lib/parser/record.d.ts

@@ -18,5 +18,5 @@ export interface Options<K extends AstNode, V extends AstNode> {
 /**
  * @returns A parser that parses something coming in a key-value pair form. e.g. SNBT objects, entity selector arguments.
  */
-export declare function record<K extends AstNode, V extends AstNode>({ start, pair, end }: Options<K, V>): InfallibleParser<RecordNode<K, V>>;
+export declare function record<K extends AstNode, V extends AstNode>({ start, pair, end, }: Options<K, V>): InfallibleParser<RecordNode<K, V>>;
 //# sourceMappingURL=record.d.ts.map

package/lib/parser/record.js

@@ -5,7 +5,7 @@ import { attempt } from './util.js';
 /**
  * @returns A parser that parses something coming in a key-value pair form. e.g. SNBT objects, entity selector arguments.
  */
-export function record({ start, pair, end }) {
+export function record({ start, pair, end, }) {
     return (src, ctx) => {
         const ans = {
             type: 'record',
@@ -26,8 +26,10 @@ export function record({ start, pair, end }) {
                 }
                 // Key.
                 const keyStart = src.cursor;
-                const { result: keyResult, updateSrcAndCtx: updateForKey, endCursor: keyEnd } = attempt(pair.key, src, ctx);
-                if (keyResult === Failure || (keyEnd - keyStart === 0 && ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
+                const { result: keyResult, updateSrcAndCtx: updateForKey, endCursor: keyEnd, } = attempt(pair.key, src, ctx);
+                if (keyResult === Failure ||
+                    (keyEnd - keyStart === 0 &&
+                        ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
                     ctx.err.report(localize('expected', localize('parser.record.key')), Range.create(src, () => src.skipUntilOrEnd(pair.sep, pair.end, end, '\r', '\n')));
                 }
                 else {
@@ -45,10 +47,14 @@ export function record({ start, pair, end }) {
                 }
                 // Value.
                 src.skipWhitespace();
-                const valueParser = typeof pair.value === 'function' ? pair.value : pair.value.get(ans, key);
+                const valueParser = typeof pair.value === 'function'
+                    ? pair.value
+                    : pair.value.get(ans, key);
                 const valueStart = src.cursor;
-                const { result: valueResult, updateSrcAndCtx: updateForValue, endCursor: valueEnd } = attempt(valueParser, src, ctx);
-                if (valueResult === Failure || (valueEnd - valueStart === 0 && ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
+                const { result: valueResult, updateSrcAndCtx: updateForValue, endCursor: valueEnd, } = attempt(valueParser, src, ctx);
+                if (valueResult === Failure ||
+                    (valueEnd - valueStart === 0 &&
+                        ![pair.sep, pair.end, end, '\r', '\n', '\t', ' '].includes(src.peek()))) {
                     ctx.err.report(localize('expected', localize('parser.record.value')), Range.create(src, () => src.skipUntilOrEnd(pair.sep, pair.end, end, '\r', '\n')));
                 }
                 else {
@@ -59,14 +65,18 @@ export function record({ start, pair, end }) {
                 let endCharRange = undefined;
                 src.skipWhitespace();
                 requiresPairEnd = true;
-                if (hasPairEnd = src.peek(pair.end.length) === pair.end) {
+                if ((hasPairEnd = src.peek(pair.end.length) === pair.end)) {
                     endCharRange = Range.create(src, () => src.skip(pair.end.length));
                 }
                 // Create pair.
                 ans.children.push({
                     type: 'pair',
                     range: Range.create(pairStart, src),
-                    ...(key || value) ? { children: [key, value].filter(v => !!v) } : {},
+                    ...(key || value
+                        ? {
+                            children: [key, value].filter((v) => !!v),
+                        }
+                        : {}),
                     key,
                     sep: sepCharRange,
                     value,

package/lib/parser/resourceLocation.js

@@ -1,11 +1,62 @@
 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 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', '_', '-', '.',
+    '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',
+    '_',
+    '-',
+    '.',
 ]);
 export function resourceLocation(options) {
     return (src, ctx) => {
@@ -35,10 +86,12 @@ export function resourceLocation(options) {
             ans.path = rawPath.split(ResourceLocation.PathSep);
             // Check characters.
             /* istanbul ignore next */
-            const illegalChars = [...new Set([
-                    ...[...ans.namespace ?? []].filter(c => !LegalCharacters.has(c)),
-                    ...[...rawPath].filter(c => c !== '/' && !LegalCharacters.has(c)),
-                ])];
+            const illegalChars = [
+                ...new Set([
+                    ...[...(ans.namespace ?? [])].filter((c) => !LegalCharacters.has(c)),
+                    ...[...rawPath].filter((c) => c !== '/' && !LegalCharacters.has(c)),
+                ]),
+            ];
             if (illegalChars.length) {
                 ctx.err.report(localize('parser.resource-location.illegal', arrayToMessage(illegalChars, true, 'and')), ans);
             }

package/lib/parser/string.js

@@ -22,7 +22,9 @@ export function string(options) {
                     const cStart = src.cursor;
                     src.skip();
                     const c2 = src.read();
-                    if (c2 === '\\' || c2 === currentQuote || EscapeChar.is(options.escapable.characters, c2)) {
+                    if (c2 === '\\' ||
+                        c2 === currentQuote ||
+                        EscapeChar.is(options.escapable.characters, c2)) {
                         ans.valueMap.push({
                             inner: Range.create(ans.value.length, ans.value.length + 1),
                             outer: Range.create(cStart, src),
@@ -73,7 +75,8 @@ export function string(options) {
             start = contentStart;
         }
         else if (options.unquotable) {
-            while (src.canRead() && isAllowedCharacter(src.peek(), options.unquotable)) {
+            while (src.canRead() &&
+                isAllowedCharacter(src.peek(), options.unquotable)) {
                 ans.value += src.read();
             }
             if (!ans.value && !options.unquotable.allowEmpty) {
@@ -83,7 +86,10 @@ export function string(options) {
         else {
             ctx.err.report(localize('expected', options.quotes), src);
         }
-        ans.valueMap.unshift({ inner: Range.create(0), outer: 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 */
@@ -105,14 +111,79 @@ export function parseStringValue(parser, value, map, ctx) {
     return parser(valueSrc, valueCtx);
 }
 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',
-    '_', '.', '+', '-',
+    '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 const BrigadierUnquotableCharacterSet = new Set(BrigadierUnquotableCharacters);
 export const BrigadierUnquotablePattern = /^[0-9A-Za-z_\.\+\-]*$/;
-export const BrigadierUnquotableOption = { allowEmpty: true, allowList: BrigadierUnquotableCharacterSet };
+export const BrigadierUnquotableOption = {
+    allowEmpty: true,
+    allowList: BrigadierUnquotableCharacterSet,
+};
 export const BrigadierStringOptions = {
     escapable: {},
     quotes: ['"', "'"],

package/lib/parser/util.d.ts

@@ -3,11 +3,11 @@ 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;
+type ExtractNodeType<P extends Parser<Returnable>> = P extends Parser<infer V> ? V : never;
 /**
  * @template PA Parser array.
  */
-declare type ExtractNodeTypes<PA extends Parser<Returnable>[]> = ExtractNodeType<PA[number]>;
+type ExtractNodeTypes<PA extends Parser<Returnable>[]> = ExtractNodeType<PA[number]>;
 export interface AttemptResult<N extends Returnable = AstNode> {
     result: Result<N>;
     updateSrcAndCtx: () => void;
@@ -27,10 +27,10 @@ interface InfallibleAttemptResult<N extends Returnable = AstNode> extends Attemp
  */
 export declare function attempt<N extends Returnable = AstNode>(parser: InfallibleParser<N>, src: Source, ctx: ParserContext): InfallibleAttemptResult<N>;
 export declare function attempt<N extends Returnable = AstNode>(parser: Parser<N>, src: Source, ctx: ParserContext): AttemptResult<N>;
-declare type SP<CN extends AstNode> = SIP<CN> | Parser<CN | SequenceUtil<CN> | undefined> | {
+type SP<CN extends AstNode> = SIP<CN> | Parser<CN | SequenceUtil<CN> | undefined> | {
     get: (result: SequenceUtil<CN>) => Parser<CN | SequenceUtil<CN> | undefined> | undefined;
 };
-declare type SIP<CN extends AstNode> = InfallibleParser<CN | SequenceUtil<CN> | undefined> | {
+type SIP<CN extends AstNode> = InfallibleParser<CN | SequenceUtil<CN> | undefined> | {
     get: (result: SequenceUtil<CN>) => InfallibleParser<CN | SequenceUtil<CN> | undefined> | undefined;
 };
 /**
@@ -102,13 +102,13 @@ export declare function recover<N extends Returnable>(parser: InfallibleParser<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> | {
+type GettableParser = Parser<Returnable> | {
     get: () => Parser<Returnable>;
 };
-declare type ExtractFromGettableParser<T extends GettableParser> = T extends {
+type ExtractFromGettableParser<T extends GettableParser> = T extends {
     get: () => infer V;
 } ? V : T extends Parser<Returnable> ? T : never;
-declare type Case = {
+type Case = {
     predicate?: (this: void, src: ReadonlySource) => boolean;
     prefix?: string;
     regex?: RegExp;

package/lib/parser/util.js

@@ -82,9 +82,13 @@ export function repeat(parser, parseGap) {
 export function any(parsers, out) {
     return (src, ctx) => {
         const results = parsers
-            .map((parser, i) => ({ attempt: attempt(parser, src, ctx), index: i }))
+            .map((parser, i) => ({
+            attempt: attempt(parser, src, ctx),
+            index: i,
+        }))
             .filter(({ attempt }) => attempt.result !== Failure)
-            .sort((a, b) => (b.attempt.endCursor - a.attempt.endCursor) || (a.attempt.errorAmount - b.attempt.errorAmount));
+            .sort((a, b) => b.attempt.endCursor - a.attempt.endCursor ||
+            a.attempt.errorAmount - b.attempt.errorAmount);
         if (results.length === 0) {
             if (out) {
                 out.index = -1;
@@ -151,8 +155,13 @@ export function recover(parser, defaultValue) {
 export function select(cases) {
     return (src, ctx) => {
         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;
+            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);
             }
         }
@@ -170,7 +179,7 @@ export function map(parser, fn) {
     };
 }
 export function setType(type, parser) {
-    return map(parser, res => {
+    return map(parser, (res) => {
         const { type: _type, ...restResult } = res;
         const ans = {
             type,

package/lib/processor/ColorInfoProvider.d.ts

@@ -6,7 +6,7 @@ export interface ColorInfo {
 /**
  * An array of four decimal numbers within the interval [0, 1] that represent R, G, B, and A respectively.
  */
-export declare type Color = [number, number, number, number];
+export type Color = [number, number, number, number];
 export declare namespace Color {
     const NamedColors: Map<string, number>;
     const ColorNames: string[];
@@ -71,12 +71,12 @@ export declare enum ColorFormat {
      */
     CompositeInt = 6
 }
-export declare type FormattableColor = {
+export type FormattableColor = {
     value: Color;
     format: ColorFormat[];
     range?: Range;
 };
-export declare type ColorPresentation = {
+export type ColorPresentation = {
     label: string;
     text: string;
     range: Range;

package/lib/processor/ColorInfoProvider.js

@@ -119,19 +119,34 @@ export var ColorPresentation;
         const round = (num) => parseFloat(num.toFixed(3));
         switch (format) {
             case ColorFormat.DecRGBA:
-                return color.map(c => round(c)).join(' ');
+                return color.map((c) => round(c)).join(' ');
             case ColorFormat.DecRGB:
-                return color.slice(0, 3).map(c => round(c)).join(' ');
+                return color
+                    .slice(0, 3)
+                    .map((c) => round(c))
+                    .join(' ');
             case ColorFormat.IntRGBA:
-                return color.map(c => Math.round(c * 255)).join(' ');
+                return color.map((c) => Math.round(c * 255)).join(' ');
             case ColorFormat.IntRGB:
-                return color.slice(0, 3).map(c => Math.round(c * 255)).join(' ');
+                return color
+                    .slice(0, 3)
+                    .map((c) => Math.round(c * 255))
+                    .join(' ');
             case ColorFormat.HexRGBA:
-                return `#${Math.round((color[0] * 255 << 24) + (color[1] * 255 << 16) + (color[2] * 255) << 8 + color[3] * 255).toString(16).padStart(8, '0')}`;
+                return `#${Math.round((((color[0] * 255) << 24) +
+                    ((color[1] * 255) << 16) +
+                    color[2] * 255) <<
+                    (8 + color[3] * 255))
+                    .toString(16)
+                    .padStart(8, '0')}`;
             case ColorFormat.HexRGB:
-                return `#${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255).toString(16).padStart(6, '0')}`;
+                return `#${Math.round(((color[0] * 255) << 16) + ((color[1] * 255) << 8) +
+                    color[2] * 255)
+                    .toString(16)
+                    .padStart(6, '0')}`;
             case ColorFormat.CompositeInt:
-                return `${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255)}`;
+                return `${Math.round(((color[0] * 255) << 16) + ((color[1] * 255) << 8) +
+                    color[2] * 255)}`;
         }
     }
 })(ColorPresentation || (ColorPresentation = {}));

package/lib/processor/InlayHintProvider.d.ts

@@ -5,5 +5,5 @@ export interface InlayHint {
     offset: number;
     text: string;
 }
-export declare type InlayHintProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ProcessorContext) => readonly InlayHint[];
+export type InlayHintProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ProcessorContext) => readonly InlayHint[];
 //# sourceMappingURL=InlayHintProvider.d.ts.map

package/lib/processor/SignatureHelpProvider.d.ts

@@ -15,5 +15,5 @@ export interface ParameterInfo {
     label: [number, number];
     documentation?: string;
 }
-export declare type SignatureHelpProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
+export type SignatureHelpProvider<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: SignatureHelpProviderContext) => SignatureHelp | undefined;
 //# sourceMappingURL=SignatureHelpProvider.d.ts.map

package/lib/processor/binder/Binder.d.ts

@@ -1,7 +1,7 @@
 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 type Binder<N extends AstNode> = SyncBinder<N> | AsyncBinder<N>;
 export interface SyncBinderInitializer<N extends AstNode> {
     (node: N, ctx: BinderContext): void;
 }

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

@@ -3,13 +3,13 @@ import { ResourceLocationNode } from '../../node/index.js';
 import type { BinderContext, MetaRegistry } from '../../service/index.js';
 import type { Binder } from './Binder.js';
 import { AsyncBinder, SyncBinder } from './Binder.js';
-export declare type AttemptResult = {
+export type AttemptResult = {
     errorAmount: number;
     totalErrorSpan: number;
     updateNodeAndCtx: () => void;
 };
 export declare function attempt<B extends Binder<never>>(binder: B, node: B extends Binder<infer N extends AstNode> ? N : never, ctx: BinderContext): B extends SyncBinder<any> ? AttemptResult : Promise<AttemptResult>;
-declare type ExtractBinder<B extends Binder<never>> = B extends Binder<infer N extends AstNode> ? N : never;
+type ExtractBinder<B extends Binder<never>> = B extends Binder<infer N extends AstNode> ? N : never;
 export declare function any<Binders extends Binder<never>[]>(binders: Binders): Binders extends SyncBinder<never>[] ? SyncBinder<ExtractBinder<Binders[number]>> : AsyncBinder<ExtractBinder<Binders[number]>>;
 /**
  * No operation.