@spyglassmc/nbt 0.3.1 → 0.3.3

package/lib/checker/index.d.ts

@@ -11,9 +11,9 @@ declare global {
     }
 }
 /**
-* @param id If the registry is under the `custom` namespace, `id` can only be a string. Otherwise it can be a string, string array, or `undefined`.
-* If set to `undefined` or an empty array, all mcdoc compound definitions for this registry will be merged for checking, and unknown keys are allowed.
-*/
+ * @param id If the registry is under the `custom` namespace, `id` can only be a string. Otherwise it can be a string, string array, or `undefined`.
+ * If set to `undefined` or an empty array, all mcdoc compound definitions for this registry will be merged for checking, and unknown keys are allowed.
+ */
 export declare function index(registry: string, id: core.FullResourceLocation | readonly core.FullResourceLocation[] | undefined, options?: Options): core.SyncChecker<NbtCompoundNode>;
 export declare function index(registry: string, id: core.FullResourceLocation, options?: Options): core.SyncChecker<NbtCompoundNode>;
 /**
@@ -21,10 +21,7 @@ export declare function index(registry: string, id: core.FullResourceLocation, o
  */
 export declare function definition(identifier: `::${string}::${string}`, options?: Options): core.SyncChecker<NbtCompoundNode>;
 export declare function blockStates(blocks: string[], _options?: Options): core.SyncChecker<NbtCompoundNode>;
-/**
- * @param path The {@link core.SymbolPath} to the compound definition.
- */
-export declare function compound(data: any, options?: Options): core.SyncChecker<NbtCompoundNode>;
+export declare function compound(typeDef: mcdoc.StructType, options?: Options): core.SyncChecker<NbtCompoundNode>;
 export declare function enum_(path: core.SymbolPath | undefined, _options?: Options): core.SyncChecker<NbtPrimitiveNode>;
 /**
  * @param id If set to `undefined` or an empty array, all mcdoc compound definitions for this registry will be merged for checking, and unknown keys are allowed.

package/lib/checker/index.js

@@ -3,14 +3,12 @@ import { localeQuote, localize } from '@spyglassmc/locales';
 import * as mcdoc from '@spyglassmc/mcdoc';
 import { NbtListNode } from '../node/index.js';
 import { localizeTag } from '../util.js';
-import { getBlocksFromItem, getEntityFromItem, getSpecialStringParser } from './mcdocUtil.js';
+import { getBlocksFromItem, getEntityFromItem, getSpecialStringParser, } from './mcdocUtil.js';
 export function index(registry, id, options = {}) {
     switch (registry) {
         case 'custom:blockitemstates':
             const blockIds = getBlocksFromItem(id);
-            return blockIds
-                ? blockStates(blockIds, options)
-                : core.checker.noop;
+            return blockIds ? blockStates(blockIds, options) : core.checker.noop;
         case 'custom:blockstates':
             return blockStates([id], options);
         case 'custom:spawnitemtag':
@@ -19,25 +17,44 @@ export function index(registry, id, options = {}) {
                 ? index('entity_type', entityId, options)
                 : core.checker.noop;
         default:
+            const identifier = getRegistryIdentifier(registry);
+            if (!identifier) {
+                return core.checker.noop;
+            }
             return (node, ctx) => {
-                // const { allowUnknownKey, value } = resolveRootRegistry(registry, id, ctx, node)
-                // options.allowUnknownKey ||= allowUnknownKey
-                // compound(value, options)(node, ctx)
+                definition(identifier, options)(node, ctx);
             };
     }
 }
+function getRegistryIdentifier(registry) {
+    switch (registry) {
+        case 'block':
+            return '::java::server::world::block::BlockEntity';
+        case 'entity_type':
+            return '::java::server::world::entity::AnyEntity';
+        case 'item':
+            return '::java::server::world::item::AnyItem';
+        default:
+            return undefined;
+    }
+}
 /**
  * @param identifier An identifier of mcdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
  */
 export function definition(identifier, options = {}) {
-    const index = identifier.lastIndexOf('::');
-    const module = identifier.slice(0, index);
-    const compoundDef = identifier.slice(index + 2);
-    const path = { category: 'mcdoc', path: [module, compoundDef] };
     return (node, ctx) => {
-        // const { allowUnknownKey, value } = resolveSymbolPaths([path], ctx, node)
-        // options.allowUnknownKey ||= allowUnknownKey
-        // compound(value, options)(node, ctx)
+        const symbol = ctx.symbols.query(ctx.doc, 'mcdoc', identifier);
+        const typeDef = symbol.getData(mcdoc.binder.TypeDefSymbolData.is)?.typeDef;
+        if (!typeDef) {
+            return;
+        }
+        switch (typeDef.kind) {
+            case 'struct':
+                compound(typeDef, options)(node, ctx);
+                break;
+            default:
+                ctx.logger.error(`[nbt.checker.definition] Expected a struct type, but got ${typeDef.kind}`);
+        }
     };
 }
 export function blockStates(blocks, _options = {}) {
@@ -48,7 +65,9 @@ export function blockStates(blocks, _options = {}) {
                 continue;
             }
             // Type check.
-            if (valueNode.type === 'nbt:byte' && (ctx.src.slice(valueNode.range).toLowerCase() === 'false' || ctx.src.slice(valueNode.range).toLowerCase() === 'true')) {
+            if (valueNode.type === 'nbt:byte' &&
+                (ctx.src.slice(valueNode.range).toLowerCase() === 'false' ||
+                    ctx.src.slice(valueNode.range).toLowerCase() === 'true')) {
                 ctx.err.report(localize('nbt.checker.block-states.fake-boolean'), valueNode, 2 /* core.ErrorSeverity.Warning */);
                 continue;
             }
@@ -70,25 +89,25 @@ export function blockStates(blocks, _options = {}) {
         }
     };
 }
-/**
- * @param path The {@link core.SymbolPath} to the compound definition.
- */
-export function compound(data, options = {}) {
+export function compound(typeDef, options = {}) {
     return (node, ctx) => {
         for (const { key: keyNode, value: valueNode } of node.children) {
             if (!keyNode || !valueNode) {
                 continue;
             }
             const key = keyNode.value;
-            const fieldData = data[key];
-            if (fieldData) {
-                fieldData.query.enter({ usage: { type: 'reference', node: keyNode } });
-                fieldValue(fieldData.data, options)(valueNode, ctx);
+            // TODO: handle spread types
+            const fieldDef = typeDef.fields.find((p) => p.kind === 'pair' && p.key === key);
+            if (fieldDef) {
+                // TODO: enter a reference to the mcdoc key
+                fieldValue(fieldDef.type, options)(valueNode, ctx);
             }
             else if (!options.allowUnknownKey) {
                 ctx.err.report(localize('unknown-key', localeQuote(key)), keyNode, 2 /* core.ErrorSeverity.Warning */);
             }
         }
+        // TODO: check for required fields
+        // requires an update to vanilla-mcdoc to make most fields optional
     };
 }
 export function enum_(path, _options = {}) {
@@ -243,7 +262,8 @@ export function path(registry, id) {
 export function fieldValue(type, options) {
     const isInRange = (value, { kind, min = -Infinity, max = Infinity }) => {
         const comparator = (a, b, exclusive) => exclusive ? a < b : a <= b;
-        return comparator(min, value, kind & 0b10) && comparator(value, max, kind & 0b01);
+        return (comparator(min, value, kind & 0b10) &&
+            comparator(value, max, kind & 0b01));
     };
     const ExpectedTypes = {
         boolean: 'nbt:byte',
@@ -263,7 +283,18 @@ export function fieldValue(type, options) {
     };
     return (node, ctx) => {
         // Rough type check.
-        if (type.kind !== 'any' && type.kind !== 'dispatcher' && type.kind !== 'enum' && type.kind !== 'literal' && type.kind !== 'reference' && type.kind !== 'union' && node.type !== ExpectedTypes[type.kind]) {
+        if (type.kind !== 'any' &&
+            type.kind !== 'dispatcher' &&
+            type.kind !== 'enum' &&
+            type.kind !== 'literal' &&
+            type.kind !== 'reference' &&
+            type.kind !== 'union' &&
+            type.kind !== 'attributed' &&
+            type.kind !== 'unsafe' &&
+            type.kind !== 'concrete' &&
+            type.kind !== 'indexed' &&
+            type.kind !== 'template' &&
+            node.type !== ExpectedTypes[type.kind]) {
             ctx.err.report(localize('expected', localizeTag(ExpectedTypes[type.kind])), node, 2 /* core.ErrorSeverity.Warning */);
             return;
         }
@@ -278,12 +309,14 @@ export function fieldValue(type, options) {
             case 'int_array':
             case 'long_array':
                 node = node;
-                if (type.lengthRange && !isInRange(node.children.length, type.lengthRange)) {
+                if (type.lengthRange &&
+                    !isInRange(node.children.length, type.lengthRange)) {
                     ctx.err.report(localize('expected', localize('nbt.checker.collection.length-between', localizeTag(node.type), type.lengthRange.min ?? '-∞', type.lengthRange.max ?? '+∞')), node, 2 /* core.ErrorSeverity.Warning */);
                 }
                 if (type.valueRange) {
                     for (const { value: childNode } of node.children) {
-                        if (childNode && !isInRange(Number(childNode.value), type.valueRange)) {
+                        if (childNode &&
+                            !isInRange(Number(childNode.value), type.valueRange)) {
                             ctx.err.report(localize('number.between', type.valueRange.min ?? '-∞', type.valueRange.max ?? '+∞'), node, 2 /* core.ErrorSeverity.Warning */);
                         }
                     }
@@ -296,7 +329,8 @@ export function fieldValue(type, options) {
             case 'float':
             case 'double':
                 node = node;
-                if (type.valueRange && !isInRange(Number(node.value), type.valueRange)) {
+                if (type.valueRange &&
+                    !isInRange(Number(node.value), type.valueRange)) {
                     ctx.err.report(localize('number.between', type.valueRange.min ?? '-∞', type.valueRange.max ?? '+∞'), node, 2 /* core.ErrorSeverity.Warning */);
                 }
                 break;
@@ -314,7 +348,8 @@ export function fieldValue(type, options) {
             case 'list':
                 node = node;
                 type = mcdoc.simplifyListType(type);
-                if (type.lengthRange && !isInRange(node.children.length, type.lengthRange)) {
+                if (type.lengthRange &&
+                    !isInRange(node.children.length, type.lengthRange)) {
                     ctx.err.report(localize('expected', localize('nbt.checker.collection.length-between', localizeTag(node.type), type.lengthRange.min ?? '-∞', type.lengthRange.max ?? '+∞')), node, 2 /* core.ErrorSeverity.Warning */);
                 }
                 for (const { value: childNode } of node.children) {
@@ -327,12 +362,15 @@ export function fieldValue(type, options) {
                 node = node;
                 let suffix = '';
                 let valueNode = node;
-                if (core.ItemNode.is(node.parent) && NbtListNode.is(node.parent.parent)) {
+                if (core.ItemNode.is(node.parent) &&
+                    NbtListNode.is(node.parent.parent)) {
                     suffix = '[]';
                     valueNode = node.parent.parent;
                 }
                 if (core.PairNode.is(valueNode.parent)) {
-                    const structMcdocPath = valueNode.parent.key?.symbol?.parentSymbol?.path.join('::');
+                    const structMcdocPath = valueNode.parent.key?.symbol
+                        ?.parentSymbol
+                        ?.path.join('::');
                     const key = valueNode.parent.key?.value;
                     const path = `${structMcdocPath}.${key}${suffix}`;
                     const parserName = getSpecialStringParser(path);
@@ -362,13 +400,18 @@ export function fieldValue(type, options) {
                 type = mcdoc.flattenUnionType(type);
                 if (type.members.length === 0) {
                     ctx.err.report(localize('nbt.checker.compound.field.union-empty-members'), core.PairNode.is(node.parent)
-                        ? (node.parent.key ?? node.parent)
+                        ? node.parent.key ?? node.parent
                         : node, 2 /* core.ErrorSeverity.Warning */);
                 }
                 else {
-                    core.checker.any(type.members.map(t => fieldValue(t, options)))(node, ctx);
+                    ;
+                    core.checker.any(type.members.map((t) => fieldValue(t, options)))(node, ctx);
                 }
                 break;
+            case 'attributed':
+                // TODO: don't just ignore the attribute
+                fieldValue(type.child, options)(node, ctx);
+                break;
         }
     };
 }

package/lib/checker/mcdocUtil.js

@@ -63,10 +63,7 @@ const BlockItems = {
         'minecraft:dead_tube_coral_wall_fan',
     ],
     // Torches.
-    'minecraft:torch': [
-        'minecraft:torch',
-        'minecraft:wall_torch',
-    ],
+    'minecraft:torch': ['minecraft:torch', 'minecraft:wall_torch'],
     'minecraft:soul_torch': [
         'minecraft:soul_torch',
         'minecraft:soul_wall_torch',
@@ -75,39 +72,17 @@ const BlockItems = {
         'minecraft:redstone_torch',
         'minecraft:redstone_wall_torch',
     ],
-    'minecraft:beetroot_seeds': [
-        'minecraft:beetroots',
-    ],
-    'minecraft:carrot': [
-        'minecraft:carrots',
-    ],
-    'minecraft:cocoa_beans': [
-        'minecraft:cocoa',
-    ],
-    'minecraft:glow_berries': [
-        'minecraft:cave_vines',
-    ],
-    'minecraft:melon_seeds': [
-        'minecraft:melon_stem',
-    ],
-    'minecraft:potato': [
-        'minecraft:potatoes',
-    ],
-    'minecraft:pumpkin_seeds': [
-        'minecraft:pumpkin_stem',
-    ],
-    'minecraft:redstone': [
-        'minecraft:redstone_wire',
-    ],
-    'minecraft:string': [
-        'minecraft:tripwire',
-    ],
-    'minecraft:sweat_berries': [
-        'minecraft:sweat_berry_bush',
-    ],
-    'minecraft:wheat_seeds': [
-        'minecraft:wheat',
-    ],
+    'minecraft:beetroot_seeds': ['minecraft:beetroots'],
+    'minecraft:carrot': ['minecraft:carrots'],
+    'minecraft:cocoa_beans': ['minecraft:cocoa'],
+    'minecraft:glow_berries': ['minecraft:cave_vines'],
+    'minecraft:melon_seeds': ['minecraft:melon_stem'],
+    'minecraft:potato': ['minecraft:potatoes'],
+    'minecraft:pumpkin_seeds': ['minecraft:pumpkin_stem'],
+    'minecraft:redstone': ['minecraft:redstone_wire'],
+    'minecraft:string': ['minecraft:tripwire'],
+    'minecraft:sweat_berries': ['minecraft:sweat_berry_bush'],
+    'minecraft:wheat_seeds': ['minecraft:wheat'],
 };
 export function getBlocksFromItem(item) {
     return BlockItems[item];

package/lib/node/index.d.ts

@@ -1,18 +1,18 @@
 import * as core from '@spyglassmc/core';
 import type * as mcdoc from '@spyglassmc/mcdoc';
-export declare type NbtNode = NbtPrimitiveNode | NbtCompoundNode | NbtCollectionNode;
+export type NbtNode = NbtPrimitiveNode | NbtCompoundNode | NbtCollectionNode;
 export declare namespace NbtNode {
     function is(node: core.AstNode | undefined): node is NbtNode;
 }
-export declare type NbtPrimitiveNode = NbtNumberNode | core.StringNode;
+export type NbtPrimitiveNode = NbtNumberNode | core.StringNode;
 export declare namespace NbtPrimitiveNode {
     function is(node: core.AstNode | undefined): node is NbtPrimitiveNode;
 }
-export declare type NbtNumberNode = NbtIntegerAlikeNode | NbtFloatAlikeNode;
+export type NbtNumberNode = NbtIntegerAlikeNode | NbtFloatAlikeNode;
 export declare namespace NbtNumberNode {
     function is(node: core.AstNode | undefined): node is NbtNumberNode;
 }
-export declare type NbtIntegerAlikeNode = NbtByteNode | NbtShortNode | NbtIntNode | NbtLongNode;
+export type NbtIntegerAlikeNode = NbtByteNode | NbtShortNode | NbtIntNode | NbtLongNode;
 export declare namespace NbtIntegerAlikeNode {
     function is(node: core.AstNode | undefined): node is NbtIntegerAlikeNode;
 }
@@ -40,7 +40,7 @@ export interface NbtLongNode extends core.LongBaseNode {
 export declare namespace NbtLongNode {
     function is(node: core.AstNode | undefined): node is NbtLongNode;
 }
-export declare type NbtFloatAlikeNode = NbtFloatNode | NbtDoubleNode;
+export type NbtFloatAlikeNode = NbtFloatNode | NbtDoubleNode;
 export declare namespace NbtFloatAlikeNode {
     function is(node: core.AstNode | undefined): node is NbtFloatAlikeNode;
 }
@@ -62,7 +62,7 @@ export interface NbtCompoundNode extends core.RecordBaseNode<core.StringNode, Nb
 export declare namespace NbtCompoundNode {
     function is(node: core.AstNode | undefined): node is NbtCompoundNode;
 }
-export declare type NbtCollectionNode = NbtListNode | NbtPrimitiveArrayNode;
+export type NbtCollectionNode = NbtListNode | NbtPrimitiveArrayNode;
 export declare namespace NbtCollectionNode {
     function is(node: core.AstNode | undefined): node is NbtCollectionNode;
 }
@@ -73,7 +73,7 @@ export interface NbtListNode extends core.ListNode<NbtNode> {
 export declare namespace NbtListNode {
     function is(node: core.AstNode | undefined): node is NbtListNode;
 }
-export declare type NbtPrimitiveArrayNode = NbtByteArrayNode | NbtIntArrayNode | NbtLongArrayNode;
+export type NbtPrimitiveArrayNode = NbtByteArrayNode | NbtIntArrayNode | NbtLongArrayNode;
 export declare namespace NbtPrimitiveArrayNode {
     function is(node: core.AstNode | undefined): node is NbtPrimitiveArrayNode;
 }

package/lib/node/index.js

@@ -3,7 +3,9 @@ export var NbtNode;
 (function (NbtNode) {
     /* istanbul ignore next */
     function is(node) {
-        return NbtPrimitiveNode.is(node) || NbtCompoundNode.is(node) || NbtCollectionNode.is(node);
+        return (NbtPrimitiveNode.is(node) ||
+            NbtCompoundNode.is(node) ||
+            NbtCollectionNode.is(node));
     }
     NbtNode.is = is;
 })(NbtNode || (NbtNode = {}));
@@ -27,7 +29,10 @@ export var NbtIntegerAlikeNode;
 (function (NbtIntegerAlikeNode) {
     /* istanbul ignore next */
     function is(node) {
-        return NbtByteNode.is(node) || NbtShortNode.is(node) || NbtIntNode.is(node) || NbtLongNode.is(node);
+        return (NbtByteNode.is(node) ||
+            NbtShortNode.is(node) ||
+            NbtIntNode.is(node) ||
+            NbtLongNode.is(node));
     }
     NbtIntegerAlikeNode.is = is;
 })(NbtIntegerAlikeNode || (NbtIntegerAlikeNode = {}));
@@ -115,7 +120,9 @@ export var NbtPrimitiveArrayNode;
 (function (NbtPrimitiveArrayNode) {
     /* istanbul ignore next */
     function is(node) {
-        return NbtByteArrayNode.is(node) || NbtIntArrayNode.is(node) || NbtLongArrayNode.is(node);
+        return (NbtByteArrayNode.is(node) ||
+            NbtIntArrayNode.is(node) ||
+            NbtLongArrayNode.is(node));
     }
     NbtPrimitiveArrayNode.is = is;
 })(NbtPrimitiveArrayNode || (NbtPrimitiveArrayNode = {}));

package/lib/parser/collection.js

@@ -4,7 +4,13 @@ import { localizeTag } from '../util.js';
 import { entry } from './entry.js';
 import { primitive } from './primitive.js';
 export const list = (src, ctx) => {
-    const parser = core.list({ start: '[', value: entry, sep: ',', trailingSep: false, end: ']' });
+    const parser = core.list({
+        start: '[',
+        value: entry,
+        sep: ',',
+        trailingSep: false,
+        end: ']',
+    });
     const ans = parser(src, ctx);
     ans.type = 'nbt:list';
     ans.valueType = ans.children[0]?.value?.type;
@@ -19,7 +25,13 @@ export const list = (src, ctx) => {
     return ans;
 };
 export const byteArray = (src, ctx) => {
-    const parser = core.list({ start: '[B;', value: primitive, sep: ',', trailingSep: false, end: ']' });
+    const parser = core.list({
+        start: '[B;',
+        value: primitive,
+        sep: ',',
+        trailingSep: false,
+        end: ']',
+    });
     const ans = parser(src, ctx);
     ans.type = 'nbt:byte_array';
     // Check if every element is of the required type.
@@ -31,7 +43,13 @@ export const byteArray = (src, ctx) => {
     return ans;
 };
 export const intArray = (src, ctx) => {
-    const parser = core.list({ start: '[I;', value: primitive, sep: ',', trailingSep: false, end: ']' });
+    const parser = core.list({
+        start: '[I;',
+        value: primitive,
+        sep: ',',
+        trailingSep: false,
+        end: ']',
+    });
     const ans = parser(src, ctx);
     ans.type = 'nbt:int_array';
     // Check if every element is of the required type.
@@ -43,7 +61,13 @@ export const intArray = (src, ctx) => {
     return ans;
 };
 export const longArray = (src, ctx) => {
-    const parser = core.list({ start: '[L;', value: primitive, sep: ',', trailingSep: false, end: ']' });
+    const parser = core.list({
+        start: '[L;',
+        value: primitive,
+        sep: ',',
+        trailingSep: false,
+        end: ']',
+    });
     const ans = parser(src, ctx);
     ans.type = 'nbt:long_array';
     // Check if every element is of the required type.

package/lib/parser/compound.js

@@ -4,7 +4,10 @@ export const compound = (src, ctx) => {
     return core.setType('nbt:compound', core.record({
         start: '{',
         pair: {
-            key: core.failOnEmpty(core.string({ ...core.BrigadierStringOptions, colorTokenType: 'property' })),
+            key: core.failOnEmpty(core.string({
+                ...core.BrigadierStringOptions,
+                colorTokenType: 'property',
+            })),
             sep: ':',
             value: entry,
             end: ',',

package/lib/parser/entry.js

@@ -3,11 +3,11 @@ import { byteArray, intArray, list, longArray } from './collection.js';
 import { compound } from './compound.js';
 import { primitive } from './primitive.js';
 export const entry = (src, ctx) => core.failOnEmpty(core.select([
-    { predicate: src => src.tryPeek('[B;'), parser: byteArray },
-    { predicate: src => src.tryPeek('[I;'), parser: intArray },
-    { predicate: src => src.tryPeek('[L;'), parser: longArray },
-    { predicate: src => src.tryPeek('['), parser: list },
-    { predicate: src => src.tryPeek('{'), parser: compound },
+    { predicate: (src) => src.tryPeek('[B;'), parser: byteArray },
+    { predicate: (src) => src.tryPeek('[I;'), parser: intArray },
+    { predicate: (src) => src.tryPeek('[L;'), parser: longArray },
+    { predicate: (src) => src.tryPeek('['), parser: list },
+    { predicate: (src) => src.tryPeek('{'), parser: compound },
     { parser: primitive },
 ]))(src, ctx);
 //# sourceMappingURL=entry.js.map

package/lib/parser/path.js

@@ -51,9 +51,7 @@ const index = (children, src, ctx) => {
     }
     node.range.end = src.cursor;
     children.push(node);
-    return src.trySkip('.')
-        ? ['index', 'key']
-        : ['end', 'index'];
+    return src.trySkip('.') ? ['index', 'key'] : ['end', 'index'];
 };
 const key = (children, src, ctx) => {
     const node = core.string({
@@ -61,12 +59,23 @@ const key = (children, src, ctx) => {
         escapable: {},
         // No single quotes: https://bugs.mojang.com/browse/MC-175504
         quotes: ['"'],
-        unquotable: { blockList: new Set(['\n', '\r', '\t', ' ', '"', '[', ']', '.', '{', '}']) },
+        unquotable: {
+            blockList: new Set([
+                '\n',
+                '\r',
+                '\t',
+                ' ',
+                '"',
+                '[',
+                ']',
+                '.',
+                '{',
+                '}',
+            ]),
+        },
     })(src, ctx);
     children.push(node);
-    return src.trySkip('.')
-        ? ['index', 'key']
-        : ['end', 'filter', 'index'];
+    return src.trySkip('.') ? ['index', 'key'] : ['end', 'filter', 'index'];
 };
 function nextPart(src) {
     switch (src.peek()) {

package/lib/parser/primitive.js

@@ -1,15 +1,64 @@
 import * as core from '@spyglassmc/core';
 import { localize } from '@spyglassmc/locales';
 import { localizeTag } from '../util.js';
-const FloatMaximum = (2 - (2 ** -23)) * (2 ** 127);
+const FloatMaximum = (2 - 2 ** -23) * 2 ** 127;
 const NumeralPatterns = [
-    { pattern: /^[-+]?(?:0|[1-9][0-9]*)b$/i, type: 'nbt:byte', hasSuffix: true, group: 2 /* Group.IntegerAlike */, min: -128, max: 127 },
-    { pattern: /^[-+]?(?:0|[1-9][0-9]*)s$/i, type: 'nbt:short', hasSuffix: true, group: 2 /* Group.IntegerAlike */, min: -32768, max: 32767 },
-    { pattern: /^[-+]?(?:0|[1-9][0-9]*)$/, type: 'nbt:int', hasSuffix: false, group: 2 /* Group.IntegerAlike */, min: -2147483648, max: 2147483647 },
-    { pattern: /^[-+]?(?:0|[1-9][0-9]*)l$/i, type: 'nbt:long', hasSuffix: true, group: 3 /* Group.LongAlike */, min: -9223372036854775808n, max: 9223372036854775807n },
-    { pattern: /^[-+]?(?:[0-9]+\.?|[0-9]*\.[0-9]+)(?:e[-+]?[0-9]+)?f$/i, type: 'nbt:float', hasSuffix: true, group: 1 /* Group.FloatAlike */, min: -FloatMaximum, max: FloatMaximum },
-    { pattern: /^[-+]?(?:[0-9]+\.|[0-9]*\.[0-9]+)(?:e[-+]?[0-9]+)?$/i, type: 'nbt:double', hasSuffix: false, group: 1 /* Group.FloatAlike */, min: -Number.MAX_VALUE, max: Number.MAX_VALUE },
-    { pattern: /^[-+]?(?:[0-9]+\.?|[0-9]*\.[0-9]+)(?:e[-+]?[0-9]+)?d$/i, type: 'nbt:double', hasSuffix: true, group: 1 /* Group.FloatAlike */, min: -Number.MAX_VALUE, max: Number.MAX_VALUE },
+    {
+        pattern: /^[-+]?(?:0|[1-9][0-9]*)b$/i,
+        type: 'nbt:byte',
+        hasSuffix: true,
+        group: 2 /* Group.IntegerAlike */,
+        min: -128,
+        max: 127,
+    },
+    {
+        pattern: /^[-+]?(?:0|[1-9][0-9]*)s$/i,
+        type: 'nbt:short',
+        hasSuffix: true,
+        group: 2 /* Group.IntegerAlike */,
+        min: -32768,
+        max: 32767,
+    },
+    {
+        pattern: /^[-+]?(?:0|[1-9][0-9]*)$/,
+        type: 'nbt:int',
+        hasSuffix: false,
+        group: 2 /* Group.IntegerAlike */,
+        min: -2147483648,
+        max: 2147483647,
+    },
+    {
+        pattern: /^[-+]?(?:0|[1-9][0-9]*)l$/i,
+        type: 'nbt:long',
+        hasSuffix: true,
+        group: 3 /* Group.LongAlike */,
+        min: -9223372036854775808n,
+        max: 9223372036854775807n,
+    },
+    {
+        pattern: /^[-+]?(?:[0-9]+\.?|[0-9]*\.[0-9]+)(?:e[-+]?[0-9]+)?f$/i,
+        type: 'nbt:float',
+        hasSuffix: true,
+        group: 1 /* Group.FloatAlike */,
+        min: -FloatMaximum,
+        max: FloatMaximum,
+    },
+    {
+        pattern: /^[-+]?(?:[0-9]+\.|[0-9]*\.[0-9]+)(?:e[-+]?[0-9]+)?$/i,
+        type: 'nbt:double',
+        hasSuffix: false,
+        group: 1 /* Group.FloatAlike */,
+        min: -Number.MAX_VALUE,
+        max: Number.MAX_VALUE,
+    },
+    {
+        pattern: /^[-+]?(?:[0-9]+\.?|[0-9]*\.[0-9]+)(?:e[-+]?[0-9]+)?d$/i,
+        type: 'nbt:double',
+        hasSuffix: true,
+        group: 1 /* Group.FloatAlike */,
+        min: -Number.MAX_VALUE,
+        max: Number.MAX_VALUE,
+    },
     { pattern: /^true$/i, type: 'nbt:byte', value: 1, group: 0 /* Group.Boolean */ },
     { pattern: /^false$/i, type: 'nbt:byte', value: 0, group: 0 /* Group.Boolean */ },
 ];
@@ -18,7 +67,8 @@ export const primitive = (src, ctx) => {
     if (core.Source.isBrigadierQuote(src.peek())) {
         return string(src, ctx);
     }
-    const { result: unquotedResult, updateSrcAndCtx: updateUnquoted } = core.attempt(string, src, ctx);
+    const { result: unquotedResult, updateSrcAndCtx: updateUnquoted } = core
+        .attempt(string, src, ctx);
     for (const e of NumeralPatterns) {
         if (e.pattern.test(unquotedResult.value)) {
             if (e.group === 0 /* Group.Boolean */) {
@@ -31,15 +81,21 @@ export const primitive = (src, ctx) => {
                 return ans;
             }
             let isOutOfRange = false;
-            const onOutOfRange = () => isOutOfRange = true;
+            const onOutOfRange = () => (isOutOfRange = true);
             const numeralParser = e.group === 2 /* Group.IntegerAlike */
                 // As we already checked the format of the value with `e.pattern` in the if-block, there is no need to check
                 // it again here in the parser, therefore we just pass in a simple /./ regex.
-                ? core.integer({ pattern: /./, min: e.min, max: e.max, onOutOfRange })
+                ? core.integer({
+                    pattern: /./,
+                    min: e.min,
+                    max: e.max,
+                    onOutOfRange,
+                })
                 : e.group === 3 /* Group.LongAlike */
                     ? core.long({ pattern: /./, min: e.min, max: e.max, onOutOfRange })
                     : core.float({ pattern: /./, min: e.min, max: e.max, onOutOfRange });
-            const { result: numeralResult, updateSrcAndCtx: updateNumeral } = core.attempt(numeralParser, src, ctx);
+            const { result: numeralResult, updateSrcAndCtx: updateNumeral } = core
+                .attempt(numeralParser, src, ctx);
             if (isOutOfRange) {
                 ctx.err.report(localize('nbt.parser.number.out-of-range', localizeTag(e.type), localize('nbt.node.string'), e.min, e.max), unquotedResult, 2 /* core.ErrorSeverity.Warning */);
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/nbt",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,8 +25,8 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.0",
-    "@spyglassmc/locales": "0.3.0",
-    "@spyglassmc/mcdoc": "0.3.1"
+    "@spyglassmc/core": "0.4.2",
+    "@spyglassmc/locales": "0.3.2",
+    "@spyglassmc/mcdoc": "0.3.3"
   }
 }