@spyglassmc/nbt 0.1.0

package/lib/checker/nbtdocUtil.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpandableCompound = exports.getSpecialStringParser = exports.getEntityFromItem = exports.getBlocksFromItem = void 0;
+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',
+    ],
+    // 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:wither_skeleton_skull': [
+        'minecraft:wither_skeleton_skull',
+        'minecraft:wither_skeleton_wall_skull',
+    ],
+    // Dead coral fans.
+    'minecraft:dead_brain_coral_fan': [
+        'minecraft:dead_brain_coral_fan',
+        'minecraft:dead_brain_coral_wall_fan',
+    ],
+    'minecraft:dead_bubble_coral_fan': [
+        'minecraft:dead_bubble_coral_fan',
+        'minecraft:dead_bubble_coral_wall_fan',
+    ],
+    'minecraft:dead_fire_coral_fan': [
+        'minecraft:dead_fire_coral_fan',
+        'minecraft:dead_fire_coral_wall_fan',
+    ],
+    'minecraft:dead_horn_coral_fan': [
+        'minecraft:dead_horn_coral_fan',
+        'minecraft:dead_horn_coral_wall_fan',
+    ],
+    'minecraft:dead_tube_coral_fan': [
+        'minecraft:dead_tube_coral_fan',
+        'minecraft:dead_tube_coral_wall_fan',
+    ],
+    // 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: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',
+    ],
+};
+function getBlocksFromItem(item) {
+    return BlockItems[item];
+}
+exports.getBlocksFromItem = getBlocksFromItem;
+function getEntityFromItem(item) {
+    if (item === 'minecraft:armor_stand') {
+        return item;
+    }
+    const result = item.match(/^minecraft:([a-z0-9_]+)_spawn_egg$/);
+    if (result) {
+        return `minecraft:${result[1]}`;
+    }
+    return undefined;
+}
+exports.getEntityFromItem = getEntityFromItem;
+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',
+    // TODO
+    // '::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',
+};
+function getSpecialStringParser(nbtdocPath) {
+    return SpecialStrings[nbtdocPath];
+}
+exports.getSpecialStringParser = getSpecialStringParser;
+const ExpandableCompounds = [
+    '::minecraft::item::ItemBase',
+    '::minecraft::entity::marker::Any',
+];
+/**
+ * @param nbtdocPath Path of the nbtdoc compound definition.
+ */
+function isExpandableCompound(nbtdocPath) {
+    return ExpandableCompounds.includes(nbtdocPath);
+}
+exports.isExpandableCompound = isExpandableCompound;
+//# sourceMappingURL=nbtdocUtil.js.map

package/lib/colorizer/index.d.ts

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

package/lib/colorizer/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+function register(meta) {
+    meta.registerColorizer('nbt:byte', core.colorizer.number);
+    meta.registerColorizer('nbt:short', core.colorizer.number);
+    meta.registerColorizer('nbt:int', core.colorizer.number);
+    meta.registerColorizer('nbt:long', core.colorizer.number);
+    meta.registerColorizer('nbt:float', core.colorizer.number);
+    meta.registerColorizer('nbt:double', core.colorizer.number);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import type * as core from '@spyglassmc/core';
+export * as checker from './checker';
+export * as colorizer from './colorizer';
+export * from './node';
+export * as parser from './parser';
+export declare const initialize: core.ProjectInitializer;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = exports.parser = exports.colorizer = exports.checker = void 0;
+const colorizer = __importStar(require("./colorizer"));
+const parser = __importStar(require("./parser"));
+exports.checker = __importStar(require("./checker"));
+exports.colorizer = __importStar(require("./colorizer"));
+__exportStar(require("./node"), exports);
+exports.parser = __importStar(require("./parser"));
+/* istanbul ignore next */
+const initialize = ({ meta }) => {
+    meta.registerLanguage('nbt', {
+        extensions: ['.snbt'],
+        parser: parser.entry,
+    });
+    meta.registerParser('nbt:entry', parser.entry);
+    meta.registerParser('nbt:compound', parser.compound);
+    meta.registerParser('nbt:path', parser.path);
+    colorizer.register(meta);
+};
+exports.initialize = initialize;
+//# sourceMappingURL=index.js.map

package/lib/node/index.d.ts

@@ -0,0 +1,113 @@
+import * as core from '@spyglassmc/core';
+import type * as nbtdoc from '@spyglassmc/nbtdoc';
+export declare 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 declare namespace NbtPrimitiveNode {
+    function is(node: core.AstNode | undefined): node is NbtPrimitiveNode;
+}
+export declare 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 declare namespace NbtIntegerAlikeNode {
+    function is(node: core.AstNode | undefined): node is NbtIntegerAlikeNode;
+}
+export interface NbtByteNode extends core.IntegerBaseNode {
+    readonly type: 'nbt:byte';
+}
+export declare namespace NbtByteNode {
+    function is(node: core.AstNode | undefined): node is NbtByteNode;
+}
+export interface NbtShortNode extends core.IntegerBaseNode {
+    readonly type: 'nbt:short';
+}
+export declare namespace NbtShortNode {
+    function is(node: core.AstNode | undefined): node is NbtShortNode;
+}
+export interface NbtIntNode extends core.IntegerBaseNode {
+    readonly type: 'nbt:int';
+}
+export declare namespace NbtIntNode {
+    function is(node: core.AstNode | undefined): node is NbtIntNode;
+}
+export interface NbtLongNode extends core.LongBaseNode {
+    readonly type: 'nbt:long';
+}
+export declare namespace NbtLongNode {
+    function is(node: core.AstNode | undefined): node is NbtLongNode;
+}
+export declare type NbtFloatAlikeNode = NbtFloatNode | NbtDoubleNode;
+export declare namespace NbtFloatAlikeNode {
+    function is(node: core.AstNode | undefined): node is NbtFloatAlikeNode;
+}
+export interface NbtFloatNode extends core.FloatBaseNode {
+    readonly type: 'nbt:float';
+}
+export declare namespace NbtFloatNode {
+    function is(node: core.AstNode | undefined): node is NbtFloatNode;
+}
+export interface NbtDoubleNode extends core.FloatBaseNode {
+    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> {
+    readonly type: 'nbt:compound';
+}
+export declare namespace NbtCompoundNode {
+    function is(node: core.AstNode | undefined): node is NbtCompoundNode;
+}
+export declare type NbtCollectionNode = NbtListNode | NbtPrimitiveArrayNode;
+export declare namespace NbtCollectionNode {
+    function is(node: core.AstNode | undefined): node is NbtCollectionNode;
+}
+export interface NbtListNode extends core.ListNode<NbtNode> {
+    readonly type: 'nbt:list';
+    readonly valueType?: NbtNode['type'];
+}
+export declare namespace NbtListNode {
+    function is(node: core.AstNode | undefined): node is NbtListNode;
+}
+export declare type NbtPrimitiveArrayNode = NbtByteArrayNode | NbtIntArrayNode | NbtLongArrayNode;
+export declare namespace NbtPrimitiveArrayNode {
+    function is(node: core.AstNode | undefined): node is NbtPrimitiveArrayNode;
+}
+export interface NbtByteArrayNode extends core.ListNode<NbtByteNode> {
+    readonly type: 'nbt:byte_array';
+}
+export declare namespace NbtByteArrayNode {
+    function is(node: core.AstNode | undefined): node is NbtByteArrayNode;
+}
+export interface NbtIntArrayNode extends core.ListNode<NbtIntNode> {
+    readonly type: 'nbt:int_array';
+}
+export declare namespace NbtIntArrayNode {
+    function is(node: core.AstNode | undefined): node is NbtIntArrayNode;
+}
+export interface NbtLongArrayNode extends core.ListNode<NbtLongNode> {
+    readonly type: 'nbt:long_array';
+}
+export declare namespace NbtLongArrayNode {
+    function is(node: core.AstNode | undefined): node is NbtLongArrayNode;
+}
+export interface NbtPathNode extends core.AstNode {
+    type: 'nbt:path';
+    children: (core.StringNode | NbtCompoundNode | NbtPathIndexNode)[];
+    targetType?: nbtdoc.NbtdocType | undefined;
+}
+export declare namespace NbtPathNode {
+    function is(node: core.AstNode | undefined): node is NbtPathNode;
+}
+export interface NbtPathIndexNode extends core.AstNode {
+    type: 'nbt:path/index';
+    children: [core.IntegerNode] | [NbtCompoundNode] | undefined;
+}
+export declare namespace NbtPathIndexNode {
+    function is(node: core.AstNode | undefined): node is NbtPathIndexNode;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/node/index.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NbtPathIndexNode = exports.NbtPathNode = exports.NbtLongArrayNode = exports.NbtIntArrayNode = exports.NbtByteArrayNode = exports.NbtPrimitiveArrayNode = exports.NbtListNode = exports.NbtCollectionNode = exports.NbtCompoundNode = exports.NbtDoubleNode = exports.NbtFloatNode = exports.NbtFloatAlikeNode = exports.NbtLongNode = exports.NbtIntNode = exports.NbtShortNode = exports.NbtByteNode = exports.NbtIntegerAlikeNode = exports.NbtNumberNode = exports.NbtPrimitiveNode = exports.NbtNode = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+var NbtNode;
+(function (NbtNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtPrimitiveNode.is(node) || NbtCompoundNode.is(node) || NbtCollectionNode.is(node);
+    }
+    NbtNode.is = is;
+})(NbtNode = exports.NbtNode || (exports.NbtNode = {}));
+var NbtPrimitiveNode;
+(function (NbtPrimitiveNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtNumberNode.is(node) || core.StringNode.is(node);
+    }
+    NbtPrimitiveNode.is = is;
+})(NbtPrimitiveNode = exports.NbtPrimitiveNode || (exports.NbtPrimitiveNode = {}));
+var NbtNumberNode;
+(function (NbtNumberNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtIntegerAlikeNode.is(node) || NbtFloatAlikeNode.is(node);
+    }
+    NbtNumberNode.is = is;
+})(NbtNumberNode = exports.NbtNumberNode || (exports.NbtNumberNode = {}));
+var NbtIntegerAlikeNode;
+(function (NbtIntegerAlikeNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtByteNode.is(node) || NbtShortNode.is(node) || NbtIntNode.is(node) || NbtLongNode.is(node);
+    }
+    NbtIntegerAlikeNode.is = is;
+})(NbtIntegerAlikeNode = exports.NbtIntegerAlikeNode || (exports.NbtIntegerAlikeNode = {}));
+var NbtByteNode;
+(function (NbtByteNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:byte';
+    }
+    NbtByteNode.is = is;
+})(NbtByteNode = exports.NbtByteNode || (exports.NbtByteNode = {}));
+var NbtShortNode;
+(function (NbtShortNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:short';
+    }
+    NbtShortNode.is = is;
+})(NbtShortNode = exports.NbtShortNode || (exports.NbtShortNode = {}));
+var NbtIntNode;
+(function (NbtIntNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:int';
+    }
+    NbtIntNode.is = is;
+})(NbtIntNode = exports.NbtIntNode || (exports.NbtIntNode = {}));
+var NbtLongNode;
+(function (NbtLongNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:long';
+    }
+    NbtLongNode.is = is;
+})(NbtLongNode = exports.NbtLongNode || (exports.NbtLongNode = {}));
+var NbtFloatAlikeNode;
+(function (NbtFloatAlikeNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtFloatNode.is(node) || NbtDoubleNode.is(node);
+    }
+    NbtFloatAlikeNode.is = is;
+})(NbtFloatAlikeNode = exports.NbtFloatAlikeNode || (exports.NbtFloatAlikeNode = {}));
+var NbtFloatNode;
+(function (NbtFloatNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:float';
+    }
+    NbtFloatNode.is = is;
+})(NbtFloatNode = exports.NbtFloatNode || (exports.NbtFloatNode = {}));
+var NbtDoubleNode;
+(function (NbtDoubleNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:double';
+    }
+    NbtDoubleNode.is = is;
+})(NbtDoubleNode = exports.NbtDoubleNode || (exports.NbtDoubleNode = {}));
+var NbtCompoundNode;
+(function (NbtCompoundNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:compound';
+    }
+    NbtCompoundNode.is = is;
+})(NbtCompoundNode = exports.NbtCompoundNode || (exports.NbtCompoundNode = {}));
+var NbtCollectionNode;
+(function (NbtCollectionNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtListNode.is(node) || NbtPrimitiveArrayNode.is(node);
+    }
+    NbtCollectionNode.is = is;
+})(NbtCollectionNode = exports.NbtCollectionNode || (exports.NbtCollectionNode = {}));
+var NbtListNode;
+(function (NbtListNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:list';
+    }
+    NbtListNode.is = is;
+})(NbtListNode = exports.NbtListNode || (exports.NbtListNode = {}));
+var NbtPrimitiveArrayNode;
+(function (NbtPrimitiveArrayNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return NbtByteArrayNode.is(node) || NbtIntArrayNode.is(node) || NbtLongArrayNode.is(node);
+    }
+    NbtPrimitiveArrayNode.is = is;
+})(NbtPrimitiveArrayNode = exports.NbtPrimitiveArrayNode || (exports.NbtPrimitiveArrayNode = {}));
+var NbtByteArrayNode;
+(function (NbtByteArrayNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:byte_array';
+    }
+    NbtByteArrayNode.is = is;
+})(NbtByteArrayNode = exports.NbtByteArrayNode || (exports.NbtByteArrayNode = {}));
+var NbtIntArrayNode;
+(function (NbtIntArrayNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:int_array';
+    }
+    NbtIntArrayNode.is = is;
+})(NbtIntArrayNode = exports.NbtIntArrayNode || (exports.NbtIntArrayNode = {}));
+var NbtLongArrayNode;
+(function (NbtLongArrayNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:long_array';
+    }
+    NbtLongArrayNode.is = is;
+})(NbtLongArrayNode = exports.NbtLongArrayNode || (exports.NbtLongArrayNode = {}));
+var NbtPathNode;
+(function (NbtPathNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:path';
+    }
+    NbtPathNode.is = is;
+})(NbtPathNode = exports.NbtPathNode || (exports.NbtPathNode = {}));
+var NbtPathIndexNode;
+(function (NbtPathIndexNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'nbt:path/index';
+    }
+    NbtPathIndexNode.is = is;
+})(NbtPathIndexNode = exports.NbtPathIndexNode || (exports.NbtPathIndexNode = {}));
+//# sourceMappingURL=index.js.map

package/lib/parser/collection.d.ts

@@ -0,0 +1,7 @@
+import * as core from '@spyglassmc/core';
+import type { NbtByteArrayNode, NbtIntArrayNode, NbtListNode, NbtLongArrayNode } from '../node';
+export declare const list: core.Parser<NbtListNode>;
+export declare const byteArray: core.Parser<NbtByteArrayNode>;
+export declare const intArray: core.Parser<NbtIntArrayNode>;
+export declare const longArray: core.Parser<NbtLongArrayNode>;
+//# sourceMappingURL=collection.d.ts.map

package/lib/parser/collection.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longArray = exports.intArray = exports.byteArray = exports.list = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const locales_1 = require("@spyglassmc/locales");
+const util_1 = require("../util");
+const entry_1 = require("./entry");
+const primitive_1 = require("./primitive");
+const list = (src, ctx) => {
+    const parser = core.list({ start: '[', value: entry_1.entry, sep: ',', trailingSep: false, end: ']' });
+    const ans = parser(src, ctx);
+    ans.type = 'nbt:list';
+    ans.valueType = ans.children[0]?.value?.type;
+    // Check if every element is of the same type.
+    if (ans.valueType) {
+        for (const { value } of ans.children) {
+            if (value && value.type !== ans.valueType) {
+                ctx.err.report((0, locales_1.localize)('expected-got', (0, util_1.localizeTag)(ans.valueType), (0, util_1.localizeTag)(value.type)), value);
+            }
+        }
+    }
+    return ans;
+};
+exports.list = list;
+const byteArray = (src, ctx) => {
+    const parser = core.list({ start: '[B;', value: primitive_1.primitive, sep: ',', trailingSep: false, end: ']' });
+    const ans = parser(src, ctx);
+    ans.type = 'nbt:byte_array';
+    // Check if every element is of the required type.
+    for (const { value } of ans.children) {
+        if (value && value.type !== 'nbt:byte') {
+            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.localize)('nbt.node.byte'), (0, util_1.localizeTag)(value.type)), value);
+        }
+    }
+    return ans;
+};
+exports.byteArray = byteArray;
+const intArray = (src, ctx) => {
+    const parser = core.list({ start: '[I;', value: primitive_1.primitive, sep: ',', trailingSep: false, end: ']' });
+    const ans = parser(src, ctx);
+    ans.type = 'nbt:int_array';
+    // Check if every element is of the required type.
+    for (const { value } of ans.children) {
+        if (value && value.type !== 'nbt:int') {
+            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.localize)('nbt.node.int'), (0, util_1.localizeTag)(value.type)), value);
+        }
+    }
+    return ans;
+};
+exports.intArray = intArray;
+const longArray = (src, ctx) => {
+    const parser = core.list({ start: '[L;', value: primitive_1.primitive, sep: ',', trailingSep: false, end: ']' });
+    const ans = parser(src, ctx);
+    ans.type = 'nbt:long_array';
+    // Check if every element is of the required type.
+    for (const { value } of ans.children) {
+        if (value && value.type !== 'nbt:long') {
+            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.localize)('nbt.node.long'), (0, util_1.localizeTag)(value.type)), value);
+        }
+    }
+    return ans;
+};
+exports.longArray = longArray;
+//# sourceMappingURL=collection.js.map

package/lib/parser/compound.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import type { NbtCompoundNode } from '../node';
+export declare const compound: core.InfallibleParser<NbtCompoundNode>;
+//# sourceMappingURL=compound.d.ts.map