@spyglassmc/core 0.4.5 → 0.4.6

package/lib/parser/long.js

@@ -6,11 +6,7 @@ const fallbackOnOutOfRange = (ans, _src, ctx, options) => {
 };
 export function long(options) {
     return (src, ctx) => {
-        const ans = {
-            type: 'long',
-            range: Range.create(src),
-            value: 0n,
-        };
+        const ans = { type: 'long', range: Range.create(src), value: 0n };
         if (src.peek() === '-' || src.peek() === '+') {
             src.skip();
         }
@@ -36,8 +32,7 @@ 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/prefixed.d.ts

@@ -0,0 +1,8 @@
+import type { AstNode, PrefixedNode } from '../node/index.js';
+import type { InfallibleParser, Parser } from './Parser.js';
+export interface Options<C extends AstNode> {
+    prefix: string;
+    child: Parser<C>;
+}
+export declare function prefixed<C extends AstNode>(options: Options<C>): InfallibleParser<PrefixedNode<C>>;
+//# sourceMappingURL=prefixed.d.ts.map

package/lib/parser/prefixed.js

@@ -0,0 +1,23 @@
+import { Range } from '../source/index.js';
+import { literal } from './literal.js';
+import { Failure } from './Parser.js';
+export function prefixed(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'prefixed',
+            range: Range.create(src),
+            prefix: options.prefix,
+            children: [],
+        };
+        const prefix = literal(options.prefix)(src, ctx);
+        ans.children.push(prefix);
+        ans.range.end = src.cursor;
+        const child = options.child(src, ctx);
+        if (child !== Failure) {
+            ans.children.push(child);
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+//# sourceMappingURL=prefixed.js.map

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,13 +5,9 @@ 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',
-            range: Range.create(src),
-            children: [],
-        };
+        const ans = { type: 'record', range: Range.create(src), children: [] };
         if (src.trySkip(start)) {
             src.skipWhitespace();
             let requiresPairEnd = false;
@@ -26,10 +22,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 {
@@ -51,10 +47,10 @@ export function record({ start, pair, end, }) {
                     ? 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 {
@@ -73,9 +69,7 @@ export function record({ start, pair, end, }) {
                     type: 'pair',
                     range: Range.create(pairStart, src),
                     ...(key || value
-                        ? {
-                            children: [key, value].filter((v) => !!v),
-                        }
+                        ? { children: [key, value].filter((v) => !!v) }
                         : {}),
                     key,
                     sep: sepCharRange,

package/lib/parser/resourceLocation.d.ts

@@ -1,4 +1,5 @@
 import type { ResourceLocationNode, ResourceLocationOptions } from '../node/index.js';
 import type { InfallibleParser } from './Parser.js';
+export declare const LegalResourceLocationCharacters: Set<string>;
 export declare function resourceLocation(options: ResourceLocationOptions): InfallibleParser<ResourceLocationNode>;
 //# sourceMappingURL=resourceLocation.d.ts.map

package/lib/parser/resourceLocation.js

@@ -6,6 +6,7 @@ const Terminators = new Set([
     '\r',
     '\n',
     '=',
+    '~',
     ',',
     '"',
     "'",
@@ -16,8 +17,9 @@ const Terminators = new Set([
     '(',
     ')',
     ';',
+    '|',
 ]);
-const LegalCharacters = new Set([
+export const LegalResourceLocationCharacters = new Set([
     'a',
     'b',
     'c',
@@ -88,8 +90,8 @@ export function resourceLocation(options) {
             /* istanbul ignore next */
             const illegalChars = [
                 ...new Set([
-                    ...[...(ans.namespace ?? [])].filter((c) => !LegalCharacters.has(c)),
-                    ...[...rawPath].filter((c) => c !== '/' && !LegalCharacters.has(c)),
+                    ...[...(ans.namespace ?? [])].filter((c) => !LegalResourceLocationCharacters.has(c)),
+                    ...[...rawPath].filter((c) => c !== '/' && !LegalResourceLocationCharacters.has(c)),
                 ]),
             ];
             if (illegalChars.length) {
@@ -98,7 +100,7 @@ export function resourceLocation(options) {
             if (ans.isTag && !options.allowTag) {
                 ctx.err.report(localize('parser.resource-location.tag-disallowed'), ans);
             }
-            if (!ans.namespace && options.isPredicate) {
+            if (!ans.namespace && options.requireCanonical) {
                 ctx.err.report(localize('parser.resource-location.namespace-expected'), ans);
             }
         }

package/lib/parser/string.js

@@ -15,6 +15,7 @@ export function string(options) {
         let start = src.cursor;
         if (options.quotes?.length && (src.peek() === '"' || src.peek() === "'")) {
             const currentQuote = src.read();
+            ans.quote = currentQuote;
             const contentStart = src.cursor;
             while (src.canRead() && src.peek() !== currentQuote) {
                 const c = src.peek();
@@ -22,9 +23,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),
@@ -75,8 +76,7 @@ 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) {
@@ -86,10 +86,7 @@ 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 */

package/lib/parser/util.d.ts

@@ -1,7 +1,8 @@
 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 { ErrorSeverity, ReadonlySource } from '../source/index.js';
+import { Source } from '../source/index.js';
 import type { InfallibleParser, Parser, Result, Returnable } from './Parser.js';
 type ExtractNodeType<P extends Parser<Returnable>> = P extends Parser<infer V> ? V : never;
 /**
@@ -141,8 +142,18 @@ export declare function validate<N extends AstNode>(parser: Parser<N>, validator
 /**
  * @returns A parser that is based on the passed-in `parser`, but will never read to any of the terminator strings.
  */
-export declare function stopBefore<N extends Returnable>(parser: InfallibleParser<N>, ...teminators: (string | readonly string[])[]): InfallibleParser<N>;
-export declare function stopBefore<N extends Returnable>(parser: Parser<N>, ...teminators: (string | readonly string[])[]): Parser<N>;
+export declare function stopBefore<N extends Returnable>(parser: InfallibleParser<N>, ...terminators: (string | readonly string[])[]): InfallibleParser<N>;
+export declare function stopBefore<N extends Returnable>(parser: Parser<N>, ...terminators: (string | readonly string[])[]): Parser<N>;
+/**
+ * @returns A parser that is based on the passed-in `parser`, but concatenates lines
+ * together when we reach, in order:
+ * - a backslash
+ * - whitespace (optional)
+ * - a newline
+ * - whitespace (optional)
+ */
+export declare function concatOnTrailingBackslash<N extends Returnable>(parser: InfallibleParser<N>): InfallibleParser<N>;
+export declare function concatOnTrailingBackslash<N extends Returnable>(parser: Parser<N>): Parser<N>;
 /**
  * @returns A parser that is based on the passed-in `parser`, but will only read the acceptable characters.
  */

package/lib/parser/util.js

@@ -1,13 +1,11 @@
+import { localize } from '@spyglassmc/locales';
 import { SequenceUtil, SequenceUtilDiscriminator } from '../node/index.js';
 import { ErrorReporter } from '../service/index.js';
-import { Range } from '../source/index.js';
+import { IndexMap, Range, Source } from '../source/index.js';
 import { Failure } from './Parser.js';
 export function attempt(parser, src, ctx) {
     const tmpSrc = src.clone();
-    const tmpCtx = {
-        ...ctx,
-        err: new ErrorReporter(),
-    };
+    const tmpCtx = { ...ctx, err: new ErrorReporter() };
     const result = parser(tmpSrc, tmpCtx);
     return {
         result,
@@ -81,14 +79,7 @@ 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,
-        }))
-            .filter(({ attempt }) => attempt.result !== Failure)
-            .sort((a, b) => b.attempt.endCursor - a.attempt.endCursor ||
-            a.attempt.errorAmount - b.attempt.errorAmount);
+        const results = parsers.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);
         if (results.length === 0) {
             if (out) {
                 out.index = -1;
@@ -155,13 +146,11 @@ 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);
             }
         }
@@ -181,10 +170,7 @@ export function map(parser, fn) {
 export function setType(type, parser) {
     return map(parser, (res) => {
         const { type: _type, ...restResult } = res;
-        const ans = {
-            type,
-            ...restResult,
-        };
+        const ans = { type, ...restResult };
         delete ans[SequenceUtilDiscriminator];
         return ans;
     });
@@ -198,8 +184,8 @@ export function validate(parser, validator, message, severity) {
         return res;
     });
 }
-export function stopBefore(parser, ...teminators) {
-    const flatTerminators = teminators.flat();
+export function stopBefore(parser, ...terminators) {
+    const flatTerminators = terminators.flat();
     return (src, ctx) => {
         const tmpSrc = src.clone();
         // Cut tmpSrc.string before the nearest terminator.
@@ -212,6 +198,42 @@ export function stopBefore(parser, ...teminators) {
         return ans;
     };
 }
+export function concatOnTrailingBackslash(parser) {
+    return (src, ctx) => {
+        let wrappedStr = src.sliceToCursor(0);
+        const wrappedSrcCursor = wrappedStr.length;
+        const indexMap = [];
+        while (src.canRead()) {
+            wrappedStr += src.readUntil('\\');
+            if (!src.canRead()) {
+                break;
+            }
+            // If we get here, then `src.cursor` is at a backslash
+            if (src.hasNonSpaceAheadInLine(1)) {
+                wrappedStr += src.read();
+                continue;
+            }
+            // Create an index map that skips from the trailing backslash to the
+            // next line's first non-whitespace character
+            const from = src.getCharRange();
+            src.nextLine();
+            // Minecraft raises a `Line continuation at end of file` if a backslash
+            // (+ optional whitespace to the next line) is right before the end of the file
+            if (!src.canRead()) {
+                const ans = { type: 'error', range: Range.span(from, src) };
+                ctx.err.report(localize('parser.line-continuation-end-of-file'), ans);
+            }
+            src.skipSpace();
+            const to = src.getCharRange(-1);
+            indexMap.push({ inner: Range.create(wrappedStr.length), outer: Range.span(from, to) });
+        }
+        const wrappedSrc = new Source(wrappedStr, IndexMap.merge(src.indexMap, indexMap));
+        wrappedSrc.innerCursor = wrappedSrcCursor;
+        const ans = parser(wrappedSrc, ctx);
+        src.cursor = wrappedSrc.cursor;
+        return ans;
+    };
+}
 export function acceptOnly(parser, ...characters) {
     const set = new Set(characters.flat());
     return (src, ctx) => {

package/lib/processor/ColorInfoProvider.js

@@ -108,11 +108,7 @@ export var ColorPresentation;
 (function (ColorPresentation) {
     function fromColorFormat(format, color, range) {
         const presentation = colorPresentation(format, color);
-        return {
-            label: presentation,
-            text: presentation,
-            range,
-        };
+        return { label: presentation, text: presentation, range };
     }
     ColorPresentation.fromColorFormat = fromColorFormat;
     function colorPresentation(format, color) {
@@ -121,32 +117,19 @@ export var ColorPresentation;
             case ColorFormat.DecRGBA:
                 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(' ');
             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/binder/builtin.d.ts

@@ -19,6 +19,7 @@ export declare const noop: SyncBinder<AstNode>;
  * Use the shallowest children that have their own binder to validate.
  */
 export declare const fallback: AsyncBinder<AstNode>;
+export declare const fallbackSync: SyncBinder<AstNode>;
 export declare const dispatchSync: SyncBinder<AstNode>;
 export declare const resourceLocation: SyncBinder<ResourceLocationNode>;
 export declare const symbol: SyncBinder<SymbolBaseNode>;

package/lib/processor/binder/builtin.js

@@ -5,16 +5,10 @@ import { ErrorReporter } from '../../service/index.js';
 import { traversePreOrder } from '../util.js';
 import { AsyncBinder, SyncBinder } from './Binder.js';
 export function attempt(binder, node, ctx) {
-    const tempCtx = {
-        ...ctx,
-        err: new ErrorReporter(),
-        symbols: ctx.symbols.clone(),
-    };
+    const tempCtx = { ...ctx, err: new ErrorReporter(), symbols: ctx.symbols.clone() };
     const processAfterBinder = () => {
         StateProxy.undoChanges(node);
-        const totalErrorSpan = tempCtx.err.errors
-            .map((e) => e.range.end - e.range.start)
-            .reduce((a, b) => a + b, 0);
+        const totalErrorSpan = tempCtx.err.errors.map((e) => e.range.end - e.range.start).reduce((a, b) => a + b, 0);
         return {
             errorAmount: tempCtx.err.errors.length,
             totalErrorSpan,
@@ -43,15 +37,14 @@ export function any(binders) {
     const attemptSorter = (a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan;
     if (binders.every(SyncBinder.is)) {
         return SyncBinder.create((node, ctx) => {
-            const attempts = binders
-                .map((binder) => attempt(binder, node, ctx))
-                .sort(attemptSorter);
+            const attempts = binders.map((binder) => attempt(binder, node, ctx)).sort(attemptSorter);
             attempts[0].updateNodeAndCtx();
         });
     }
     else {
         return AsyncBinder.create(async (node, ctx) => {
-            const attempts = (await Promise.all(binders.map((binder) => attempt(binder, node, ctx)))).sort(attemptSorter);
+            const attempts = (await Promise.all(binders.map((binder) => attempt(binder, node, ctx))))
+                .sort(attemptSorter);
             attempts[0].updateNodeAndCtx();
         });
     }
@@ -74,6 +67,17 @@ export const fallback = AsyncBinder.create(async (node, ctx) => {
     });
     await Promise.all(promises);
 });
+export const fallbackSync = SyncBinder.create((node, ctx) => {
+    traversePreOrder(node, (node) => !ctx.meta.hasBinder(node.type), (node) => ctx.meta.hasBinder(node.type), (node) => {
+        const binder = ctx.meta.getBinder(node.type);
+        if (SyncBinder.is(binder)) {
+            binder(node, ctx);
+        }
+        else {
+            ctx.logger.warn(`[fallbackSync] Trying to run async binder for "${node.type}"`);
+        }
+    });
+});
 export const dispatchSync = SyncBinder.create((node, ctx) => {
     for (const child of node.children ?? []) {
         if (ctx.meta.hasBinder(child.type)) {
@@ -88,16 +92,8 @@ export const resourceLocation = SyncBinder.create((node, ctx) => {
         ? raw.replace(/\./g, ResourceLocation.NamespacePathSep)
         : raw);
     if (node.options.category) {
-        ctx.symbols
-            .query(ctx.doc, node.isTag
-            ? `tag/${node.options.category}`
-            : node.options.category, sanitizedRaw)
-            .enter({
-            usage: {
-                type: node.options.usageType,
-                node,
-                accessType: node.options.accessType,
-            },
+        ctx.symbols.query(ctx.doc, node.isTag ? `tag/${node.options.category}` : node.options.category, sanitizedRaw).enter({
+            usage: { type: node.options.usageType, node, accessType: node.options.accessType },
         });
     }
     if (node.options.pool && !node.options.allowUnknown) {
@@ -109,15 +105,9 @@ export const resourceLocation = SyncBinder.create((node, ctx) => {
 });
 export const symbol = SyncBinder.create((node, ctx) => {
     if (node.value) {
-        const path = node.options.parentPath
-            ? [...node.options.parentPath, node.value]
-            : [node.value];
+        const path = node.options.parentPath ? [...node.options.parentPath, node.value] : [node.value];
         ctx.symbols.query(ctx.doc, node.options.category, ...path).enter({
-            usage: {
-                type: node.options.usageType,
-                node: node,
-                accessType: node.options.accessType,
-            },
+            usage: { type: node.options.usageType, node, accessType: node.options.accessType },
         });
     }
 });

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

@@ -16,6 +16,7 @@ export declare const noop: SyncChecker<AstNode>;
  * Use the shallowest children that have their own checker to validate.
  */
 export declare const fallback: Checker<AstNode>;
+export declare const fallbackSync: SyncChecker<AstNode>;
 export declare const dispatchSync: SyncChecker<AstNode>;
 export declare const resourceLocation: Checker<ResourceLocationNode>;
 export declare const symbol: Checker<SymbolBaseNode>;

package/lib/processor/checker/builtin.js

@@ -10,9 +10,7 @@ export function attempt(checker, node, ctx) {
     // FIXME: await
     checker(node, tempCtx);
     StateProxy.undoChanges(node);
-    const totalErrorSpan = tempCtx.err.errors
-        .map((e) => e.range.end - e.range.start)
-        .reduce((a, b) => a + b, 0);
+    const totalErrorSpan = tempCtx.err.errors.map((e) => e.range.end - e.range.start).reduce((a, b) => a + b, 0);
     return {
         errorAmount: tempCtx.err.errors.length,
         totalErrorSpan,
@@ -28,10 +26,7 @@ export function any(checkers) {
         throw new Error('Expected at least one checker');
     }
     return (node, ctx) => {
-        const attempts = checkers
-            .map((checker) => attempt(checker, node, ctx))
-            .sort((a, b) => a.errorAmount - b.errorAmount ||
-            a.totalErrorSpan - b.totalErrorSpan);
+        const attempts = checkers.map((checker) => attempt(checker, node, ctx)).sort((a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan);
         attempts[0].updateNodeAndCtx();
     };
 }
@@ -53,6 +48,17 @@ export const fallback = async (node, ctx) => {
     });
     await Promise.all(promises);
 };
+export const fallbackSync = async (node, ctx) => {
+    const promises = [];
+    traversePreOrder(node, (node) => !ctx.meta.hasChecker(node.type), (node) => ctx.meta.hasChecker(node.type), (node) => {
+        const checker = ctx.meta.getChecker(node.type);
+        const result = checker(node, ctx);
+        if (result instanceof Promise) {
+            ctx.logger.warn(`[fallbackSync] Trying to run async checker for "${node.type}"`);
+        }
+    });
+    await Promise.all(promises);
+};
 export const dispatchSync = (node, ctx) => {
     for (const child of node.children ?? []) {
         if (ctx.meta.hasChecker(child.type)) {

package/lib/processor/colorizer/Colorizer.d.ts

@@ -17,7 +17,7 @@ export declare namespace ColorToken {
      */
     function fillGap(tokens: readonly ColorToken[], targetRange: Range, type: ColorTokenType, modifiers?: ColorTokenModifier[]): ColorToken[];
 }
-export declare const ColorTokenTypes: readonly ["comment", "enum", "enumMember", "function", "keyword", "modifier", "number", "operator", "property", "string", "struct", "type", "type", "variable", "error", "literal", "operator", "resourceLocation", "vector"];
+export declare const ColorTokenTypes: readonly ["comment", "enum", "enumMember", "function", "keyword", "modifier", "number", "property", "string", "struct", "type", "variable", "error", "literal", "operator", "resourceLocation", "vector"];
 export type ColorTokenType = typeof ColorTokenTypes[number];
 export declare const ColorTokenModifiers: readonly ["declaration", "defaultLibrary", "definition", "deprecated", "documentation", "modification", "readonly"];
 export type ColorTokenModifier = typeof ColorTokenModifiers[number];

package/lib/processor/colorizer/Colorizer.js

@@ -3,11 +3,7 @@ export var ColorToken;
 (function (ColorToken) {
     /* istanbul ignore next */
     function create(range, type, modifiers) {
-        return {
-            range: Range.get(range),
-            type,
-            modifiers,
-        };
+        return { range: Range.get(range), type, modifiers };
     }
     ColorToken.create = create;
     /**
@@ -32,6 +28,9 @@ export var ColorToken;
     ColorToken.fillGap = fillGap;
 })(ColorToken || (ColorToken = {}));
 // Built-in LSP semantic tokens: https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocument_semanticTokens
+/*
+ * Hint: during development, the `Developer: Inspect Editor Tokens and Scopes` command in VS Code helps a lot with deciding on the color for nodes.
+ */
 export const ColorTokenTypes = Object.freeze([
     'comment',
     'enum',
@@ -40,12 +39,10 @@ export const ColorTokenTypes = Object.freeze([
     'keyword',
     'modifier',
     'number',
-    'operator',
     'property',
     'string',
     'struct',
     'type',
-    'type',
     'variable',
     // Below are custom types.
     'error',

package/lib/processor/colorizer/builtin.js

@@ -6,8 +6,8 @@ import { ColorToken } from './Colorizer.js';
  */
 export const fallback = (node, ctx) => {
     const ans = [];
-    traversePreOrder(node, (node) => !ctx.meta.hasColorizer(node.type) &&
-        (!ctx.range || Range.intersects(node.range, ctx.range)), (node) => ctx.meta.hasColorizer(node.type), (node) => {
+    traversePreOrder(node, (node) => !ctx.meta.hasColorizer(node.type)
+        && (!ctx.range || Range.intersects(node.range, ctx.range)), (node) => ctx.meta.hasColorizer(node.type), (node) => {
         const colorizer = ctx.meta.getColorizer(node.type);
         const result = colorizer(node, ctx);
         ans.push(...result);

package/lib/processor/completer/Completer.js

@@ -51,9 +51,7 @@ export class InsertTextBuilder {
             this.#ans += `$\{${this.#nextPlaceholder}:${CompletionItem.escape(defaultValues[0])}}`;
         }
         else {
-            this.#ans += `$\{${this.#nextPlaceholder}|${defaultValues
-                .map((v) => v.replace(/([\\$},|])/g, '\\$1'))
-                .join(',')}|}`;
+            this.#ans += `$\{${this.#nextPlaceholder}|${defaultValues.map((v) => v.replace(/([\\$},|])/g, '\\$1')).join(',')}|}`;
         }
         this.#nextPlaceholder += 1;
         return this;