@spyglassmc/core 0.4.1 → 0.4.3

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;
@@ -149,5 +149,9 @@ export declare function stopBefore<N extends Returnable>(parser: Parser<N>, ...t
 export declare function acceptOnly<N extends Returnable>(parser: InfallibleParser<N>, ...characters: (string | readonly string[])[]): InfallibleParser<N>;
 export declare function acceptOnly<N extends Returnable>(parser: Parser<N>, ...characters: (string | readonly string[])[]): Parser<N>;
 export declare function acceptIf<P extends Parser<AstNode>>(parser: P, predicate: (this: void, char: string) => boolean): P extends InfallibleParser<infer N> ? InfallibleParser<N> : P extends Parser<infer N> ? Parser<N> : never;
+/**
+ * @returns A parser that dumps any parser errors after it finishes parsing.
+ */
+export declare function dumpErrors<P extends Parser<AstNode>>(parser: P): P;
 export {};
 //# sourceMappingURL=util.d.ts.map

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);
             }
         }
@@ -238,4 +243,14 @@ export function acceptIf(parser, predicate) {
         return ans;
     });
 }
+/**
+ * @returns A parser that dumps any parser errors after it finishes parsing.
+ */
+export function dumpErrors(parser) {
+    return ((src, ctx) => {
+        const ans = parser(src, ctx);
+        ctx.err.dump();
+        return ans;
+    });
+}
 //# sourceMappingURL=util.js.map

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

@@ -2,8 +2,10 @@ import type { DeepReadonly } from '../common/index.js';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
 export interface InlayHint {
+    label: string;
     offset: number;
-    text: string;
+    paddingLeft?: boolean;
+    paddingRight?: boolean;
 }
-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,26 +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 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>;
-}>;
+export declare namespace SyncBinder {
+    function create<N extends AstNode>(binder: SyncBinderInitializer<N>): SyncBinder<N>;
+    function 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 declare namespace AsyncBinder {
+    function create<N extends AstNode>(binder: AsyncBinderInitializer<N>): AsyncBinder<N>;
+    function is(binder: Binder<any>): binder is AsyncBinder<any>;
+}
 export {};
 //# sourceMappingURL=Binder.d.ts.map

package/lib/processor/binder/Binder.js

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

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 {

package/lib/processor/linter/Linter.d.ts

@@ -1,5 +1,5 @@
 import type { StateProxy } from '../../index.js';
 import type { AstNode } from '../../node/index.js';
 import type { LinterContext } from '../../service/index.js';
-export declare type Linter<N extends AstNode> = (node: StateProxy<N>, ctx: LinterContext) => void;
+export type Linter<N extends AstNode> = (node: StateProxy<N>, ctx: LinterContext) => void;
 //# sourceMappingURL=Linter.d.ts.map

package/lib/processor/util.d.ts

@@ -1,6 +1,6 @@
 import type { DeepReadonly } from '../index.js';
 import type { AstNode } from '../node/index.js';
-declare type Callback<R> = (this: void, node: AstNode, parents: AstNode[]) => R;
+type Callback<R> = (this: void, node: AstNode, parents: AstNode[]) => R;
 export declare function traversePreOrder<CN extends AstNode>(node: DeepReadonly<AstNode>, shouldContinue: Callback<unknown>, shouldCallFn: (this: void, node: AstNode, parents: AstNode[]) => node is CN, fn: (this: void, node: CN, parents: AstNode[]) => void): void;
 export declare function traversePreOrder(node: DeepReadonly<AstNode>, shouldContinue: Callback<unknown>, shouldCallFn: Callback<unknown>, fn: Callback<void>): void;
 export {};

package/lib/service/CacheService.d.ts

@@ -19,7 +19,7 @@ interface Checksums {
 declare namespace Checksums {
     function create(): Checksums;
 }
-declare type ErrorCache = Record<string, readonly PosRangeLanguageError[]>;
+type ErrorCache = Record<string, readonly PosRangeLanguageError[]>;
 interface LoadResult {
     symbols: SymbolTable;
 }

package/lib/service/CacheService.js

@@ -36,8 +36,8 @@ export class CacheService {
             }
             try {
                 // TODO: Don't update this for every single change.
-                this.checksums.files[doc.uri] =
-                    await this.project.externals.crypto.getSha1(doc.getText());
+                this.checksums.files[doc.uri] = await this.project.externals.crypto
+                    .getSha1(doc.getText());
             }
             catch (e) {
                 if (!this.project.externals.error.isKind(e, 'EISDIR')) {

package/lib/service/Config.d.ts

@@ -13,7 +13,7 @@ export interface Config {
      */
     format: FormatterConfig;
     /**
-     *t Linter rules.
+     * t Linter rules.
      */
     lint: LinterConfig;
     /**
@@ -77,19 +77,19 @@ export interface EnvConfig {
     permissionLevel: 1 | 2 | 3 | 4;
     plugins: string[];
 }
-export declare type LinterSeverity = 'hint' | 'information' | 'warning' | 'error';
+export type LinterSeverity = 'hint' | 'information' | 'warning' | 'error';
 export declare namespace LinterSeverity {
     function is(value: unknown): value is LinterSeverity;
     function toErrorSeverity(value: LinterSeverity): ErrorSeverity;
 }
-declare type BracketSpacingConfig = any;
-declare type SepSpacingConfig = any;
-export declare type QuoteConfig = {
+type BracketSpacingConfig = any;
+type SepSpacingConfig = any;
+export type QuoteConfig = {
     always?: boolean;
     avoidEscape?: boolean | null;
     type?: 'double' | 'single';
 };
-declare type LinterConfigValue<T> = T extends boolean ? null | T | [LinterSeverity, T] | LinterSeverity : null | T | [LinterSeverity, T];
+type LinterConfigValue<T> = T extends boolean ? null | T | [LinterSeverity, T] | LinterSeverity : null | T | [LinterSeverity, T];
 export declare namespace LinterConfigValue {
     function destruct(value: LinterConfigValue<boolean | string | number | object>): {
         ruleSeverity: ErrorSeverity;
@@ -151,7 +151,7 @@ export interface LinterConfig {
 export interface SnippetsConfig {
     [label: string]: string;
 }
-export declare type SymbolLinterConfig = Arrayable<SymbolLinterConfig.Complex> | SymbolLinterConfig.Action;
+export type SymbolLinterConfig = Arrayable<SymbolLinterConfig.Complex> | SymbolLinterConfig.Action;
 export declare namespace SymbolLinterConfig {
     function is(value: unknown): value is SymbolLinterConfig;
     interface Complex {
@@ -192,10 +192,10 @@ export declare namespace SymbolLinterConfig {
  * Config which simulates the default vanilla command system.
  */
 export declare const VanillaConfig: Config;
-declare type ConfigEvent = {
+type ConfigEvent = {
     config: Config;
 };
-declare type ErrorEvent = {
+type ErrorEvent = {
     error: unknown;
     uri: string;
 };

package/lib/service/Config.js

@@ -117,7 +117,10 @@ export var SymbolLinterConfig;
 export const VanillaConfig = {
     env: {
         dataSource: 'GitHub',
-        dependencies: ['@vanilla-mcdoc'],
+        dependencies: [
+            '@vanilla-datapack',
+            '@vanilla-mcdoc',
+        ],
         feature: {
             codeActions: true,
             colors: true,
@@ -128,7 +131,16 @@ export const VanillaConfig = {
             formatting: true,
             hover: true,
             inlayHint: {
-                enabledNodes: ['mcfunction:command_child/unknown'],
+                enabledNodes: [
+                    'boolean',
+                    'double',
+                    'float',
+                    'integer',
+                    'long',
+                    'mcfunction:coordinate',
+                    'mcfunction:vector',
+                    'mcfunction:command_child/unknown',
+                ],
             },
             semanticColoring: true,
             selectionRanges: true,
@@ -192,7 +204,9 @@ export const VanillaConfig = {
             {
                 if: [
                     { category: RegistryCategories, namespace: 'minecraft' },
-                    { category: [...FileCategories, 'bossbar', 'objective', 'team'] },
+                    {
+                        category: [...FileCategories, 'bossbar', 'objective', 'team'],
+                    },
                 ],
                 then: { report: 'warning' },
             },

package/lib/service/Dependency.d.ts

@@ -1,10 +1,10 @@
-export declare type Dependency = {
+export type Dependency = {
     uri: string;
     info?: Record<string, any>;
 };
-export declare type DependencyKey = `@${string}`;
+export type DependencyKey = `@${string}`;
 export declare namespace DependencyKey {
     function is(value: string): value is DependencyKey;
 }
-export declare type DependencyProvider = () => PromiseLike<Dependency> | Dependency;
+export type DependencyProvider = () => PromiseLike<Dependency> | Dependency;
 //# sourceMappingURL=Dependency.d.ts.map

package/lib/service/FileService.d.ts

@@ -22,7 +22,7 @@ export interface UriProtocolSupporter {
      */
     listRoots(): Iterable<RootUriString>;
 }
-declare type Protocol = `${string}:`;
+type Protocol = `${string}:`;
 export interface FileService extends UriProtocolSupporter {
     /**
      * @param protocol A protocol of URI, including the colon. e.g. `file:`.
@@ -100,7 +100,7 @@ export declare class ArchiveUriSupporter implements UriProtocolSupporter {
     private static readonly SupportedArchiveExtnames;
     readonly protocol = "archive:";
     /**
-     * @param entries A map from archive URIs to unzipped entries.
+     * @param entries A map from archive names to unzipped entries.
      */
     private constructor();
     hash(uri: string): Promise<string>;
@@ -116,7 +116,7 @@ export declare class ArchiveUriSupporter implements UriProtocolSupporter {
      * @throws When `uri` has the wrong protocol or hostname.
      */
     private static decodeUri;
-    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger, checksums: Record<RootUriString, string>): Promise<ArchiveUriSupporter>;
+    static create(dependencies: readonly Dependency[], externals: Externals, logger: Logger): Promise<ArchiveUriSupporter>;
 }
 export {};
 //# sourceMappingURL=FileService.d.ts.map