@spyglassmc/mcdoc 0.3.49 → 0.3.51

package/lib/binder/index.js

@@ -1,6 +1,6 @@
-import { AsyncBinder, atArray, Dev, ErrorSeverity, Range, ResourceLocationNode, SymbolUtil, traversePreOrder, } from '@spyglassmc/core';
+import { AsyncBinder, Dev, ErrorSeverity, FloatNode, IntegerNode, LongNode, Range, ResourceLocationNode, StringNode, SymbolUtil, traversePreOrder, } from '@spyglassmc/core';
 import { localeQuote, localize } from '@spyglassmc/locales';
-import { AttributeNode, AttributeTreeNamedValuesNode, AttributeTreeNode, AttributeTreePosValuesNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, DynamicIndexNode, EnumBlockNode, EnumFieldNode, EnumInjectionNode, EnumNode, FloatRangeNode, IndexBodyNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StaticIndexNode, StringTypeNode, StructBlockNode, StructMapKeyNode, StructNode, StructPairFieldNode, StructSpreadFieldNode, TopLevelNode, TupleTypeNode, TypeAliasNode, TypeArgBlockNode, TypeBaseNode, TypedNumberNode, TypeParamBlockNode, TypeParamNode, UnionTypeNode, UseStatementNode, } from '../node/index.js';
+import { AttributeNode, AttributeTreeNamedValuesNode, AttributeTreeNode, AttributeTreePosValuesNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, DynamicIndexNode, EnumBlockNode, EnumFieldNode, EnumInjectionNode, EnumNode, FloatRangeNode, IndexBodyNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, LongRangeNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StaticIndexNode, StringTypeNode, StructBlockNode, StructMapKeyNode, StructNode, StructPairFieldNode, StructSpreadFieldNode, TopLevelNode, TupleTypeNode, TypeAliasNode, TypeArgBlockNode, TypeBaseNode, TypedNumberNode, TypeParamBlockNode, TypeParamNode, UnionTypeNode, UseStatementNode, } from '../node/index.js';
 var ModuleSymbolData;
 (function (ModuleSymbolData) {
     function is(data) {
@@ -288,7 +288,7 @@ async function bindPath(node, ctx) {
             },
         })).else(() => {
             if (indexRight === 0) {
-                ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(atArray(identifiers, -1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node, ErrorSeverity.Warning);
+                ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(identifiers.at(-1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node, ErrorSeverity.Warning);
             }
         });
     }
@@ -413,7 +413,7 @@ function* resolvePathByStep(path, ctx, options = {}) {
     }
 }
 function resolvePath(path, ctx, options = {}) {
-    return atArray([...resolvePathByStep(path, ctx, options)], -1)?.identifiers;
+    return [...resolvePathByStep(path, ctx, options)].at(-1)?.identifiers;
 }
 function identifierToUri(module, ctx) {
     return ctx.symbols.global.mcdoc?.[module]?.definition?.[0]?.uri;
@@ -571,27 +571,144 @@ function convertEnum(node, ctx) {
     if (symbol && TypeDefSymbolData.is(symbol.data) && symbol.data.typeDef.kind === 'enum') {
         return symbol.data.typeDef;
     }
-    return wrapType(node, { kind: 'enum', enumKind, values: convertEnumBlock(block, ctx) }, ctx);
-}
-function convertEnumBlock(node, ctx) {
+    switch (enumKind) {
+        case 'byte':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumIntValue(enumKind, 'b'), ctx),
+            }, ctx);
+        case 'short':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumIntValue(enumKind, 's'), ctx),
+            }, ctx);
+        case 'int':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumIntValue(enumKind), ctx),
+            }, ctx);
+        case 'long':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumLongValue, ctx),
+            }, ctx);
+        case 'float':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumFloatValue(enumKind, 'f'), ctx),
+            }, ctx);
+        case 'double':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumFloatValue(enumKind, 'd'), ctx),
+            }, ctx);
+        case 'string':
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumStringValue, ctx),
+            }, ctx);
+        case undefined:
+            return wrapType(node, {
+                kind: 'enum',
+                enumKind,
+                values: convertEnumBlock(block, convertEnumValue, ctx),
+            }, ctx);
+    }
+}
+function convertEnumBlock(node, getEnumFieldValue, ctx) {
     const { fields } = EnumBlockNode.destruct(node);
-    return fields.map((n) => convertEnumField(n, ctx));
+    return fields.map((n) => convertEnumField(n, getEnumFieldValue, ctx));
 }
-function convertEnumField(node, ctx) {
+function convertEnumField(node, getEnumFieldValue, ctx) {
     const { attributes, docComments, identifier, value } = EnumFieldNode.destruct(node);
     return {
         attributes: convertAttributes(attributes, ctx),
         desc: DocCommentsNode.asText(docComments),
         identifier: identifier.value,
-        value: convertEnumValue(value, ctx),
+        value: getEnumFieldValue(value, ctx),
     };
 }
-function convertEnumValue(node, ctx) {
-    if (TypedNumberNode.is(node)) {
-        const { value } = TypedNumberNode.destruct(node);
-        return value.value;
+function convertEnumIntValue(expected, expectedSuffix) {
+    return (node, ctx) => {
+        const { value: valueNode, suffix: suffixNode } = TypedNumberNode.is(node)
+            ? TypedNumberNode.destruct(node)
+            : { value: node };
+        const value = Math.floor(typeof valueNode.value === 'string'
+            ? Number.parseFloat(valueNode.value)
+            : Number(valueNode.value));
+        const suffix = suffixNode?.value.toLowerCase();
+        if (suffix !== expectedSuffix || !IntegerNode.is(valueNode)) {
+            ctx.err.report(localize('expected', localize(expected)), node);
+        }
+        return value;
+    };
+}
+function convertEnumFloatValue(expected, expectedSuffix) {
+    return (node, ctx) => {
+        const { value: valueNode, suffix: suffixNode } = TypedNumberNode.is(node)
+            ? TypedNumberNode.destruct(node)
+            : { value: node };
+        const value = typeof valueNode.value === 'string'
+            ? Number.parseFloat(valueNode.value)
+            : Number(valueNode.value);
+        const suffix = suffixNode?.value.toLowerCase();
+        if (suffix !== expectedSuffix
+            && (expectedSuffix !== 'd' || suffix !== undefined || !FloatNode.is(valueNode))) {
+            ctx.err.report(localize('expected', localize(expected)), node);
+        }
+        return value;
+    };
+}
+function convertEnumStringValue(node, ctx) {
+    const { value: valueNode } = TypedNumberNode.is(node)
+        ? TypedNumberNode.destruct(node)
+        : { value: node };
+    const value = typeof valueNode.value === 'string'
+        ? valueNode.value
+        : valueNode.value.toString();
+    if (!StringNode.is(valueNode)) {
+        ctx.err.report(localize('expected', localize('string')), node);
+    }
+    return value;
+}
+function convertEnumLongValue(node, ctx) {
+    const { value: valueNode } = TypedNumberNode.is(node)
+        ? TypedNumberNode.destruct(node)
+        : { value: node };
+    let value = valueNode.value;
+    if (typeof value === 'string') {
+        if (/^-?\d+$/.test(value)) {
+            value = BigInt(value);
+        }
+        else {
+            value = parseFloat(value);
+        }
     }
-    return node.value;
+    if (typeof value === 'number') {
+        if (isNaN(value) || !isFinite(value)) {
+            value = 0n;
+        }
+        else {
+            value = BigInt(Math.floor(value));
+        }
+    }
+    if (!LongNode.is(valueNode)) {
+        ctx.err.report(localize('expected', localize('long')), node);
+    }
+    return value;
+}
+function convertEnumValue(node, ctx) {
+    const { value } = TypedNumberNode.is(node)
+        ? TypedNumberNode.destruct(node)
+        : { value: node };
+    return value.value;
 }
 function convertStruct(node, ctx) {
     const { block, identifier } = StructNode.destruct(node);
@@ -665,13 +782,17 @@ function convertList(node, ctx) {
     return wrapType(node, {
         kind: 'list',
         item: convertType(item, ctx),
-        lengthRange: convertRange(lengthRange, ctx),
+        lengthRange: convertRange(lengthRange),
     }, ctx);
 }
-function convertRange(node, ctx) {
+function convertRange(node) {
     if (!node) {
         return undefined;
     }
+    if (LongRangeNode.is(node)) {
+        const { kind, min, max } = LongRangeNode.destruct(node);
+        return { kind, min: min?.value, max: max?.value };
+    }
     const { kind, min, max } = FloatRangeNode.is(node)
         ? FloatRangeNode.destruct(node)
         : IntRangeNode.destruct(node);
@@ -718,20 +839,20 @@ function convertNumericType(node, ctx) {
     const { numericKind, valueRange } = NumericTypeNode.destruct(node);
     return wrapType(node, {
         kind: numericKind.value,
-        valueRange: convertRange(valueRange, ctx),
+        valueRange: convertRange(valueRange),
     }, ctx);
 }
 function convertPrimitiveArray(node, ctx) {
     const { arrayKind, lengthRange, valueRange } = PrimitiveArrayTypeNode.destruct(node);
     return wrapType(node, {
         kind: `${arrayKind.value}_array`,
-        lengthRange: convertRange(lengthRange, ctx),
-        valueRange: convertRange(valueRange, ctx),
+        lengthRange: convertRange(lengthRange),
+        valueRange: convertRange(valueRange),
     }, ctx);
 }
 function convertString(node, ctx) {
     const { lengthRange } = StringTypeNode.destruct(node);
-    return wrapType(node, { kind: 'string', lengthRange: convertRange(lengthRange, ctx) }, ctx);
+    return wrapType(node, { kind: 'string', lengthRange: convertRange(lengthRange) }, ctx);
 }
 function convertReference(node, ctx) {
     const { path } = ReferenceTypeNode.destruct(node);

package/lib/node/index.d.ts

@@ -1,5 +1,5 @@
 import type { AstNode, ColorTokenType, SymbolBaseNode } from '@spyglassmc/core';
-import { CommentNode, FloatNode, IntegerNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+import { CommentNode, FloatNode, IntegerNode, LongNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
 export interface ModuleNode extends AstNode {
     type: 'mcdoc:module';
     children: TopLevelNode[];
@@ -170,6 +170,18 @@ export declare namespace IntRangeNode {
     };
     function is(node: AstNode | undefined): node is IntRangeNode;
 }
+export interface LongRangeNode extends AstNode {
+    type: 'mcdoc:long_range';
+    children: (LongNode | LiteralNode)[];
+}
+export declare namespace LongRangeNode {
+    function destruct(node: LongRangeNode): {
+        kind: RangeKind;
+        min?: LongNode;
+        max?: LongNode;
+    };
+    function is(node: AstNode | undefined): node is LongRangeNode;
+}
 export interface LiteralTypeNode extends TypeBaseNode<LiteralTypeValueNode> {
     type: 'mcdoc:type/literal';
 }
@@ -185,22 +197,22 @@ export declare namespace LiteralTypeValueNode {
 }
 export interface TypedNumberNode extends AstNode {
     type: 'mcdoc:typed_number';
-    children: (FloatNode | IntegerNode | LiteralNode)[];
+    children: (FloatNode | IntegerNode | LongNode | LiteralNode)[];
 }
 export declare namespace TypedNumberNode {
     function destruct(node: TypedNumberNode): {
-        value: FloatNode | IntegerNode;
+        value: FloatNode | IntegerNode | LongNode;
         suffix?: LiteralNode;
     };
     function is(node: AstNode | undefined): node is TypedNumberNode;
 }
-export interface NumericTypeNode extends TypeBaseNode<LiteralNode | FloatRangeNode | IntRangeNode> {
+export interface NumericTypeNode extends TypeBaseNode<LiteralNode | FloatRangeNode | IntRangeNode | LongRangeNode> {
     type: 'mcdoc:type/numeric_type';
 }
 export declare namespace NumericTypeNode {
     function destruct(node: NumericTypeNode): {
         numericKind: LiteralNode;
-        valueRange?: FloatRangeNode | IntRangeNode;
+        valueRange?: FloatRangeNode | IntRangeNode | LongRangeNode;
     };
     function is(node: AstNode | undefined): node is NumericTypeNode;
 }
@@ -228,14 +240,14 @@ export declare namespace FloatRangeNode {
     };
     function is(node: AstNode | undefined): node is FloatRangeNode;
 }
-export interface PrimitiveArrayTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode> {
+export interface PrimitiveArrayTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode | LongRangeNode> {
     type: 'mcdoc:type/primitive_array';
 }
 export declare namespace PrimitiveArrayTypeNode {
     function destruct(node: PrimitiveArrayTypeNode): {
         arrayKind: LiteralNode;
         lengthRange?: IntRangeNode;
-        valueRange?: IntRangeNode;
+        valueRange?: IntRangeNode | LongRangeNode;
     };
     function is(node: AstNode | undefined): node is PrimitiveArrayTypeNode;
 }
@@ -272,7 +284,7 @@ export interface EnumNode extends TypeBaseNode<DocCommentsNode | LiteralNode | I
 }
 export type EnumKind = typeof EnumNode.Kinds extends Set<infer V> ? V : never;
 export declare namespace EnumNode {
-    const Kinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
+    const Kinds: Set<"byte" | "double" | "float" | "int" | "long" | "short" | "string">;
     function destruct(node: EnumNode): {
         block: EnumBlockNode;
         docComments?: DocCommentsNode;

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { atArray, CommentNode, FloatNode, IntegerNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
+import { CommentNode, FloatNode, IntegerNode, LongNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
 export var ModuleNode;
 (function (ModuleNode) {
     function is(node) {
@@ -233,6 +233,17 @@ export var IntRangeNode;
     }
     IntRangeNode.is = is;
 })(IntRangeNode || (IntRangeNode = {}));
+export var LongRangeNode;
+(function (LongRangeNode) {
+    function destruct(node) {
+        return destructRangeNode(node);
+    }
+    LongRangeNode.destruct = destruct;
+    function is(node) {
+        return node?.type === 'mcdoc:long_range';
+    }
+    LongRangeNode.is = is;
+})(LongRangeNode || (LongRangeNode = {}));
 export var LiteralTypeNode;
 (function (LiteralTypeNode) {
     function destruct(node) {
@@ -255,7 +266,9 @@ export var TypedNumberNode;
 (function (TypedNumberNode) {
     function destruct(node) {
         return {
-            value: node.children.find(FloatNode.is) ?? node.children.find(IntegerNode.is),
+            value: node.children.find(FloatNode.is)
+                ?? node.children.find(IntegerNode.is)
+                ?? node.children.find(LongNode.is),
             suffix: node.children.find(LiteralNode.is),
         };
     }
@@ -270,7 +283,9 @@ export var NumericTypeNode;
     function destruct(node) {
         return {
             numericKind: node.children.find(LiteralNode.is),
-            valueRange: node.children.find(FloatRangeNode.is) || node.children.find(IntRangeNode.is),
+            valueRange: node.children.find(FloatRangeNode.is)
+                || node.children.find(IntRangeNode.is)
+                || node.children.find(LongRangeNode.is),
         };
     }
     NumericTypeNode.destruct = destruct;
@@ -354,6 +369,9 @@ export var PrimitiveArrayTypeNode;
             if (LiteralNode.is(child) && child.value === '[]') {
                 afterBrackets = true;
             }
+            else if (LongRangeNode.is(child)) {
+                valueRange = child;
+            }
             else if (IntRangeNode.is(child)) {
                 if (afterBrackets) {
                     lengthRange = child;
@@ -563,7 +581,7 @@ export var TypeParamNode;
 export var PathNode;
 (function (PathNode) {
     function destruct(node) {
-        const lastChild = atArray(node?.children, -1);
+        const lastChild = node?.children.at(-1);
         return {
             children: node?.children ?? [],
             isAbsolute: node?.isAbsolute,

package/lib/parser/index.d.ts

@@ -1,6 +1,6 @@
-import type { ColorTokenType, CommentNode, FloatNode, InfallibleParser, IntegerNode, Parser, ResourceLocationNode, ResourceLocationOptions, StringNode } from '@spyglassmc/core';
+import type { ColorTokenType, CommentNode, FloatNode, InfallibleParser, IntegerNode, LongNode, Parser, ResourceLocationNode, ResourceLocationOptions, StringNode } from '@spyglassmc/core';
 import { Arrayable } from '@spyglassmc/core';
-import type { AnyTypeNode, AttributeNode, BooleanTypeNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, EnumNode, FloatRangeNode, IdentifierNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, ModuleNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StringTypeNode, StructNode, TupleTypeNode, TypeAliasNode, TypedNumberNode, TypeNode, UnionTypeNode, UseStatementNode } from '../node/index.js';
+import type { AnyTypeNode, AttributeNode, BooleanTypeNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, EnumNode, FloatRangeNode, IdentifierNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, LongRangeNode, ModuleNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StringTypeNode, StructNode, TupleTypeNode, TypeAliasNode, TypedNumberNode, TypeNode, UnionTypeNode, UseStatementNode } from '../node/index.js';
 /**
  * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
  *
@@ -27,6 +27,7 @@ export declare const docComments: InfallibleParser<DocCommentsNode>;
 export declare const dispatchStatement: Parser<DispatchStatementNode>;
 export declare const float: InfallibleParser<FloatNode>;
 export declare const integer: InfallibleParser<IntegerNode>;
+export declare const long: InfallibleParser<LongNode>;
 export declare const LiteralIntSuffixes: readonly ["b", "s", "l"];
 export type LiteralIntSuffix = (typeof LiteralIntSuffixes)[number];
 export declare const LiteralIntCaseInsensitiveSuffixes: readonly ["b", "s", "l", "B", "S", "L"];
@@ -40,6 +41,7 @@ export type LiteralNumberSuffix = (typeof LiteralNumberSuffixes)[number];
 export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "b", "s", "l", "B", "S", "L", "f", "d", "F", "D"];
 export type LiteralNumberCaseInsensitiveSuffix = (typeof LiteralNumberCaseInsensitiveSuffixes)[number];
 export declare const typedNumber: InfallibleParser<TypedNumberNode>;
+export declare const failableTypedNumber: Parser<TypedNumberNode>;
 export declare const enum_: Parser<EnumNode>;
 export declare const struct: Parser<StructNode>;
 export declare const injection: Parser<InjectionNode>;
@@ -49,9 +51,13 @@ export declare const module_: Parser<ModuleNode>;
 export declare const anyType: Parser<AnyTypeNode>;
 export declare const booleanType: Parser<BooleanTypeNode>;
 export declare const intRange: InfallibleParser<IntRangeNode>;
+export declare const longRange: InfallibleParser<LongRangeNode>;
+export declare const floatRange: InfallibleParser<FloatRangeNode>;
+export declare const atIntRange: InfallibleParser<IntRangeNode | undefined>;
+export declare const atLongRange: InfallibleParser<LongRangeNode | undefined>;
+export declare const atFloatRange: InfallibleParser<FloatRangeNode | undefined>;
 export declare const stringType: Parser<StringTypeNode>;
 export declare const literalType: Parser<LiteralTypeNode>;
-export declare const floatRange: InfallibleParser<FloatRangeNode>;
 export declare const numericType: Parser<NumericTypeNode>;
 export declare const primitiveArrayType: Parser<PrimitiveArrayTypeNode>;
 export declare const listType: Parser<ListTypeNode>;

package/lib/parser/index.js

@@ -326,6 +326,9 @@ export const float = core.float({
 export const integer = core.integer({
     pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
 });
+export const long = core.long({
+    pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
+});
 export const LiteralIntSuffixes = Object.freeze(['b', 's', 'l']);
 export const LiteralIntCaseInsensitiveSuffixes = Object.freeze([...LiteralIntSuffixes, 'B', 'S', 'L']);
 export const LiteralFloatSuffixes = Object.freeze(['f', 'd']);
@@ -337,17 +340,37 @@ export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([
     ...LiteralFloatCaseInsensitiveSuffixes,
 ]);
 export const typedNumber = setType('mcdoc:typed_number', select([{
+        regex: /^(?:\+|-)?\d+L/i,
+        parser: sequence([
+            long,
+            optional(failOnEmpty(literal(LiteralIntCaseInsensitiveSuffixes, { colorTokenType: 'keyword' }))),
+        ]),
+    }, {
         regex: /^(?:\+|-)?\d+(?!\d|[.dfe])/i,
         parser: sequence([
             integer,
-            optional(keyword(LiteralIntCaseInsensitiveSuffixes, { colorTokenType: 'keyword' })),
+            optional(failOnEmpty(literal(LiteralIntCaseInsensitiveSuffixes, { colorTokenType: 'keyword' }))),
         ]),
     }, {
         parser: sequence([
             float,
-            optional(keyword(LiteralFloatCaseInsensitiveSuffixes, { colorTokenType: 'keyword' })),
+            optional(failOnEmpty(literal(LiteralFloatCaseInsensitiveSuffixes, { colorTokenType: 'keyword' }))),
         ]),
     }]));
+export const failableTypedNumber = (src, ctx) => {
+    const { updateSrcAndCtx, result, errorAmount } = core.attempt(typedNumber, src, ctx);
+    if (errorAmount > 0) {
+        if (result.children.length !== 2) {
+            return Failure;
+        }
+        const { errorAmount: numberErrors } = core.attempt(float, src, ctx);
+        if (numberErrors > 0) {
+            return Failure;
+        }
+    }
+    updateSrcAndCtx();
+    return result;
+};
 const enumValue = select([{ prefix: '"', parser: string }, {
         parser: typedNumber,
     }]);
@@ -471,14 +494,21 @@ function range(type, number) {
             ]),
         }]));
 }
+function atRange(parser) {
+    return optional((src, ctx) => {
+        if (!src.trySkip('@')) {
+            return Failure;
+        }
+        src.skipWhitespace();
+        return parser(src, ctx);
+    });
+}
 export const intRange = range('mcdoc:int_range', integer);
-const atIntRange = optional((src, ctx) => {
-    if (!src.trySkip('@')) {
-        return Failure;
-    }
-    src.skipWhitespace();
-    return intRange(src, ctx);
-});
+export const longRange = range('mcdoc:long_range', long);
+export const floatRange = range('mcdoc:float_range', float);
+export const atIntRange = atRange(intRange);
+export const atLongRange = atRange(longRange);
+export const atFloatRange = atRange(floatRange);
 export const stringType = typeBase('mcdoc:type/string', syntax([
     keyword('string', { colorTokenType: 'type' }),
     atIntRange,
@@ -489,25 +519,24 @@ export const literalType = typeBase('mcdoc:type/literal', select([
         parser: keyword(['false', 'true'], { colorTokenType: 'type' }),
     },
     { prefix: '"', parser: failOnEmpty(string) },
-    { parser: failOnError(typedNumber) },
+    { parser: failableTypedNumber },
 ]));
-export const floatRange = range('mcdoc:float_range', float);
-const atFloatRange = optional((src, ctx) => {
-    if (!src.trySkip('@')) {
-        return Failure;
-    }
-    src.skipWhitespace();
-    return floatRange(src, ctx);
-});
 export const numericType = typeBase('mcdoc:type/numeric_type', select([{
         predicate: (src) => NumericTypeFloatKinds.some((k) => src.tryPeek(k)),
         parser: syntax([keyword(NumericTypeFloatKinds, { colorTokenType: 'type' }), atFloatRange], true),
+    }, {
+        predicate: (src) => src.tryPeek('long'),
+        parser: syntax([keyword('long', { colorTokenType: 'type' }), atLongRange], true),
     }, {
         parser: syntax([keyword(NumericTypeIntKinds, { colorTokenType: 'type' }), atIntRange], true),
     }]));
 export const primitiveArrayType = typeBase('mcdoc:type/primitive_array', syntax([
-    literal(PrimitiveArrayValueKinds),
-    atIntRange,
+    select([{
+            predicate: (src) => src.tryPeek('long'),
+            parser: syntax([literal('long'), atLongRange], true),
+        }, {
+            parser: syntax([literal(PrimitiveArrayValueKinds), atIntRange], true),
+        }]),
     keyword('[]', { allowedChars: new Set(['[', ']']), colorTokenType: 'type' }),
     atIntRange,
 ]));

package/lib/runtime/attribute/builtin.js

@@ -83,7 +83,8 @@ export function registerBuiltinAttributes(meta) {
             }
             const value = typeDef.value.value;
             return (node, ctx) => {
-                if (value % config !== 0) {
+                const moduloResult = typeof value === 'number' ? value % config : value % BigInt(config);
+                if (moduloResult !== 0 && moduloResult !== 0n) {
                     ctx.err.report(localize('not-divisible-by', value, config), node, core.ErrorSeverity.Warning);
                 }
             };

package/lib/runtime/checker/context.d.ts

@@ -12,7 +12,7 @@ export interface RuntimePair<T> {
     key: RuntimeNode<T>;
     possibleValues: RuntimeNode<T>[];
 }
-export type NodeEquivalenceChecker = (inferredNode: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>, definition: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>) => boolean;
+export type TypeConverter<T> = (node: T, definition: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>) => SimplifiedMcdocTypeNoUnion | undefined;
 export type TypeInfoAttacher<T> = (node: T, definition: SimplifiedMcdocType, description?: string) => void;
 export type NodeAttacher<T> = (node: T, attacher: (node: core.AstNode) => void) => void;
 export type StringAttacher<T> = (node: T, attacher: (node: core.StringBaseNode) => void) => void;
@@ -21,7 +21,7 @@ export type ErrorReporter<T> = (error: McdocRuntimeError<T>) => void;
 export interface McdocCheckerContext<T> extends core.CheckerContext {
     allowMissingKeys: boolean;
     requireCanonical: boolean;
-    isEquivalent: NodeEquivalenceChecker;
+    tryConvertTo: TypeConverter<T>;
     getChildren: ChildrenGetter<T>;
     reportError: ErrorReporter<T>;
     attachTypeInfo?: TypeInfoAttacher<T>;

package/lib/runtime/checker/context.js

@@ -5,7 +5,7 @@ export var McdocCheckerContext;
             ...ctx,
             allowMissingKeys: options.allowMissingKeys ?? false,
             requireCanonical: options.requireCanonical ?? false,
-            isEquivalent: options.isEquivalent ?? (() => false),
+            tryConvertTo: options.tryConvertTo ?? (() => undefined),
             getChildren: options.getChildren ?? (() => []),
             reportError: options.reportError ?? (() => { }),
             attachTypeInfo: options.attachTypeInfo,

package/lib/runtime/checker/index.d.ts

@@ -1,17 +1,13 @@
 import type { CheckerContext, FullResourceLocation } from '@spyglassmc/core';
-import { type EnumKind } from '../../node/index.js';
-import type { EnumType, Index, KeywordType, ListType, LiteralType, NumericType, ParallelIndices, PrimitiveArrayType, StringType, StructType, StructTypePairField, TupleType, UnionType } from '../../type/index.js';
+import type { EnumType, Index, KeywordType, ListType, LiteralType, LongType, NumericType, ParallelIndices, PrimitiveArrayType, StringType, StructType, StructTypePairField, TupleType, UnionType } from '../../type/index.js';
 import { McdocType } from '../../type/index.js';
-import type { NodeEquivalenceChecker, RuntimeNode } from './context.js';
+import type { RuntimeNode, TypeConverter } from './context.js';
 import { McdocCheckerContext } from './context.js';
 import type { McdocRuntimeError } from './error.js';
 export * from './context.js';
 export * from './error.js';
 export type SimplifiedMcdocType = SimplifiedMcdocTypeNoUnion | UnionType<SimplifiedMcdocTypeNoUnion>;
-export type SimplifiedMcdocTypeNoUnion = SimplifiedEnum | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | StringType | SimplifiedStructType | TupleType;
-export interface SimplifiedEnum extends EnumType {
-    enumKind: EnumKind;
-}
+export type SimplifiedMcdocTypeNoUnion = EnumType | KeywordType | ListType | LiteralType | NumericType | LongType | PrimitiveArrayType | StringType | SimplifiedStructType | TupleType;
 export interface SimplifiedStructType extends StructType {
     fields: SimplifiedStructTypePairField[];
 }
@@ -20,7 +16,7 @@ export interface SimplifiedStructTypePairField extends StructTypePairField {
 }
 export declare function reference<T>(node: RuntimeNode<T>[], path: string, ctx: McdocCheckerContext<T>): void;
 export declare function dispatcher<T>(node: RuntimeNode<T>[], registry: FullResourceLocation, index: string | Index | ParallelIndices, ctx: McdocCheckerContext<T>): void;
-export declare function isAssignable(assignValue: McdocType, typeDef: McdocType, ctx: CheckerContext, isEquivalent?: NodeEquivalenceChecker): boolean;
+export declare function isAssignable(assignValue: McdocType, typeDef: McdocType, ctx: CheckerContext, convert?: TypeConverter<McdocType>): boolean;
 export interface CheckerTreeNode<T> {
     parent: CheckerTreeRuntimeNode<T> | undefined;
     runtimeKey: RuntimeNode<T> | undefined;

package/lib/runtime/checker/index.js

@@ -18,7 +18,7 @@ export function dispatcher(node, registry, index, ctx) {
             : [index];
     typeDefinition(node, { kind: 'dispatcher', registry, parallelIndices }, ctx);
 }
-export function isAssignable(assignValue, typeDef, ctx, isEquivalent) {
+export function isAssignable(assignValue, typeDef, ctx, convert) {
     if (assignValue.kind === 'literal' && typeDef.kind === 'literal'
         && assignValue.value.kind === typeDef.value.kind
         && !assignValue.attributes && !typeDef.attributes) {
@@ -26,18 +26,27 @@ export function isAssignable(assignValue, typeDef, ctx, isEquivalent) {
     }
     let ans = true;
     const newCtx = McdocCheckerContext.create(ctx, {
-        isEquivalent,
+        tryConvertTo: convert,
         getChildren: (_, d) => {
             switch (d.kind) {
                 case 'list':
                     const vals = getPossibleTypes(d.item);
                     return [vals.map(v => ({ originalNode: v, inferredType: v }))];
                 case 'byte_array':
-                    return [[{ originalNode: { kind: 'byte' }, inferredType: { kind: 'byte' } }]];
+                    return [[{
+                                originalNode: { kind: 'byte' },
+                                inferredType: { kind: 'byte' },
+                            }]];
                 case 'int_array':
-                    return [[{ originalNode: { kind: 'int' }, inferredType: { kind: 'int' } }]];
+                    return [[{
+                                originalNode: { kind: 'int' },
+                                inferredType: { kind: 'int' },
+                            }]];
                 case 'long_array':
-                    return [[{ originalNode: { kind: 'long' }, inferredType: { kind: 'long' } }]];
+                    return [[{
+                                originalNode: { kind: 'long' },
+                                inferredType: { kind: 'long' },
+                            }]];
                 case 'struct':
                     return d.fields.map(f => {
                         const vals = getPossibleTypes(f.type);
@@ -92,6 +101,10 @@ export function typeDefinition(runtimeValues, typeDef, ctx) {
         const validRootDefinitions = simplifiedRoot.kind === 'union'
             ? simplifiedRoot.members
             : [simplifiedRoot];
+        if (validRootDefinitions.length === 0
+            && (typeDef.kind !== 'union' || typeDef.members.length > 0)) {
+            validRootDefinitions.push({ kind: 'any' });
+        }
         value.definitionsByParent = [{
                 parents: [],
                 keyDefinition: undefined,
@@ -274,9 +287,13 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
         return { childDefinitions, errors: [] };
     }
     const typeDefValueType = getValueType(typeDef);
-    const runtimeValueType = getValueType(simplifiedInferred);
-    if (runtimeValueType.kind !== typeDefValueType.kind
-        && !ctx.isEquivalent(runtimeValueType, typeDefValueType)) {
+    let runtimeValueType = getValueType(simplifiedInferred);
+    if (runtimeValueType.kind !== typeDefValueType.kind) {
+        simplifiedInferred = ctx.tryConvertTo(runtimeNode.originalNode, typeDefValueType)
+            ?? simplifiedInferred;
+        runtimeValueType = getValueType(simplifiedInferred);
+    }
+    if (runtimeValueType.kind !== typeDefValueType.kind) {
         return {
             childDefinitions,
             errors: [{ kind: 'type_mismatch', node: runtimeNode, expected: [typeDef] }],
@@ -313,7 +330,8 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
         case 'double':
             if (typeDef.valueRange
                 && simplifiedInferred.kind === 'literal'
-                && typeof simplifiedInferred.value.value === 'number'
+                && simplifiedInferred.value.kind !== 'string'
+                && simplifiedInferred.value.kind !== 'boolean'
                 && !NumericRange.isInRange(typeDef.valueRange, simplifiedInferred.value.value)) {
                 errors.push({
                     kind: 'number_out_of_range',
@@ -373,14 +391,22 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
                 }
                 if (!foundMatch) {
                     for (const kvp of otherKvps) {
-                        if (isAssignable(kvp.value.key.inferredType, pair.key, ctx, ctx.isEquivalent)) {
+                        if (isAssignable(kvp.value.key.inferredType, pair.key, ctx, (type, target) => type === kvp.value.key.inferredType
+                            ? ctx.tryConvertTo(kvp.value.key.originalNode, target)
+                            : undefined)) {
                             foundMatch = true;
                             otherKvpMatches.push(kvp.index);
                         }
                     }
                     for (const kvp of literalKvps.entries()) {
+                        const literalType = {
+                            kind: 'literal',
+                            value: { kind: 'string', value: kvp[0] },
+                        };
                         if ((!kvp[1].definition || kvp[1].definition.keyType?.kind !== 'literal')
-                            && isAssignable({ kind: 'literal', value: { kind: 'string', value: kvp[0] } }, pair.key, ctx, ctx.isEquivalent)) {
+                            && kvp[1].values.some(v => isAssignable(literalType, pair.key, ctx, (type, target) => type === literalType
+                                ? ctx.tryConvertTo(v.pair.key.originalNode, target)
+                                : undefined))) {
                             foundMatch = true;
                             kvp[1].definition = { keyType: pair.key, type: pair.type, desc: pair.desc };
                         }
@@ -903,7 +929,7 @@ function simplifyTuple(typeDef, context) {
 }
 function simplifyEnum(typeDef, context) {
     const filteredValues = typeDef.values.filter(value => shouldKeepAccordingToAttributeFilters(value.attributes, context.ctx));
-    return { typeDef: { ...typeDef, enumKind: typeDef.enumKind ?? 'int', values: filteredValues } };
+    return { typeDef: { ...typeDef, values: filteredValues } };
 }
 function simplifyConcrete(typeDef, context) {
     let dynamicData = false;
@@ -947,6 +973,9 @@ function getValueType(type) {
         case 'literal':
             return { kind: type.value.kind };
         case 'enum':
+            if (type.enumKind === undefined) {
+                return { kind: 'any' };
+            }
             return { kind: type.enumKind };
         default:
             return type;

package/lib/type/index.d.ts

@@ -1,5 +1,4 @@
 import type { FullResourceLocation } from '@spyglassmc/core';
-import type { EnumKind } from '../node/index.js';
 import { RangeKind } from '../node/index.js';
 export type Attributes = Attribute[];
 export declare namespace Attributes {
@@ -23,15 +22,15 @@ export interface AttributeTree {
 export declare namespace AttributeValue {
     function equals(a: AttributeValue, b: AttributeValue): boolean;
 }
-export type NumericRange = {
+export interface NumericRange<T extends (number | bigint) = (number | bigint)> {
     kind: RangeKind;
-    min?: number;
-    max?: number;
-};
+    min?: T;
+    max?: T;
+}
 export declare namespace NumericRange {
-    function isInRange(range: NumericRange, val: number): boolean;
+    function isInRange<T extends (number | bigint) = (number | bigint)>(range: NumericRange<T>, val: T): boolean;
     function equals(a: NumericRange, b: NumericRange): boolean;
-    function intersect(a: NumericRange, b: NumericRange): NumericRange;
+    function intersect<T extends (number | bigint) = number>(a: NumericRange<T>, b: NumericRange<T>): NumericRange<T>;
     function toString({ kind, min, max }: NumericRange): string;
 }
 export declare const StaticIndexKeywords: readonly ["fallback", "none", "unknown", "spawnitem", "blockitem"];
@@ -78,14 +77,29 @@ export interface StructTypeSpreadField extends McdocBaseType {
     kind: 'spread';
     type: McdocType;
 }
-export interface EnumType extends McdocBaseType {
+export type EnumType = NumberEnumType | LongEnumType | StringEnumType | InvalidEnumType;
+interface EnumTypeBase extends McdocBaseType {
     kind: 'enum';
-    enumKind?: EnumKind;
-    values: EnumTypeField[];
 }
-export interface EnumTypeField extends McdocBaseType {
+interface NumberEnumType extends EnumTypeBase {
+    enumKind: 'byte' | 'short' | 'int' | 'float' | 'double';
+    values: EnumTypeField<number>[];
+}
+interface LongEnumType extends EnumTypeBase {
+    enumKind: 'long';
+    values: EnumTypeField<bigint>[];
+}
+interface StringEnumType extends EnumTypeBase {
+    enumKind: 'string';
+    values: EnumTypeField<string>[];
+}
+interface InvalidEnumType extends EnumTypeBase {
+    enumKind: undefined;
+    values: EnumTypeField<string | number | bigint>[];
+}
+export interface EnumTypeField<T> extends McdocBaseType {
     identifier: string;
-    value: string | number;
+    value: T;
     desc?: string;
 }
 export interface ReferenceType extends McdocBaseType {
@@ -127,9 +141,9 @@ export interface KeywordType extends McdocBaseType {
 }
 export interface StringType extends McdocBaseType {
     kind: 'string';
-    lengthRange?: NumericRange;
+    lengthRange?: NumericRange<number>;
 }
-export type LiteralValue = LiteralBooleanValue | LiteralStringValue | LiteralNumericValue;
+export type LiteralValue = LiteralBooleanValue | LiteralStringValue | LiteralNumericValue | LiteralLongNumberValue;
 export interface LiteralBooleanValue {
     kind: 'boolean';
     value: boolean;
@@ -139,16 +153,27 @@ export interface LiteralStringValue {
     value: string;
 }
 export interface LiteralNumericValue {
-    kind: NumericTypeKind;
+    kind: Exclude<NumericTypeKind, 'long'>;
     value: number;
 }
+export interface LiteralLongNumberValue {
+    kind: 'long';
+    value: bigint;
+}
+export declare namespace LiteralNumericValue {
+    function makeIfValid(kind: string, value: number | bigint, allowInt?: boolean, allowFloat?: boolean): LiteralNumericValue | LiteralLongNumberValue | undefined;
+}
 export interface LiteralType extends McdocBaseType {
     kind: 'literal';
     value: LiteralValue;
 }
 export interface NumericType extends McdocBaseType {
-    kind: NumericTypeKind;
-    valueRange?: NumericRange;
+    kind: Exclude<NumericTypeKind, 'long'>;
+    valueRange?: NumericRange<number>;
+}
+export interface LongType extends McdocBaseType {
+    kind: 'long';
+    valueRange?: NumericRange<bigint>;
 }
 export declare const NumericTypeIntKinds: readonly ["byte", "short", "int", "long"];
 export type NumericTypeIntKind = (typeof NumericTypeIntKinds)[number];
@@ -156,10 +181,16 @@ export declare const NumericTypeFloatKinds: readonly ["float", "double"];
 export type NumericTypeFloatKind = (typeof NumericTypeFloatKinds)[number];
 export declare const NumericTypeKinds: readonly ["byte", "short", "int", "long", "float", "double"];
 export type NumericTypeKind = (typeof NumericTypeKinds)[number];
-export interface PrimitiveArrayType extends McdocBaseType {
-    kind: 'byte_array' | 'int_array' | 'long_array';
-    valueRange?: NumericRange;
-    lengthRange?: NumericRange;
+export type PrimitiveArrayType = SmallIntArrayType | LongArrayType;
+export interface SmallIntArrayType extends McdocBaseType {
+    kind: 'byte_array' | 'int_array';
+    valueRange?: NumericRange<number>;
+    lengthRange?: NumericRange<number>;
+}
+export interface LongArrayType extends McdocBaseType {
+    kind: 'long_array';
+    valueRange?: NumericRange<bigint>;
+    lengthRange?: NumericRange<number>;
 }
 export declare const PrimitiveArrayValueKinds: readonly ["byte", "int", "long"];
 export type PrimitiveArrayValueKind = (typeof PrimitiveArrayValueKinds)[number];
@@ -168,7 +199,7 @@ export type PrimitiveArrayKind = (typeof PrimitiveArrayKinds)[number];
 export interface ListType extends McdocBaseType {
     kind: 'list';
     item: McdocType;
-    lengthRange?: NumericRange;
+    lengthRange?: NumericRange<number>;
 }
 export interface TupleType extends McdocBaseType {
     kind: 'tuple';
@@ -177,9 +208,10 @@ export interface TupleType extends McdocBaseType {
 export interface McdocBaseType {
     attributes?: Attributes;
 }
-export type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType | IndexedType | TemplateType | ConcreteType | MappedType;
+export type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | LongType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType | IndexedType | TemplateType | ConcreteType | MappedType;
 export declare namespace McdocType {
     function equals(a: McdocType, b: McdocType): boolean;
     function toString(type: McdocType | undefined): string;
 }
+export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/type/index.js

@@ -1,4 +1,4 @@
-import { Arrayable, Dev } from '@spyglassmc/core';
+import { Arrayable, Dev, max, min, numericEquals } from '@spyglassmc/core';
 import { getRangeDelimiter, RangeKind } from '../node/index.js';
 export var Attributes;
 (function (Attributes) {
@@ -73,35 +73,31 @@ export var NumericRange;
     NumericRange.isInRange = isInRange;
     function equals(a, b) {
         return a.kind === b.kind
-            && a.min === b.min
-            && a.max === b.max;
+            && numericEquals(a.min, b.min)
+            && numericEquals(a.max, b.max);
     }
     NumericRange.equals = equals;
     function intersect(a, b) {
-        const min = a.min !== undefined && b.min !== undefined
-            ? Math.max(a.min, b.min)
-            : a.min !== undefined
-                ? a.min
-                : b.min;
-        const max = a.max !== undefined && b.max !== undefined
-            ? Math.min(a.max, b.max)
-            : a.max !== undefined
-                ? a.max
-                : b.max;
+        const rangeMin = a.min !== undefined && b.min !== undefined
+            ? max(a.min, b.min)
+            : a.min ?? b.min;
+        const rangeMax = a.max !== undefined && b.max !== undefined
+            ? min(a.max, b.max)
+            : a.max ?? b.max;
         let kind = 0b00;
-        if (min === a.min && RangeKind.isLeftExclusive(a.kind)) {
+        if (numericEquals(rangeMin, a.min) && RangeKind.isLeftExclusive(a.kind)) {
             kind |= 0b10;
         }
-        else if (min === b.min && RangeKind.isLeftExclusive(b.kind)) {
+        else if (numericEquals(rangeMin, b.min) && RangeKind.isLeftExclusive(b.kind)) {
             kind |= 0b10;
         }
-        if (max === a.max && RangeKind.isRightExclusive(a.kind)) {
+        if (numericEquals(rangeMax, a.max) && RangeKind.isRightExclusive(a.kind)) {
             kind |= 0b01;
         }
-        else if (max === b.max && RangeKind.isRightExclusive(b.kind)) {
+        else if (numericEquals(rangeMax, b.max) && RangeKind.isRightExclusive(b.kind)) {
             kind |= 0b01;
         }
-        return { kind: kind, min, max };
+        return { kind: kind, min: rangeMin, max: rangeMax };
     }
     NumericRange.intersect = intersect;
     function toString({ kind, min, max }) {
@@ -154,6 +150,46 @@ export function createEmptyUnion(attributes) {
         // attributes,
     };
 }
+export var LiteralNumericValue;
+(function (LiteralNumericValue) {
+    function makeIfValid(kind, value, allowInt = true, allowFloat = true) {
+        value = Number(value);
+        switch (kind) {
+            case 'byte':
+                if (allowInt && value >= -128 && value < 128) {
+                    return { kind: 'byte', value };
+                }
+                break;
+            case 'short':
+                if (allowInt && value >= -32768 && value < 32768) {
+                    return { kind: 'short', value };
+                }
+                break;
+            case 'int':
+                if (allowInt && value >= -2147483648 && value < 2147483648) {
+                    return { kind: 'int', value };
+                }
+                break;
+            case 'long':
+                if (allowInt && value >= -9223372036854775808n && value < 9223372036854775808n) {
+                    return { kind: 'long', value: BigInt(value) };
+                }
+                break;
+            case 'float':
+                if (allowFloat) {
+                    return { kind: 'float', value };
+                }
+                break;
+            case 'double':
+                if (allowFloat) {
+                    return { kind: 'double', value };
+                }
+                break;
+        }
+        return undefined;
+    }
+    LiteralNumericValue.makeIfValid = makeIfValid;
+})(LiteralNumericValue || (LiteralNumericValue = {}));
 export const NumericTypeIntKinds = Object.freeze(['byte', 'short', 'int', 'long']);
 export const NumericTypeFloatKinds = Object.freeze(['float', 'double']);
 export const NumericTypeKinds = Object.freeze([...NumericTypeIntKinds, ...NumericTypeFloatKinds]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.49",
+  "version": "0.3.51",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.45",
-    "@spyglassmc/locales": "0.3.23"
+    "@spyglassmc/core": "0.4.47",
+    "@spyglassmc/locales": "0.3.24"
   }
 }