@spyglassmc/java-edition 0.1.0

package/lib/mcfunction/completer/index.js

@@ -0,0 +1,14 @@
+"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 __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 });
+__exportStar(require("./argument"), exports);
+//# sourceMappingURL=index.js.map

package/lib/mcfunction/index.d.ts

@@ -0,0 +1,8 @@
+import type * as core from '@spyglassmc/core';
+import type { MajorVersion, McmetaCommands } from '../dependency';
+export * as checker from './checker';
+export * as colorizer from './colorizer';
+export * as completer from './completer';
+export * as parser from './parser';
+export declare const initialize: (ctx: core.ProjectInitializerContext, commands: McmetaCommands, majorVersion: MajorVersion) => void;
+//# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/index.js

@@ -0,0 +1,72 @@
+"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.initialize = exports.parser = exports.completer = exports.colorizer = exports.checker = void 0;
+const mcf = __importStar(require("@spyglassmc/mcfunction"));
+const checker = __importStar(require("./checker"));
+const colorizer = __importStar(require("./colorizer"));
+const completer = __importStar(require("./completer"));
+const inlayHintProvider_1 = require("./inlayHintProvider");
+const parser = __importStar(require("./parser"));
+const signatureHelpProvider_1 = require("./signatureHelpProvider");
+const tree_1 = require("./tree");
+exports.checker = __importStar(require("./checker"));
+exports.colorizer = __importStar(require("./colorizer"));
+exports.completer = __importStar(require("./completer"));
+exports.parser = __importStar(require("./parser"));
+// DOCS: Update here when a new major version of Minecraft is released.
+const Trees = new Map([
+    ['1.15', tree_1.Tree1_15],
+    ['1.16', tree_1.Tree1_16],
+    ['1.17', tree_1.Tree1_17],
+    ['1.18', tree_1.Tree1_18],
+    ['1.19', tree_1.Tree1_19],
+]);
+const LatestTree = (() => {
+    const values = [...Trees.values()];
+    return values[values.length - 1];
+})();
+/* istanbul ignore next */
+const initialize = (ctx, commands, majorVersion) => {
+    const { meta } = ctx;
+    mcf.initialize(ctx);
+    mcf.CommandTreeRegistry.instance.register(majorVersion, commands, Trees.get(majorVersion) ?? LatestTree);
+    meta.registerLanguage('mcfunction', {
+        extensions: ['.mcfunction'],
+        parser: mcf.entry(majorVersion, parser.argument),
+        completer: mcf.completer.entry(majorVersion, completer.getMockNodes),
+        triggerCharacters: [' ', '[', '=', '!', ',', '{', ':', '/', '.', '"', "'"],
+    });
+    meta.registerParser('mcfunction:block_predicate', parser.blockPredicate);
+    meta.registerParser('mcfunction:component', parser.component);
+    // TODO: 'mcfunction:particle'
+    // TODO: Uncomment in `SpecialStrings` in `nbtdocUtil.ts` as well.
+    meta.registerParser('mcfunction:tag', parser.tag());
+    meta.registerParser('mcfunction:team', parser.team());
+    meta.registerParser('mcfunction:command', mcf.command(mcf.CommandTreeRegistry.instance.get(majorVersion), parser.argument));
+    checker.register(meta);
+    colorizer.register(meta);
+    completer.register(meta);
+    meta.registerInlayHintProvider(inlayHintProvider_1.inlayHintProvider);
+    meta.registerSignatureHelpProvider((0, signatureHelpProvider_1.signatureHelpProvider)(majorVersion));
+};
+exports.initialize = initialize;
+//# sourceMappingURL=index.js.map

package/lib/mcfunction/inlayHintProvider.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import * as mcf from '@spyglassmc/mcfunction';
+export declare const inlayHintProvider: core.InlayHintProvider<core.FileNode<mcf.McfunctionNode>>;
+//# sourceMappingURL=inlayHintProvider.d.ts.map

package/lib/mcfunction/inlayHintProvider.js

@@ -0,0 +1,40 @@
+"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.inlayHintProvider = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const mcf = __importStar(require("@spyglassmc/mcfunction"));
+const inlayHintProvider = (node, ctx) => {
+    if (node.children[0]?.type !== 'mcfunction:entry') {
+        return [];
+    }
+    const ans = [];
+    core.traversePreOrder(node, _ => true, mcf.CommandChildNode.is, n => {
+        const node = n;
+        const config = ctx.config.env.feature.inlayHint;
+        if (config === true || (typeof config === 'object' && config.enabledNodes.includes(node.children[0].type))) {
+            ans.push({ offset: node.range.start, text: `${node.path[node.path.length - 1]}:` });
+        }
+    });
+    return ans;
+};
+exports.inlayHintProvider = inlayHintProvider;
+//# sourceMappingURL=inlayHintProvider.js.map

package/lib/mcfunction/node/argument.d.ts

@@ -0,0 +1,187 @@
+import * as core from '@spyglassmc/core';
+import type * as nbt from '@spyglassmc/nbt';
+export interface BlockStatesNode extends core.RecordBaseNode<core.StringNode, core.StringNode> {
+    type: 'mcfunction:block/states';
+}
+export declare namespace BlockStatesNode {
+    function is(node: core.AstNode): node is BlockStatesNode;
+}
+export interface BlockNode extends core.AstNode {
+    type: 'mcfunction:block';
+    children: (core.ResourceLocationNode | BlockStatesNode | nbt.NbtCompoundNode)[];
+    id: core.ResourceLocationNode;
+    states?: BlockStatesNode;
+    nbt?: nbt.NbtCompoundNode;
+}
+export declare namespace BlockNode {
+    function is(node: core.AstNode | undefined): node is BlockNode;
+    function mock(range: core.RangeLike, isPredicate: boolean): BlockNode;
+}
+export declare const CoordinateNotations: readonly ["", "~", "^"];
+export declare type CoordinateNodeNotation = typeof CoordinateNotations[number];
+export interface CoordinateNode extends core.FloatBaseNode {
+    type: 'mcfunction:coordinate';
+    notation: CoordinateNodeNotation;
+}
+export declare namespace CoordinateNode {
+    function mock(range: core.RangeLike): CoordinateNode;
+    /**
+     * @returns A number in the range `[-180.0, 180.0)`.
+     */
+    function toDegree(node: CoordinateNode): number;
+}
+export declare const enum CoordinateSystem {
+    World = 0,
+    Local = 1
+}
+export interface EntitySelectorAdvancementsArgumentCriteriaNode extends core.RecordBaseNode<core.StringNode, core.BooleanNode> {
+    type: 'mcfunction:entity_selector/arguments/advancements/criteria';
+}
+export interface EntitySelectorAdvancementsArgumentNode extends core.RecordBaseNode<core.ResourceLocationNode, core.BooleanNode | EntitySelectorAdvancementsArgumentCriteriaNode> {
+    type: 'mcfunction:entity_selector/arguments/advancements';
+}
+export interface EntitySelectorScoresArgumentNode extends core.RecordBaseNode<core.SymbolNode, IntRangeNode> {
+    type: 'mcfunction:entity_selector/arguments/scores';
+}
+export interface EntitySelectorInvertableArgumentValueNode<T extends core.AstNode> extends core.SequenceNode<core.LiteralNode | T> {
+    type: 'mcfunction:entity_selector/arguments/value/invertable';
+    value: T;
+    inverted: boolean;
+}
+export interface EntitySelectorArgumentsNode extends core.RecordBaseNode<core.StringNode, any> {
+    type: 'mcfunction:entity_selector/arguments';
+}
+export declare namespace EntitySelectorArgumentsNode {
+    function is(node: core.AstNode): node is EntitySelectorArgumentsNode;
+}
+export declare const EntitySelectorVariables: readonly ["a", "e", "p", "r", "s"];
+export declare type EntitySelectorVariable = typeof EntitySelectorVariables[number];
+export declare namespace EntitySelectorVariable {
+    function is(value: string): value is EntitySelectorVariable;
+}
+export declare const EntitySelectorAtVariables: ("@a" | "@e" | "@p" | "@r" | "@s")[];
+export declare type EntitySelectorAtVariable = typeof EntitySelectorAtVariables[number];
+export declare namespace EntitySelectorAtVariable {
+    function is(value: string): value is EntitySelectorAtVariable;
+}
+export interface EntitySelectorNode extends core.AstNode {
+    type: 'mcfunction:entity_selector';
+    children: [core.LiteralNode, ...[] | [EntitySelectorArgumentsNode]];
+    variable: EntitySelectorVariable;
+    arguments?: EntitySelectorArgumentsNode;
+    currentEntity?: boolean;
+    dimensionLimited?: boolean;
+    playersOnly?: boolean;
+    predicates?: string[];
+    chunkLimited?: boolean;
+    single?: boolean;
+    typeLimited?: boolean;
+}
+export declare namespace EntitySelectorNode {
+    function is(node: core.AstNode | undefined): node is EntitySelectorNode;
+    function mock(range: core.RangeLike): EntitySelectorNode;
+    const ArgumentKeys: Set<"predicate" | "tag" | "team" | "type" | "x" | "y" | "z" | "sort" | "level" | "advancements" | "nbt" | "name" | "scores" | "limit" | "distance" | "gamemode" | "dx" | "dy" | "dz" | "x_rotation" | "y_rotation">;
+    type ArgumentKey = typeof ArgumentKeys extends Set<infer T> ? T : undefined;
+    const enum Result {
+        Ok = 0,
+        Duplicated = 1,
+        NotApplicable = 2
+    }
+    function canKeyExist(selector: EntitySelectorNode, argument: EntitySelectorArgumentsNode, key: string): Result;
+}
+export interface EntityNode extends core.AstNode {
+    type: 'mcfunction:entity';
+    children: [core.StringNode | EntitySelectorNode | UuidNode];
+    playerName?: core.StringNode;
+    selector?: EntitySelectorNode;
+    uuid?: UuidNode;
+}
+export declare namespace EntityNode {
+    function is(node: core.AstNode | undefined): node is EntityNode;
+}
+export interface FloatRangeNode extends core.AstNode {
+    type: 'mcfunction:float_range';
+    children: (core.FloatNode | core.LiteralNode)[];
+    value: [number | undefined, number | undefined];
+}
+export interface ItemNode extends core.AstNode {
+    type: 'mcfunction:item';
+    children: (core.ResourceLocationNode | nbt.NbtCompoundNode)[];
+    id: core.ResourceLocationNode;
+    nbt?: nbt.NbtCompoundNode;
+}
+export declare namespace ItemNode {
+    function mock(range: core.RangeLike, isPredicate: boolean): ItemNode;
+}
+export interface IntRangeNode extends core.AstNode {
+    type: 'mcfunction:int_range';
+    children: (core.IntegerNode | core.LiteralNode)[];
+    value: [number | undefined, number | undefined];
+}
+export declare namespace IntRangeNode {
+    function mock(range: core.RangeLike): IntRangeNode;
+}
+export interface MessageNode extends core.AstNode {
+    type: 'mcfunction:message';
+    children: (core.StringNode | EntitySelectorNode)[];
+}
+export interface ObjectiveCriteriaNode extends core.AstNode {
+    type: 'mcfunction:objective_criteria';
+    children?: [core.ResourceLocationNode, core.ResourceLocationNode];
+    simpleValue?: string;
+}
+export declare namespace ObjectiveCriteriaNode {
+    const SimpleValues: string[];
+    const ComplexCategories: Map<string, "activity" | "attribute" | "block" | "block_entity_type" | "block_predicate_type" | "chunk_status" | "custom_stat" | "enchantment" | "entity_type" | "float_provider_type" | "fluid" | "game_event" | "height_provider_type" | "int_provider_type" | "item" | "loot_condition_type" | "loot_function_type" | "loot_nbt_provider_type" | "loot_number_provider_type" | "loot_pool_entry_type" | "loot_score_provider_type" | "memory_module_type" | "menu" | "mob_effect" | "motive" | "particle_type" | "point_of_interest_type" | "pos_rule_test" | "position_source_type" | "potion" | "recipe_serializer" | "recipe_type" | "rule_test" | "schedule" | "sensor_type" | "sound_event" | "stat_type" | "villager_profession" | "villager_type" | "worldgen/biome_source" | "worldgen/block_placer_type" | "worldgen/block_state_provider_type" | "worldgen/carver" | "worldgen/chunk_generator" | "worldgen/decorator" | "worldgen/feature" | "worldgen/feature_size_type" | "worldgen/foliage_placer_type" | "worldgen/material_condition" | "worldgen/material_rule" | "worldgen/placement_modifier_type" | "worldgen/structure_feature" | "worldgen/structure_piece" | "worldgen/structure_pool_element" | "worldgen/structure_processor" | "worldgen/surface_builder" | "worldgen/tree_decorator_type" | "worldgen/trunk_placer_type">;
+    const ComplexSep = ":";
+    function mock(range: core.RangeLike): ObjectiveCriteriaNode;
+}
+export interface ParticleNode extends core.AstNode {
+    type: 'mcfunction:particle';
+    children?: (core.FloatNode | core.IntegerNode | core.ResourceLocationNode | BlockNode | ItemNode | VectorNode)[];
+    id: core.ResourceLocationNode;
+}
+export declare namespace ParticleNode {
+    const SpecialTypes: Set<"block" | "item" | "block_marker" | "dust" | "dust_color_transition" | "falling_dust" | "sculk_charge" | "vibration">;
+    export type SpecialType = typeof SpecialTypes extends Set<infer T> ? T : undefined;
+    export function isSpecialType(type: string | undefined): type is SpecialType;
+    export function mock(range: core.RangeLike): ParticleNode;
+    export {};
+}
+export interface ScoreHolderNode extends core.AstNode {
+    type: 'mcfunction:score_holder';
+    children: [core.SymbolNode | EntitySelectorNode];
+    fakeName?: core.SymbolNode;
+    selector?: EntitySelectorNode;
+}
+export declare namespace ScoreHolderNode {
+    function mock(range: core.RangeLike): ScoreHolderNode;
+}
+export interface TimeNode extends core.AstNode {
+    type: 'mcfunction:time';
+    children: (core.FloatNode | core.LiteralNode)[];
+    value: number;
+    unit?: string;
+}
+export declare namespace TimeNode {
+    const UnitToTicks: Map<string, number>;
+    const Units: string[];
+}
+export interface UuidNode extends core.AstNode {
+    type: 'mcfunction:uuid';
+    bits: [bigint, bigint];
+}
+export interface VectorNode extends core.SequenceNode<CoordinateNode> {
+    type: 'mcfunction:vector';
+    options: VectorNode.Options;
+    system: CoordinateSystem;
+}
+export declare namespace VectorNode {
+    interface Options {
+        dimension: 2 | 3;
+        integersOnly?: boolean;
+        noLocal?: boolean;
+    }
+    function mock(range: core.RangeLike, options: Options): VectorNode;
+}
+//# sourceMappingURL=argument.d.ts.map

package/lib/mcfunction/node/argument.js

@@ -0,0 +1,281 @@
+"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.VectorNode = exports.TimeNode = exports.ScoreHolderNode = exports.ParticleNode = exports.ObjectiveCriteriaNode = exports.IntRangeNode = exports.ItemNode = exports.EntityNode = exports.EntitySelectorNode = exports.EntitySelectorAtVariable = exports.EntitySelectorAtVariables = exports.EntitySelectorVariable = exports.EntitySelectorVariables = exports.EntitySelectorArgumentsNode = exports.CoordinateNode = exports.CoordinateNotations = exports.BlockNode = exports.BlockStatesNode = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+var BlockStatesNode;
+(function (BlockStatesNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:block/states';
+    }
+    BlockStatesNode.is = is;
+})(BlockStatesNode = exports.BlockStatesNode || (exports.BlockStatesNode = {}));
+var BlockNode;
+(function (BlockNode) {
+    function is(node) {
+        return node?.type === 'mcfunction:block';
+    }
+    BlockNode.is = is;
+    function mock(range, isPredicate) {
+        const id = core.ResourceLocationNode.mock(range, { category: 'block', allowTag: isPredicate });
+        return {
+            type: 'mcfunction:block',
+            range: core.Range.get(range),
+            children: [id],
+            id,
+        };
+    }
+    BlockNode.mock = mock;
+})(BlockNode = exports.BlockNode || (exports.BlockNode = {}));
+exports.CoordinateNotations = ['', '~', '^'];
+var CoordinateNode;
+(function (CoordinateNode) {
+    function mock(range) {
+        return {
+            type: 'mcfunction:coordinate',
+            range: core.Range.get(range),
+            notation: '',
+            value: 0,
+        };
+    }
+    CoordinateNode.mock = mock;
+    /**
+     * @returns A number in the range `[-180.0, 180.0)`.
+     */
+    function toDegree(node) {
+        // TODO: For relative coordinates, const value = (node.value + baseCoordinate) % 360
+        const value = node.value % 360;
+        return value >= 180
+            ? value - 360
+            : value < -180 ? value + 360 : value;
+    }
+    CoordinateNode.toDegree = toDegree;
+})(CoordinateNode = exports.CoordinateNode || (exports.CoordinateNode = {}));
+var EntitySelectorArgumentsNode;
+(function (EntitySelectorArgumentsNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:entity_selector/arguments';
+    }
+    EntitySelectorArgumentsNode.is = is;
+})(EntitySelectorArgumentsNode = exports.EntitySelectorArgumentsNode || (exports.EntitySelectorArgumentsNode = {}));
+exports.EntitySelectorVariables = ['a', 'e', 'p', 'r', 's'];
+var EntitySelectorVariable;
+(function (EntitySelectorVariable) {
+    /* istanbul ignore next */
+    function is(value) {
+        return exports.EntitySelectorVariables.includes(value);
+    }
+    EntitySelectorVariable.is = is;
+})(EntitySelectorVariable = exports.EntitySelectorVariable || (exports.EntitySelectorVariable = {}));
+exports.EntitySelectorAtVariables = exports.EntitySelectorVariables.map(v => `@${v}`);
+var EntitySelectorAtVariable;
+(function (EntitySelectorAtVariable) {
+    /* istanbul ignore next */
+    function is(value) {
+        return exports.EntitySelectorAtVariables.includes(value);
+    }
+    EntitySelectorAtVariable.is = is;
+})(EntitySelectorAtVariable = exports.EntitySelectorAtVariable || (exports.EntitySelectorAtVariable = {}));
+var EntitySelectorNode;
+(function (EntitySelectorNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'mcfunction:entity_selector';
+    }
+    EntitySelectorNode.is = is;
+    function mock(range) {
+        const literal = core.LiteralNode.mock(range, { pool: exports.EntitySelectorAtVariables, colorTokenType: 'keyword' });
+        return {
+            type: 'mcfunction:entity_selector',
+            range: core.Range.get(range),
+            children: [literal],
+            variable: 'e',
+        };
+    }
+    EntitySelectorNode.mock = mock;
+    EntitySelectorNode.ArgumentKeys = new Set([
+        'advancements', 'distance', 'gamemode', 'level', 'limit', 'name',
+        'nbt', 'predicate', 'scores', 'sort', 'tag', 'team', 'type',
+        'x', 'y', 'z', 'dx', 'dy', 'dz', 'x_rotation', 'y_rotation',
+    ]);
+    function canKeyExist(selector, argument, key) {
+        const hasKey = (key) => !!argument.children.find(p => p.key?.value === key);
+        const hasNonInvertedKey = (key) => !!argument.children.find(p => p.key?.value === key && !p.value?.inverted);
+        switch (key) {
+            case 'advancements':
+            case 'distance':
+            case 'level':
+            case 'scores':
+            case 'x':
+            case 'y':
+            case 'z':
+            case 'dx':
+            case 'dy':
+            case 'dz':
+            case 'x_rotation':
+            case 'y_rotation':
+                return hasKey(key) ? 1 /* Duplicated */ : 0 /* Ok */;
+            case 'gamemode':
+            case 'name':
+            case 'team':
+                return hasNonInvertedKey(key) ? 1 /* Duplicated */ : 0 /* Ok */;
+            case 'limit':
+            case 'sort':
+                return selector.currentEntity
+                    ? 2 /* NotApplicable */
+                    : hasKey(key)
+                        ? 1 /* Duplicated */
+                        : 0 /* Ok */;
+            case 'type':
+                return selector.typeLimited
+                    ? hasKey(key)
+                        ? 1 /* Duplicated */
+                        : 2 /* NotApplicable */
+                    : 0 /* Ok */;
+        }
+        return 0 /* Ok */;
+    }
+    EntitySelectorNode.canKeyExist = canKeyExist;
+})(EntitySelectorNode = exports.EntitySelectorNode || (exports.EntitySelectorNode = {}));
+var EntityNode;
+(function (EntityNode) {
+    function is(node) {
+        return node?.type === 'mcfunction:entity';
+    }
+    EntityNode.is = is;
+})(EntityNode = exports.EntityNode || (exports.EntityNode = {}));
+var ItemNode;
+(function (ItemNode) {
+    function mock(range, isPredicate) {
+        const id = core.ResourceLocationNode.mock(range, { category: 'item', allowTag: isPredicate });
+        return {
+            type: 'mcfunction:item',
+            range: core.Range.get(range),
+            children: [id],
+            id,
+        };
+    }
+    ItemNode.mock = mock;
+})(ItemNode = exports.ItemNode || (exports.ItemNode = {}));
+var IntRangeNode;
+(function (IntRangeNode) {
+    function mock(range) {
+        return {
+            type: 'mcfunction:int_range',
+            range: core.Range.get(range),
+            children: [],
+            value: [undefined, undefined],
+        };
+    }
+    IntRangeNode.mock = mock;
+})(IntRangeNode = exports.IntRangeNode || (exports.IntRangeNode = {}));
+var ObjectiveCriteriaNode;
+(function (ObjectiveCriteriaNode) {
+    ObjectiveCriteriaNode.SimpleValues = [
+        'air', 'armor', 'deathCount', 'dummy', 'food', 'health', 'level',
+        'playerKillCount', 'totalKillCount', 'trigger', 'xp',
+    ];
+    ObjectiveCriteriaNode.ComplexCategories = new Map([
+        ['broken', 'item'],
+        ['crafted', 'item'],
+        ['custom', 'custom_stat'],
+        ['dropped', 'item'],
+        ['killed', 'entity_type'],
+        ['killed_by', 'entity_type'],
+        ['mined', 'block'],
+        ['picked_up', 'item'],
+        ['used', 'item'],
+    ]);
+    ObjectiveCriteriaNode.ComplexSep = ':';
+    function mock(range) {
+        return {
+            type: 'mcfunction:objective_criteria',
+            range: core.Range.get(range),
+        };
+    }
+    ObjectiveCriteriaNode.mock = mock;
+})(ObjectiveCriteriaNode = exports.ObjectiveCriteriaNode || (exports.ObjectiveCriteriaNode = {}));
+var ParticleNode;
+(function (ParticleNode) {
+    const SpecialTypes = new Set([
+        'block',
+        'block_marker',
+        'dust',
+        'dust_color_transition',
+        'falling_dust',
+        'item',
+        'sculk_charge',
+        'vibration',
+    ]);
+    function isSpecialType(type) {
+        return SpecialTypes.has(type);
+    }
+    ParticleNode.isSpecialType = isSpecialType;
+    function mock(range) {
+        const id = core.ResourceLocationNode.mock(range, { category: 'particle_type' });
+        return {
+            type: 'mcfunction:particle',
+            range: core.Range.get(range),
+            children: [id],
+            id,
+        };
+    }
+    ParticleNode.mock = mock;
+})(ParticleNode = exports.ParticleNode || (exports.ParticleNode = {}));
+var ScoreHolderNode;
+(function (ScoreHolderNode) {
+    function mock(range) {
+        const fakeName = core.SymbolNode.mock(range, { category: 'score_holder' });
+        return {
+            type: 'mcfunction:score_holder',
+            range: core.Range.get(range),
+            children: [fakeName],
+            fakeName,
+        };
+    }
+    ScoreHolderNode.mock = mock;
+})(ScoreHolderNode = exports.ScoreHolderNode || (exports.ScoreHolderNode = {}));
+var TimeNode;
+(function (TimeNode) {
+    TimeNode.UnitToTicks = new Map([
+        ['', 1],
+        ['t', 1],
+        ['s', 20],
+        ['d', 24000],
+    ]);
+    TimeNode.Units = [...TimeNode.UnitToTicks.keys()];
+})(TimeNode = exports.TimeNode || (exports.TimeNode = {}));
+var VectorNode;
+(function (VectorNode) {
+    function mock(range, options) {
+        return {
+            type: 'mcfunction:vector',
+            range: core.Range.get(range),
+            children: [],
+            options,
+            system: 0 /* World */,
+        };
+    }
+    VectorNode.mock = mock;
+})(VectorNode = exports.VectorNode || (exports.VectorNode = {}));
+//# sourceMappingURL=argument.js.map

package/lib/mcfunction/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './argument';
+//# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/node/index.js

@@ -0,0 +1,14 @@
+"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 __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 });
+__exportStar(require("./argument"), exports);
+//# sourceMappingURL=index.js.map

package/lib/mcfunction/parser/argument.d.ts

@@ -0,0 +1,15 @@
+import * as core from '@spyglassmc/core';
+import * as json from '@spyglassmc/json';
+import * as mcf from '@spyglassmc/mcfunction';
+import type { BlockNode } from '../node';
+/**
+ * @returns The parser for the specified argument tree node. All argument parsers used in the `mcfunction` package
+ * fail on empty input.
+ */
+export declare const argument: mcf.ArgumentParserGetter;
+export declare const blockPredicate: core.InfallibleParser<BlockNode>;
+export declare const component: core.Parser<json.JsonNode>;
+export declare const scoreHolderFakeName: core.Parser<core.SymbolNode>;
+export declare function tag(terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
+export declare function team(usageType?: core.SymbolUsageType, terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
+//# sourceMappingURL=argument.d.ts.map