@spyglassmc/mcdoc 0.3.48 → 0.3.50

package/lib/binder/index.js

@@ -1,6 +1,6 @@
-import { AsyncBinder, atArray, Dev, ErrorSeverity, Range, ResourceLocationNode, SymbolUtil, traversePreOrder, } from '@spyglassmc/core';
+import { AsyncBinder, atArray, 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) {
@@ -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<"string" | "long" | "float" | "byte" | "short" | "int" | "double">;
     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 { atArray, 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;

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/index.d.ts

@@ -1,6 +1,5 @@
 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 { McdocCheckerContext } from './context.js';
@@ -8,10 +7,7 @@ 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[];
 }

package/lib/runtime/checker/index.js

@@ -92,6 +92,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,
@@ -313,7 +317,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',
@@ -903,7 +908,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 +952,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,24 @@ export interface LiteralStringValue {
     value: string;
 }
 export interface LiteralNumericValue {
-    kind: NumericTypeKind;
+    kind: Exclude<NumericTypeKind, 'long'>;
     value: number;
 }
+export interface LiteralLongNumberValue {
+    kind: 'long';
+    value: bigint;
+}
 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 +178,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 +196,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 +205,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 }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.48",
+  "version": "0.3.50",
   "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.44",
-    "@spyglassmc/locales": "0.3.23"
+    "@spyglassmc/core": "0.4.46",
+    "@spyglassmc/locales": "0.3.24"
   }
 }