@spyglassmc/nbt 0.3.7 → 0.3.9

package/lib/checker/mcdocUtil.js

@@ -1,42 +1,15 @@
 const BlockItems = {
     // Coral fans.
-    'minecraft:brain_coral_fan': [
-        'minecraft:brain_coral_fan',
-        'minecraft:brain_coral_wall_fan',
-    ],
-    'minecraft:bubble_coral_fan': [
-        'minecraft:bubble_coral_fan',
-        'minecraft:bubble_coral_wall_fan',
-    ],
-    'minecraft:fire_coral_fan': [
-        'minecraft:fire_coral_fan',
-        'minecraft:fire_coral_wall_fan',
-    ],
-    'minecraft:horn_coral_fan': [
-        'minecraft:horn_coral_fan',
-        'minecraft:horn_coral_wall_fan',
-    ],
-    'minecraft:tube_coral_fan': [
-        'minecraft:tube_coral_fan',
-        'minecraft:tube_coral_wall_fan',
-    ],
+    'minecraft:brain_coral_fan': ['minecraft:brain_coral_fan', 'minecraft:brain_coral_wall_fan'],
+    'minecraft:bubble_coral_fan': ['minecraft:bubble_coral_fan', 'minecraft:bubble_coral_wall_fan'],
+    'minecraft:fire_coral_fan': ['minecraft:fire_coral_fan', 'minecraft:fire_coral_wall_fan'],
+    'minecraft:horn_coral_fan': ['minecraft:horn_coral_fan', 'minecraft:horn_coral_wall_fan'],
+    'minecraft:tube_coral_fan': ['minecraft:tube_coral_fan', 'minecraft:tube_coral_wall_fan'],
     // Heads and skulls.
-    'minecraft:creeper_head': [
-        'minecraft:creeper_head',
-        'minecraft:creeper_wall_head',
-    ],
-    'minecraft:dragon_head': [
-        'minecraft:dragon_head',
-        'minecraft:dragon_wall_head',
-    ],
-    'minecraft:player_head': [
-        'minecraft:player_head',
-        'minecraft:player_wall_head',
-    ],
-    'minecraft:skeleton_skull': [
-        'minecraft:skeleton_skull',
-        'minecraft:skeleton_wall_skull',
-    ],
+    'minecraft:creeper_head': ['minecraft:creeper_head', 'minecraft:creeper_wall_head'],
+    'minecraft:dragon_head': ['minecraft:dragon_head', 'minecraft:dragon_wall_head'],
+    'minecraft:player_head': ['minecraft:player_head', 'minecraft:player_wall_head'],
+    'minecraft:skeleton_skull': ['minecraft:skeleton_skull', 'minecraft:skeleton_wall_skull'],
     'minecraft:wither_skeleton_skull': [
         'minecraft:wither_skeleton_skull',
         'minecraft:wither_skeleton_wall_skull',
@@ -64,14 +37,8 @@ const BlockItems = {
     ],
     // Torches.
     'minecraft:torch': ['minecraft:torch', 'minecraft:wall_torch'],
-    'minecraft:soul_torch': [
-        'minecraft:soul_torch',
-        'minecraft:soul_wall_torch',
-    ],
-    'minecraft:redstone_torch': [
-        'minecraft:redstone_torch',
-        'minecraft:redstone_wall_torch',
-    ],
+    'minecraft:soul_torch': ['minecraft:soul_torch', 'minecraft:soul_wall_torch'],
+    'minecraft:redstone_torch': ['minecraft:redstone_torch', 'minecraft:redstone_wall_torch'],
     'minecraft:beetroot_seeds': ['minecraft:beetroots'],
     'minecraft:carrot': ['minecraft:carrots'],
     'minecraft:cocoa_beans': ['minecraft:cocoa'],
@@ -97,40 +64,4 @@ export function getEntityFromItem(item) {
     }
     return undefined;
 }
-const SpecialStrings = {
-    '::minecraft::block::banner::Banner.CustomName': 'mcfunction:component',
-    '::minecraft::block::brewingstand::BrewingStand.CustomName': 'mcfunction:component',
-    '::minecraft::block::commandblock::CommandBlock.Command': 'mcfunction:command',
-    '::minecraft::block::commandblock::CommandBlock.CustomName': 'mcfunction:component',
-    '::minecraft::block::container::ContainerBase.CustomName': 'mcfunction:component',
-    '::minecraft::block::enchantingtable::EnchantingTable.CustomName': 'mcfunction:component',
-    '::minecraft::block::furnace::Furnace.CustomName': 'mcfunction:component',
-    '::minecraft::block::hopper::Hopper.CustomName': 'mcfunction:component',
-    '::minecraft::block::sign::Sign.Text1': 'mcfunction:component',
-    '::minecraft::block::sign::Sign.Text2': 'mcfunction:component',
-    '::minecraft::block::sign::Sign.Text3': 'mcfunction:component',
-    '::minecraft::block::sign::Sign.Text4': 'mcfunction:component',
-    '::minecraft::entity::effectcloud::EffectCloud.Particle': 'mcfunction:particle',
-    '::minecraft::entity::minecart::CommandMinecart.Command': 'mcfunction:command',
-    '::minecraft::entity::mob::LivingEntity.Team': 'mcfunction:team',
-    '::minecraft::entity::EntityBase.Tags[]': 'mcfunction:tag',
-    '::minecraft::item::blockitem::BlockItem.CanPlaceOn[]': 'mcfunction:block_predicate',
-    '::minecraft::item::book::WrittenBook.pages[]': 'mcfunction:component',
-    '::minecraft::item::ItemBase.CanDestroy[]': 'mcfunction:block_predicate',
-};
-export function getSpecialStringParser(mcdocPath) {
-    return SpecialStrings[mcdocPath];
-}
-const ExpandableCompounds = [
-    '::minecraft::item::ItemBase',
-    '::minecraft::entity::marker::Any',
-    '::minecraft::util::any::Any',
-    '::minecraft::util::Any',
-];
-/**
- * @param mcdocPath Path of the mcdoc compound definition.
- */
-export function isExpandableCompound(mcdocPath) {
-    return ExpandableCompounds.includes(mcdocPath);
-}
 //# sourceMappingURL=mcdocUtil.js.map

package/lib/colorizer/index.js

@@ -1,5 +1,6 @@
 import * as core from '@spyglassmc/core';
 export function register(meta) {
+    meta.registerColorizer('nbt:string', core.colorizer.string);
     meta.registerColorizer('nbt:byte', core.colorizer.number);
     meta.registerColorizer('nbt:short', core.colorizer.number);
     meta.registerColorizer('nbt:int', core.colorizer.number);

package/lib/completer/index.d.ts

@@ -0,0 +1,3 @@
+import * as core from '@spyglassmc/core';
+export declare function register(meta: core.MetaRegistry): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/completer/index.js

@@ -0,0 +1,160 @@
+import * as core from '@spyglassmc/core';
+import * as mcdoc from '@spyglassmc/mcdoc';
+const collection = (node, ctx) => {
+    const index = core.binarySearch(node.children, ctx.offset, (n, o) => {
+        return core.Range.compareOffset(n.range, o, true);
+    });
+    const item = index >= 0 ? node.children[index] : undefined;
+    if (item?.value) {
+        return ctx.meta.getCompleter(item.value.type)(item.value, ctx);
+    }
+    if (node.typeDef?.kind === 'list') {
+        const completions = getValues(node.typeDef.item, ctx.offset, {
+            ...ctx,
+            requireCanonical: node.requireCanonical,
+        });
+        if (ctx.offset < node.children[node.children.length - 1]?.range.start ?? 0) {
+            return completions.map(c => ({ ...c, insertText: c.insertText + ',' }));
+        }
+        return completions;
+    }
+    return [];
+};
+const compound = core.completer.record({
+    key: (record, pair, ctx, range, iv, ipe, exitingKeys) => {
+        if (!record.typeDef) {
+            return [];
+        }
+        const keySet = new Set(exitingKeys.map(n => n.value));
+        return mcdoc.runtime.completer
+            .getFields(record.typeDef, { ...ctx, requireCanonical: record.requireCanonical })
+            .filter(({ key }) => !keySet.has(key))
+            .map(({ key, field }) => core.CompletionItem.create(key, pair?.key ?? range, {
+            kind: 5 /* core.CompletionKind.Field */,
+            detail: mcdoc.McdocType.toString(field.type),
+            deprecated: field.deprecated,
+            sortText: field.optional ? '$b' : '$a', // sort above hardcoded $schema
+            filterText: formatKey(key, pair?.key?.quote),
+            insertText: `${formatKey(key, pair?.key?.quote)}${iv ? ':' : ''}${ipe ? '$1,' : ''}`,
+        }));
+    },
+    value: (record, pair, ctx, range) => {
+        if (pair.value) {
+            return ctx.meta.getCompleter(pair.value.type)(pair.value, ctx);
+        }
+        if (pair.key && record.typeDef) {
+            const pairKey = pair.key.value;
+            const field = mcdoc.runtime.completer
+                .getFields(record.typeDef, ctx)
+                .find(({ key }) => key === pairKey)
+                ?.field.type;
+            if (field) {
+                return getValues(field, range, {
+                    ...ctx,
+                    requireCanonical: record.requireCanonical,
+                });
+            }
+        }
+        return [];
+    },
+});
+const primitive = (node, ctx) => {
+    const insideRange = core.Range.contains(node, ctx.offset, true);
+    if (node.type === 'nbt:string' && node.children?.length && insideRange) {
+        const childItems = core.completer.string(node, ctx);
+        if (childItems.length > 0) {
+            return childItems;
+        }
+    }
+    if (!node.typeDef) {
+        return [];
+    }
+    return getValues(node.typeDef, insideRange ? node : ctx.offset, {
+        ...ctx,
+        requireCanonical: node.requireCanonical,
+    });
+};
+const path = (node, ctx) => {
+    const index = core.binarySearch(node.children, ctx.offset, (n, o) => {
+        return core.Range.compareOffset(n.range, o, true);
+    });
+    const item = index >= 0 ? node.children[index] : undefined;
+    if (item) {
+        return ctx.meta.getCompleter(item.type)(item, ctx);
+    }
+    if (!node.endTypeDef) {
+        return [];
+    }
+    return getPathKeys(node.endTypeDef, ctx.offset, undefined, ctx);
+};
+const pathKey = (node, ctx) => {
+    if (!node.typeDef) {
+        return [];
+    }
+    const child = node.children[0];
+    if (child.children?.length) {
+        return core.completer.dispatch(child.children[0], ctx);
+    }
+    return getPathKeys(node.typeDef, node, child.quote, ctx);
+};
+function getPathKeys(typeDef, range, quote, ctx) {
+    return mcdoc.runtime.completer
+        .getFields(typeDef, { ...ctx, requireCanonical: true })
+        .map(({ key, field }) => core.CompletionItem.create(key, range, {
+        kind: 5 /* core.CompletionKind.Field */,
+        detail: mcdoc.McdocType.toString(field.type),
+        deprecated: field.deprecated,
+        sortText: field.optional ? '$b' : '$a', // sort above hardcoded $schema
+        filterText: formatKey(key, quote),
+        insertText: formatKey(key, quote),
+    }));
+}
+function getValues(typeDef, range, ctx) {
+    return mcdoc.runtime.completer.getValues(typeDef, ctx)
+        .map(({ value, detail, kind, completionKind, insertText }) => core.CompletionItem.create(value, range, {
+        kind: completionKind ?? 12 /* core.CompletionKind.Value */,
+        detail,
+        filterText: formatValue(value, kind),
+        insertText: formatValue(insertText ?? value, kind),
+    }));
+}
+function formatKey(key, quote) {
+    if (!quote && core.BrigadierUnquotablePattern.test(key)) {
+        return key;
+    }
+    const q = quote ?? '"';
+    return q + core.completer.escapeString(key, q) + q;
+}
+function formatValue(value, kind) {
+    switch (kind) {
+        case 'string':
+            return `"${core.completer.escapeString(value, '"')}"`;
+        case 'byte':
+            return `${value}b`;
+        case 'short':
+            return `${value}s`;
+        case 'long':
+            return `${value}L`;
+        case 'float':
+            return `${value}f`;
+        default:
+            return value;
+    }
+}
+export function register(meta) {
+    meta.registerCompleter('nbt:byte', primitive);
+    meta.registerCompleter('nbt:byte_array', collection);
+    meta.registerCompleter('nbt:compound', compound);
+    meta.registerCompleter('nbt:double', primitive);
+    meta.registerCompleter('nbt:int', primitive);
+    meta.registerCompleter('nbt:int_array', collection);
+    meta.registerCompleter('nbt:list', collection);
+    meta.registerCompleter('nbt:long', primitive);
+    meta.registerCompleter('nbt:long_array', collection);
+    meta.registerCompleter('nbt:string', primitive);
+    meta.registerCompleter('nbt:short', primitive);
+    meta.registerCompleter('nbt:float', primitive);
+    meta.registerCompleter('nbt:path', path);
+    meta.registerCompleter('nbt:path/key', pathKey);
+}
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import type * as core from '@spyglassmc/core';
 export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
+export * as completer from './completer/index.js';
 export * from './node/index.js';
 export * as parser from './parser/index.js';
 export declare const initialize: core.SyncProjectInitializer;

package/lib/index.js

@@ -1,18 +1,28 @@
+import { registerMcdocAttributes } from './attributes.js';
+import * as checker from './checker/index.js';
 import * as colorizer from './colorizer/index.js';
+import * as completer from './completer/index.js';
 import * as parser from './parser/index.js';
 export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
+export * as completer from './completer/index.js';
 export * from './node/index.js';
 export * as parser from './parser/index.js';
 /* istanbul ignore next */
 export const initialize = ({ meta }) => {
-    meta.registerLanguage('nbt', {
+    meta.registerLanguage('snbt', {
         extensions: ['.snbt'],
         parser: parser.entry,
     });
+    meta.registerLanguage('nbt', {
+        extensions: ['.nbt'],
+    });
     meta.registerParser('nbt:entry', parser.entry);
     meta.registerParser('nbt:compound', parser.compound);
     meta.registerParser('nbt:path', parser.path);
+    checker.register(meta);
     colorizer.register(meta);
+    completer.register(meta);
+    registerMcdocAttributes(meta);
 };
 //# sourceMappingURL=index.js.map

package/lib/node/index.d.ts

@@ -1,13 +1,23 @@
-import * as core from '@spyglassmc/core';
+import type * as core from '@spyglassmc/core';
 import type * as mcdoc from '@spyglassmc/mcdoc';
+interface NbtBaseNode {
+    typeDef?: mcdoc.runtime.checker.SimplifiedMcdocType;
+    requireCanonical?: boolean;
+}
 export type NbtNode = NbtPrimitiveNode | NbtCompoundNode | NbtCollectionNode;
 export declare namespace NbtNode {
     function is(node: core.AstNode | undefined): node is NbtNode;
 }
-export type NbtPrimitiveNode = NbtNumberNode | core.StringNode;
+export type NbtPrimitiveNode = NbtNumberNode | NbtStringNode;
 export declare namespace NbtPrimitiveNode {
     function is(node: core.AstNode | undefined): node is NbtPrimitiveNode;
 }
+export interface NbtStringNode extends core.StringBaseNode, NbtBaseNode {
+    readonly type: 'nbt:string';
+}
+export declare namespace NbtStringNode {
+    function is(obj: object | undefined): obj is NbtStringNode;
+}
 export type NbtNumberNode = NbtIntegerAlikeNode | NbtFloatAlikeNode;
 export declare namespace NbtNumberNode {
     function is(node: core.AstNode | undefined): node is NbtNumberNode;
@@ -16,25 +26,25 @@ export type NbtIntegerAlikeNode = NbtByteNode | NbtShortNode | NbtIntNode | NbtL
 export declare namespace NbtIntegerAlikeNode {
     function is(node: core.AstNode | undefined): node is NbtIntegerAlikeNode;
 }
-export interface NbtByteNode extends core.IntegerBaseNode {
+export interface NbtByteNode extends core.IntegerBaseNode, NbtBaseNode {
     readonly type: 'nbt:byte';
 }
 export declare namespace NbtByteNode {
     function is(node: core.AstNode | undefined): node is NbtByteNode;
 }
-export interface NbtShortNode extends core.IntegerBaseNode {
+export interface NbtShortNode extends core.IntegerBaseNode, NbtBaseNode {
     readonly type: 'nbt:short';
 }
 export declare namespace NbtShortNode {
     function is(node: core.AstNode | undefined): node is NbtShortNode;
 }
-export interface NbtIntNode extends core.IntegerBaseNode {
+export interface NbtIntNode extends core.IntegerBaseNode, NbtBaseNode {
     readonly type: 'nbt:int';
 }
 export declare namespace NbtIntNode {
     function is(node: core.AstNode | undefined): node is NbtIntNode;
 }
-export interface NbtLongNode extends core.LongBaseNode {
+export interface NbtLongNode extends core.LongBaseNode, NbtBaseNode {
     readonly type: 'nbt:long';
 }
 export declare namespace NbtLongNode {
@@ -44,19 +54,19 @@ export type NbtFloatAlikeNode = NbtFloatNode | NbtDoubleNode;
 export declare namespace NbtFloatAlikeNode {
     function is(node: core.AstNode | undefined): node is NbtFloatAlikeNode;
 }
-export interface NbtFloatNode extends core.FloatBaseNode {
+export interface NbtFloatNode extends core.FloatBaseNode, NbtBaseNode {
     readonly type: 'nbt:float';
 }
 export declare namespace NbtFloatNode {
     function is(node: core.AstNode | undefined): node is NbtFloatNode;
 }
-export interface NbtDoubleNode extends core.FloatBaseNode {
+export interface NbtDoubleNode extends core.FloatBaseNode, NbtBaseNode {
     readonly type: 'nbt:double';
 }
 export declare namespace NbtDoubleNode {
     function is(node: core.AstNode | undefined): node is NbtDoubleNode;
 }
-export interface NbtCompoundNode extends core.RecordBaseNode<core.StringNode, NbtNode> {
+export interface NbtCompoundNode extends core.RecordBaseNode<NbtStringNode, NbtNode>, NbtBaseNode {
     readonly type: 'nbt:compound';
 }
 export declare namespace NbtCompoundNode {
@@ -66,7 +76,7 @@ export type NbtCollectionNode = NbtListNode | NbtPrimitiveArrayNode;
 export declare namespace NbtCollectionNode {
     function is(node: core.AstNode | undefined): node is NbtCollectionNode;
 }
-export interface NbtListNode extends core.ListNode<NbtNode> {
+export interface NbtListNode extends core.ListNode<NbtNode>, NbtBaseNode {
     type: 'nbt:list';
     valueType?: NbtNode['type'];
 }
@@ -77,37 +87,64 @@ export type NbtPrimitiveArrayNode = NbtByteArrayNode | NbtIntArrayNode | NbtLong
 export declare namespace NbtPrimitiveArrayNode {
     function is(node: core.AstNode | undefined): node is NbtPrimitiveArrayNode;
 }
-export interface NbtByteArrayNode extends core.ListNode<NbtByteNode> {
+export interface NbtByteArrayNode extends core.ListNode<NbtByteNode>, NbtBaseNode {
     type: 'nbt:byte_array';
 }
 export declare namespace NbtByteArrayNode {
     function is(node: core.AstNode | undefined): node is NbtByteArrayNode;
 }
-export interface NbtIntArrayNode extends core.ListNode<NbtIntNode> {
+export interface NbtIntArrayNode extends core.ListNode<NbtIntNode>, NbtBaseNode {
     type: 'nbt:int_array';
 }
 export declare namespace NbtIntArrayNode {
     function is(node: core.AstNode | undefined): node is NbtIntArrayNode;
 }
-export interface NbtLongArrayNode extends core.ListNode<NbtLongNode> {
+export interface NbtLongArrayNode extends core.ListNode<NbtLongNode>, NbtBaseNode {
     type: 'nbt:long_array';
 }
 export declare namespace NbtLongArrayNode {
     function is(node: core.AstNode | undefined): node is NbtLongArrayNode;
 }
+export type NbtPathChild = NbtPathKeyNode | NbtPathFilterNode | NbtPathIndexNode;
 export interface NbtPathNode extends core.AstNode {
     type: 'nbt:path';
-    children: (core.StringNode | NbtCompoundNode | NbtPathIndexNode)[];
-    targetType?: mcdoc.McdocType | undefined;
+    children: NbtPathChild[];
+    /**
+     * The type definition at the end of the path
+     */
+    endTypeDef?: mcdoc.runtime.checker.SimplifiedMcdocType;
 }
 export declare namespace NbtPathNode {
     function is(node: core.AstNode | undefined): node is NbtPathNode;
 }
-export interface NbtPathIndexNode extends core.AstNode {
+export interface NbtPathKeyNode extends core.AstNode, NbtBaseNode {
+    type: 'nbt:path/key';
+    children: [NbtStringNode];
+}
+export declare namespace NbtPathKeyNode {
+    function is(node: core.AstNode | undefined): node is NbtPathKeyNode;
+}
+export interface NbtPathFilterNode extends core.AstNode, NbtBaseNode {
+    type: 'nbt:path/filter';
+    children: [NbtCompoundNode];
+}
+export declare namespace NbtPathFilterNode {
+    function is(node: core.AstNode | undefined): node is NbtPathFilterNode;
+}
+export interface NbtPathIndexNode extends core.AstNode, NbtBaseNode {
     type: 'nbt:path/index';
     children: [core.IntegerNode] | [NbtCompoundNode] | undefined;
 }
 export declare namespace NbtPathIndexNode {
     function is(node: core.AstNode | undefined): node is NbtPathIndexNode;
 }
+export interface TypedNbtNode extends core.AstNode {
+    type: 'nbt:typed';
+    children: [NbtNode];
+    targetType: mcdoc.McdocType;
+}
+export declare namespace TypedNbtNode {
+    function is(node: core.AstNode | undefined): node is TypedNbtNode;
+}
+export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/node/index.js

@@ -1,11 +1,8 @@
-import * as core from '@spyglassmc/core';
 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 = {}));
@@ -13,10 +10,18 @@ export var NbtPrimitiveNode;
 (function (NbtPrimitiveNode) {
     /* istanbul ignore next */
     function is(node) {
-        return NbtNumberNode.is(node) || core.StringNode.is(node);
+        return NbtNumberNode.is(node) || NbtStringNode.is(node);
     }
     NbtPrimitiveNode.is = is;
 })(NbtPrimitiveNode || (NbtPrimitiveNode = {}));
+export var NbtStringNode;
+(function (NbtStringNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'nbt:string';
+    }
+    NbtStringNode.is = is;
+})(NbtStringNode || (NbtStringNode = {}));
 export var NbtNumberNode;
 (function (NbtNumberNode) {
     /* istanbul ignore next */
@@ -29,10 +34,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 = {}));
@@ -120,9 +125,7 @@ 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 = {}));
@@ -158,6 +161,22 @@ export var NbtPathNode;
     }
     NbtPathNode.is = is;
 })(NbtPathNode || (NbtPathNode = {}));
+export var NbtPathKeyNode;
+(function (NbtPathKeyNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:path/key';
+    }
+    NbtPathKeyNode.is = is;
+})(NbtPathKeyNode || (NbtPathKeyNode = {}));
+export var NbtPathFilterNode;
+(function (NbtPathFilterNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:path/filter';
+    }
+    NbtPathFilterNode.is = is;
+})(NbtPathFilterNode || (NbtPathFilterNode = {}));
 export var NbtPathIndexNode;
 (function (NbtPathIndexNode) {
     /* istanbul ignore next */
@@ -166,4 +185,12 @@ export var NbtPathIndexNode;
     }
     NbtPathIndexNode.is = is;
 })(NbtPathIndexNode || (NbtPathIndexNode = {}));
+export var TypedNbtNode;
+(function (TypedNbtNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:typed';
+    }
+    TypedNbtNode.is = is;
+})(TypedNbtNode || (TypedNbtNode = {}));
 //# sourceMappingURL=index.js.map

package/lib/parser/collection.js

@@ -8,7 +8,7 @@ export const list = (src, ctx) => {
         start: '[',
         value: entry,
         sep: ',',
-        trailingSep: false,
+        trailingSep: true,
         end: ']',
     });
     const ans = parser(src, ctx);
@@ -29,7 +29,7 @@ export const byteArray = (src, ctx) => {
         start: '[B;',
         value: primitive,
         sep: ',',
-        trailingSep: false,
+        trailingSep: true,
         end: ']',
     });
     const ans = parser(src, ctx);
@@ -47,7 +47,7 @@ export const intArray = (src, ctx) => {
         start: '[I;',
         value: primitive,
         sep: ',',
-        trailingSep: false,
+        trailingSep: true,
         end: ']',
     });
     const ans = parser(src, ctx);
@@ -65,7 +65,7 @@ export const longArray = (src, ctx) => {
         start: '[L;',
         value: primitive,
         sep: ',',
-        trailingSep: false,
+        trailingSep: true,
         end: ']',
     });
     const ans = parser(src, ctx);

package/lib/parser/compound.js

@@ -4,14 +4,11 @@ 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.setType('nbt:string', core.string({ ...core.BrigadierStringOptions, colorTokenType: 'property' }))),
             sep: ':',
             value: entry,
             end: ',',
-            trailingEnd: false,
+            trailingEnd: true,
         },
         end: '}',
     }))(src, ctx);

package/lib/parser/entry.js

@@ -4,7 +4,10 @@ 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('[I;'),
+        parser: intArray,
+    },
     { predicate: (src) => src.tryPeek('[L;'), parser: longArray },
     { predicate: (src) => src.tryPeek('['), parser: list },
     { predicate: (src) => src.tryPeek('{'), parser: compound },