@spyglassmc/core 0.4.1 → 0.4.2

package/lib/common/Dev.js

@@ -26,8 +26,8 @@ export const Dev = Object.freeze({
             switch (typeof current) {
                 case 'bigint': {
                     const bits = Math.ceil(Math.log2(Number(current)));
-                    ans +=
-                        (2 + Math.ceil(bits / (ByteToBits * PointerSize))) * PointerSize; // https://stackoverflow.com/a/54298760
+                    ans += (2 + Math.ceil(bits / (ByteToBits * PointerSize))) *
+                        PointerSize; // https://stackoverflow.com/a/54298760
                     break;
                 }
                 case 'boolean':

package/lib/common/ReadonlyProxy.d.ts

@@ -1,5 +1,5 @@
-declare type Wrap<T> = T extends object ? DeepReadonly<T> : T;
-export declare type DeepReadonly<T extends object> = {
+type Wrap<T> = T extends object ? DeepReadonly<T> : T;
+export type DeepReadonly<T extends object> = {
     readonly [K in keyof T]: Wrap<T[K]>;
 };
 export declare const ReadonlyProxy: Readonly<{

package/lib/common/StateProxy.d.ts

@@ -3,7 +3,7 @@ declare const Is: unique symbol;
 declare const Origin: unique symbol;
 declare const Redo: unique symbol;
 declare const Undo: unique symbol;
-declare type Wrap<T> = T extends object ? StateProxy<T> : T;
+type Wrap<T> = T extends object ? StateProxy<T> : T;
 /**
  * A proxy wrapped around an arbitrary object value.
  * You can access and mutate the value as normal, but you also have the ability to revert all changes ever since the
@@ -12,7 +12,7 @@ declare type Wrap<T> = T extends object ? StateProxy<T> : T;
  * A new proxy can be branched off of an existing proxy using {@link StateProxy.branchOff} to have finer control
  * over what changes to be reverted.
  */
-export declare type StateProxy<T extends object> = {
+export type StateProxy<T extends object> = {
     [K in keyof T]: Wrap<T[K]>;
 } & {
     [BranchOff]: () => StateProxy<T>;

package/lib/common/externals/NodeJsExternals.js

@@ -68,7 +68,10 @@ export const NodeJsExternals = {
             return fsp.chmod(toFsPathLike(location), mode);
         },
         async getAllFiles(location) {
-            return (await globby(toPath(location) + '**/*', { absolute: true, dot: true })).map(uriFromPath);
+            return (await globby(toPath(location) + '**/*', {
+                absolute: true,
+                dot: true,
+            })).map(uriFromPath);
         },
         async mkdir(location, options) {
             return void (await fsp.mkdir(toFsPathLike(location), options));

package/lib/common/externals/downloader.d.ts

@@ -1,5 +1,5 @@
-declare type RemoteUriProtocol = 'http:' | 'https:';
-export declare type RemoteUriString = `${RemoteUriProtocol}${string}`;
+type RemoteUriProtocol = 'http:' | 'https:';
+export type RemoteUriString = `${RemoteUriProtocol}${string}`;
 export declare const RemoteUriString: Readonly<{
     is(value: string): value is `http:${string}` | `https:${string}`;
 }>;

package/lib/common/externals/index.d.ts

@@ -31,7 +31,7 @@ export interface DecompressedFile {
     path: string;
     type: string;
 }
-export declare type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
+export type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
 export interface ExternalEventEmitter {
     emit(eventName: string, ...args: unknown[]): boolean;
     on(eventName: string, listener: (...args: unknown[]) => unknown): this;
@@ -76,7 +76,7 @@ export interface ExternalFileSystem {
 /**
  * A file file URI string or a URI object.
  */
-export declare type FsLocation = string | Uri;
+export type FsLocation = string | Uri;
 export interface FsWatcher {
     on(eventName: 'ready', listener: () => unknown): this;
     once(eventName: 'ready', listener: () => unknown): this;

package/lib/common/util.d.ts

@@ -9,11 +9,11 @@ export declare const Uri: {
     createObjectURL(obj: Blob | MediaSource): string;
     revokeObjectURL(url: string): void;
 };
-export declare type Uri = URL;
+export type Uri = URL;
 /**
  * `NodeJS.Timeout` on Node.js and `number` on browser.
  */
-export declare type IntervalId = any;
+export type IntervalId = any;
 /**
  * @param getKey A function that takes the actual arguments being passed into the decorated method, and returns anything.
  * The result of this function will be used as the key to identify the `Promise`. By default the first element in the argument
@@ -35,7 +35,7 @@ export declare const Singleton: MethodDecorator;
  * Decorated methods will be scheduled to run after `ms` milliseconds. The timer will reset when the method is called again.
  */
 export declare function Delay(ms: number, getKey?: (args: any[]) => any): MethodDecorator;
-export declare type FullResourceLocation = `${string}:${string}`;
+export type FullResourceLocation = `${string}:${string}`;
 export interface ResourceLocation {
     isTag: boolean;
     namespace: string | undefined;
@@ -63,7 +63,7 @@ export declare namespace ResourceLocation {
  * Byte order mark is correctly removed.
  */
 export declare function bufferToString(buffer: Uint8Array): string;
-export declare type Arrayable<T> = T | readonly T[];
+export type Arrayable<T> = T | readonly T[];
 export declare namespace Arrayable {
     function is<T>(value: unknown, isT: (value: unknown) => value is T): value is Arrayable<T>;
     function toArray<T>(value: Arrayable<T>): T[];
@@ -78,7 +78,7 @@ export declare function parseGzippedJson(externals: Externals, buffer: Uint8Arra
  */
 export declare function isPojo(value: unknown): value is Record<string, unknown>;
 export declare function merge<T extends Record<string, any>>(a: T, b: Record<string, any>): T;
-export declare type Lazy<T> = T | Lazy.ComplexLazy<T>;
+export type Lazy<T> = T | Lazy.ComplexLazy<T>;
 export declare namespace Lazy {
     const LazyDiscriminator: unique symbol;
     export type UnresolvedLazy<T> = {
@@ -121,12 +121,12 @@ export declare function normalizeUri(uri: string): string;
  * function isCommentNode<T extends DeepReadonly<AstNode> | undefined>(node: T): node is IsHelper<AstNode, CommentNode, T>
  * ```
  */
-export declare type IsHelper<ROOT extends object, TARGET extends ROOT, INPUT extends DeepReadonly<ROOT> | undefined> = INPUT extends DeepReadonly<ROOT> ? INPUT & DeepReadonly<TARGET> : INPUT & TARGET;
+export type IsHelper<ROOT extends object, TARGET extends ROOT, INPUT extends DeepReadonly<ROOT> | undefined> = INPUT extends DeepReadonly<ROOT> ? INPUT & DeepReadonly<TARGET> : INPUT & TARGET;
 /**
  * @example
  * ```ts
  * function isCommentNode<T extends DeepReadonly<AstNode> | undefined>(node: T): node is NodeIsHelper<CommentNode, T>
  * ```
  */
-export declare type NodeIsHelper<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = IsHelper<AstNode, TARGET, INPUT>;
+export type NodeIsHelper<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = IsHelper<AstNode, TARGET, INPUT>;
 //# sourceMappingURL=util.d.ts.map

package/lib/common/util.js

@@ -210,7 +210,7 @@ export const binarySearch = externalBinarySearch;
 export function isIterable(value) {
     return !!value[Symbol.iterator];
 }
-//#region ESNext functions polyfill
+// #region ESNext functions polyfill
 export function atArray(array, index) {
     return index >= 0 ? array?.[index] : array?.[array.length + index];
 }
@@ -232,7 +232,7 @@ export function emplaceMap(map, key, handler) {
         throw new Error(`No key ${key} in map and no insert handler provided`);
     }
 }
-//#endregion
+// #endregion
 /**
  * @returns If `val` is an non-null object or a callable object (i.e. function).
  */

package/lib/node/AstNode.d.ts

@@ -59,7 +59,7 @@ export declare namespace AstNode {
     export function getLocalsToLeaves(node: AstNode): Generator<SymbolTable>;
     export {};
 }
-export declare type Mutable<N> = N extends AstNode ? {
+export type Mutable<N> = N extends AstNode ? {
     -readonly [K in keyof N]: Mutable<N[K]>;
 } : N;
 //# sourceMappingURL=AstNode.d.ts.map

package/lib/node/AstNode.js

@@ -24,7 +24,9 @@ export var AstNode;
         if (!node.children) {
             return -1;
         }
-        const comparator = typeof needle === 'number' ? Range.compareOffset : Range.compare;
+        const comparator = typeof needle === 'number'
+            ? Range.compareOffset
+            : Range.compare;
         return binarySearch(node.children, needle, (a, b) => comparator(a.range, b, endInclusive));
     }
     AstNode.findChildIndex = findChildIndex;

package/lib/node/CommentNode.d.ts

@@ -1,4 +1,4 @@
-import type { DeepReadonly } from '../common/index.js';
+import type { DeepReadonly, NodeIsHelper } from '../common/index.js';
 import type { AstNode } from './AstNode.js';
 export interface CommentNode extends AstNode {
     readonly type: 'comment';
@@ -8,6 +8,6 @@ export interface CommentNode extends AstNode {
     comment: string;
 }
 export declare const CommentNode: Readonly<{
-    is<T extends DeepReadonly<AstNode> | undefined>(obj: T): obj is import("../common/util.js").IsHelper<AstNode, CommentNode, T>;
+    is<T extends DeepReadonly<AstNode> | undefined>(obj: T): obj is NodeIsHelper<CommentNode, T>;
 }>;
 //# sourceMappingURL=CommentNode.d.ts.map

package/lib/node/ResourceLocationNode.d.ts

@@ -3,7 +3,7 @@ import { ResourceLocation } from '../common/index.js';
 import type { RangeLike } from '../source/index.js';
 import type { ResourceLocationCategory, SymbolAccessType, SymbolUsageType, TaggableResourceLocationCategory } from '../symbol/index.js';
 import type { AstNode } from './AstNode.js';
-export declare type ResourceLocationOptions = {
+export type ResourceLocationOptions = {
     accessType?: SymbolAccessType;
     isPredicate?: boolean;
     usageType?: SymbolUsageType;

package/lib/node/ResourceLocationNode.js

@@ -43,10 +43,9 @@ export var ResourceLocationNode;
         switch (type) {
             case 'origin':
                 // Use `node.namespace !== undefined`, so that empty namespaces can be correctly restored to string.
-                id =
-                    node.namespace !== undefined
-                        ? `${node.namespace}${NamespacePathSep}${path}`
-                        : path;
+                id = node.namespace !== undefined
+                    ? `${node.namespace}${NamespacePathSep}${path}`
+                    : path;
                 break;
             case 'full':
                 // Use `node.namespace` before `||`, so that both undefined and empty value can result in the default namespace.
@@ -55,10 +54,9 @@ export var ResourceLocationNode;
                 break;
             case 'short':
                 // Use `node.namespace` before `&&` for the same reason stated above.
-                id =
-                    node.namespace && node.namespace !== DefaultNamespace
-                        ? `${node.namespace}${NamespacePathSep}${path}`
-                        : path;
+                id = node.namespace && node.namespace !== DefaultNamespace
+                    ? `${node.namespace}${NamespacePathSep}${path}`
+                    : path;
                 break;
         }
         return includesTagPrefix && node.isTag ? `${TagPrefix}${id}` : id;

package/lib/node/StringNode.d.ts

@@ -3,12 +3,12 @@ import type { ColorTokenType } from '../processor/index.js';
 import type { IndexMap, RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
 export declare const EscapeChars: readonly ["\"", "'", "\\", "b", "f", "n", "r", "t"];
-export declare type EscapeChar = typeof EscapeChars[number];
+export type EscapeChar = (typeof EscapeChars)[number];
 export declare namespace EscapeChar {
     function is(expected: EscapeChar[] | undefined, c: string): c is EscapeChar;
 }
 export declare const EscapeTable: Map<"\"" | "'" | "b" | "f" | "n" | "r" | "t" | "\\", string>;
-export declare type Quote = "'" | '"';
+export type Quote = "'" | '"';
 export interface StringOptions {
     colorTokenType?: ColorTokenType;
     escapable?: {
@@ -47,7 +47,7 @@ export interface StringOptions {
         type: AstNode['type'];
     };
 }
-export declare type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
+export type QuoteTypeConfig = 'always double' | 'always single' | 'prefer double' | 'prefer single';
 export interface StringBaseNode extends AstNode {
     readonly options: StringOptions;
     value: string;

package/lib/node/StringNode.js

@@ -32,7 +32,10 @@ export var StringNode;
             range,
             options,
             value: '',
-            valueMap: [{ inner: Range.create(0), outer: Range.create(range.start) }],
+            valueMap: [{
+                    inner: Range.create(0),
+                    outer: Range.create(range.start),
+                }],
         };
     }
     StringNode.mock = mock;

package/lib/parser/Parser.d.ts

@@ -4,13 +4,13 @@ import type { Source } from '../source/index.js';
 /**
  * A parser.
  */
-export declare type Parser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Result<N>;
+export type Parser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Result<N>;
 /**
  * A parser that always succeeds.
  */
-export declare type InfallibleParser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Success<N>;
-export declare type Result<T extends Returnable> = Success<T> | typeof Failure;
-export declare type Success<T extends Returnable> = T;
+export type InfallibleParser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Success<N>;
+export type Result<T extends Returnable> = Success<T> | typeof Failure;
+export type Success<T extends Returnable> = T;
 export declare const Failure: unique symbol;
-export declare type Returnable = object | string | number | bigint | boolean | undefined;
+export type Returnable = object | string | number | bigint | boolean | undefined;
 //# sourceMappingURL=Parser.d.ts.map

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/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/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/string.js

@@ -86,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 */

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,7 +82,10 @@ 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);
@@ -156,7 +159,9 @@ export function select(cases) {
                 (prefix !== undefined ? src.tryPeek(prefix) : undefined) ??
                 (regex && src.matchPattern(regex)) ??
                 true) {
-                const callableParser = typeof parser === 'object' ? parser.get() : parser;
+                const callableParser = typeof parser === 'object'
+                    ? parser.get()
+                    : parser;
                 return callableParser(src, ctx);
             }
         }

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

@@ -140,11 +140,13 @@ export var ColorPresentation;
                     .toString(16)
                     .padStart(8, '0')}`;
             case ColorFormat.HexRGB:
-                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)
                     .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.

package/lib/processor/binder/builtin.js

@@ -89,7 +89,9 @@ export const resourceLocation = SyncBinder.create((node, ctx) => {
         : raw);
     if (node.options.category) {
         ctx.symbols
-            .query(ctx.doc, node.isTag ? `tag/${node.options.category}` : node.options.category, sanitizedRaw)
+            .query(ctx.doc, node.isTag
+            ? `tag/${node.options.category}`
+            : node.options.category, sanitizedRaw)
             .enter({
             usage: {
                 type: node.options.usageType,

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

@@ -1,3 +1,3 @@
-export * as binder from './builtin.js';
 export * from './Binder.js';
+export * as binder from './builtin.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/processor/binder/index.js

@@ -1,3 +1,3 @@
-export * as binder from './builtin.js';
 export * from './Binder.js';
+export * as binder from './builtin.js';
 //# sourceMappingURL=index.js.map

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

@@ -1,7 +1,7 @@
 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>;
+export type Checker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void> | void;
+export type SyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => void;
+export type AsyncChecker<N extends AstNode> = (node: N, ctx: CheckerContext) => PromiseLike<void>;
 export declare const FallbackChecker: Checker<any>;
 //# sourceMappingURL=Checker.d.ts.map

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

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

package/lib/processor/checker/builtin.js

@@ -30,7 +30,8 @@ export function any(checkers) {
     return (node, ctx) => {
         const attempts = checkers
             .map((checker) => attempt(checker, node, ctx))
-            .sort((a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan);
+            .sort((a, b) => a.errorAmount - b.errorAmount ||
+            a.totalErrorSpan - b.totalErrorSpan);
         attempts[0].updateNodeAndCtx();
     };
 }

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

@@ -3,7 +3,7 @@ import type { AstNode } from '../../node/index.js';
 import type { ColorizerContext } from '../../service/index.js';
 import type { RangeLike } from '../../source/index.js';
 import { Range } from '../../source/index.js';
-export declare type Colorizer<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ColorizerContext) => readonly ColorToken[];
+export type Colorizer<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: ColorizerContext) => readonly ColorToken[];
 export interface ColorToken {
     range: Range;
     type: ColorTokenType;
@@ -18,7 +18,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 type ColorTokenType = typeof ColorTokenTypes[number];
+export type ColorTokenType = typeof ColorTokenTypes[number];
 export declare const ColorTokenModifiers: readonly ["declaration", "defaultLibrary", "definition", "deprecated", "documentation", "modification", "readonly"];
-export declare type ColorTokenModifier = typeof ColorTokenModifiers[number];
+export type ColorTokenModifier = typeof ColorTokenModifiers[number];
 //# sourceMappingURL=Colorizer.d.ts.map

package/lib/processor/completer/Completer.d.ts

@@ -3,7 +3,7 @@ import type { AstNode } from '../../node/index.js';
 import type { CompleterContext } from '../../service/index.js';
 import type { RangeLike } from '../../source/index.js';
 import { Range } from '../../source/index.js';
-export declare type Completer<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: CompleterContext) => CompletionItem[];
+export type Completer<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: CompleterContext) => CompletionItem[];
 export declare const enum CompletionKind {
     Text = 1,
     Method = 2,

package/lib/processor/completer/builtin.js

@@ -43,7 +43,8 @@ export const literal = (node) => {
         ['resourceLocation', 17 /* CompletionKind.File */],
         ['variable', 6 /* CompletionKind.Variable */],
     ]).get(node.options.colorTokenType ?? 'keyword') ?? 14 /* CompletionKind.Keyword */;
-    return (node.options.pool.map((v) => CompletionItem.create(v, node, { kind })) ?? []);
+    return (node.options.pool.map((v) => CompletionItem.create(v, node, { kind })) ??
+        []);
 };
 export const noop = () => [];
 export function record(o) {
@@ -88,9 +89,12 @@ export function record(o) {
 }
 export const resourceLocation = (node, ctx) => {
     const config = LinterConfigValue.destruct(ctx.config.lint.idOmitDefaultNamespace);
-    const includeEmptyNamespace = !node.options.isPredicate && node.namespace === '';
-    const includeDefaultNamespace = node.options.isPredicate || config?.ruleValue !== true;
-    const excludeDefaultNamespace = !node.options.isPredicate && config?.ruleValue !== false;
+    const includeEmptyNamespace = !node.options.isPredicate &&
+        node.namespace === '';
+    const includeDefaultNamespace = node.options.isPredicate ||
+        config?.ruleValue !== true;
+    const excludeDefaultNamespace = !node.options.isPredicate &&
+        config?.ruleValue !== false;
     const getPool = (category) => optimizePool(Object.keys(ctx.symbols.getVisibleSymbols(category, ctx.doc.uri)));
     const optimizePool = (pool) => {
         const defaultNsPrefix = `${ResourceLocation.DefaultNamespace}${ResourceLocation.NamespacePathSep}`;

package/lib/processor/formatter/Formatter.d.ts

@@ -1,7 +1,7 @@
 import type { DeepReadonly } from '../../common/index.js';
 import type { AstNode } from '../../node/index.js';
 import type { FormatterContext } from '../../service/index.js';
-export declare type Formatter<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: FormatterContext) => string;
+export type Formatter<N extends AstNode = AstNode> = (node: DeepReadonly<N>, ctx: FormatterContext) => string;
 export declare function formatterContextIndentation(ctx: FormatterContext, additionalLevels?: number): string;
 export declare function indentFormatter(ctx: FormatterContext, additionalLevels?: number): FormatterContext;
 //# sourceMappingURL=Formatter.d.ts.map

package/lib/processor/formatter/Formatter.js

@@ -1,6 +1,8 @@
 export function formatterContextIndentation(ctx, additionalLevels = 0) {
     const total = ctx.indentLevel + additionalLevels;
-    return ctx.insertSpaces ? ' '.repeat(total * ctx.tabSize) : '\t'.repeat(total);
+    return ctx.insertSpaces
+        ? ' '.repeat(total * ctx.tabSize)
+        : '\t'.repeat(total);
 }
 export function indentFormatter(ctx, additionalLevels = 1) {
     return {