@spyglassmc/java-edition 0.3.8 → 0.3.9

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

@@ -1,5 +1,6 @@
 import * as core from '@spyglassmc/core';
 import type * as nbt from '@spyglassmc/nbt';
+import type { NbtParserProperties } from '../tree/argument.js';
 export interface BlockStatesNode extends core.RecordBaseNode<core.StringNode, core.StringNode> {
     type: 'mcfunction:block/states';
 }
@@ -12,6 +13,7 @@ export interface BlockNode extends core.AstNode {
     id: core.ResourceLocationNode;
     states?: BlockStatesNode;
     nbt?: nbt.NbtCompoundNode;
+    isPredicate: boolean;
 }
 export declare namespace BlockNode {
     function is(node: core.DeepReadonly<core.AstNode> | undefined): node is BlockNode;
@@ -54,15 +56,19 @@ export interface EntitySelectorArgumentsNode extends core.RecordBaseNode<core.St
 export declare namespace EntitySelectorArgumentsNode {
     function is(node: core.AstNode): node is EntitySelectorArgumentsNode;
 }
-export declare const EntitySelectorVariables: readonly ["a", "e", "p", "r", "s"];
+declare const EntitySelectorVariables: readonly ["a", "e", "p", "r", "s", "n"];
 export 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")[];
+declare const EntitySelectorAtVariables: ("@a" | "@e" | "@p" | "@r" | "@s" | "@n")[];
 export type EntitySelectorAtVariable = typeof EntitySelectorAtVariables[number];
 export declare namespace EntitySelectorAtVariable {
     function is(value: string): value is EntitySelectorAtVariable;
+    /**
+     * Should be used to get a list of available selectors for the current version.
+     */
+    function filterAvailable(ctx: core.ContextBase): ("@a" | "@e" | "@p" | "@r" | "@s" | "@n")[];
 }
 export interface EntitySelectorNode extends core.AstNode {
     type: 'mcfunction:entity_selector';
@@ -79,8 +85,8 @@ export interface EntitySelectorNode extends core.AstNode {
 }
 export declare namespace EntitySelectorNode {
     function is<T extends core.DeepReadonly<core.AstNode> | undefined>(node: T): node is core.InheritReadonly<EntitySelectorNode, T>;
-    function mock(range: core.RangeLike): EntitySelectorNode;
-    const ArgumentKeys: Set<"predicate" | "tag" | "team" | "type" | "level" | "advancements" | "sort" | "distance" | "gamemode" | "limit" | "name" | "nbt" | "scores" | "x" | "y" | "z" | "dx" | "dy" | "dz" | "x_rotation" | "y_rotation">;
+    function mock(range: core.RangeLike, options: core.LiteralOptions): EntitySelectorNode;
+    const ArgumentKeys: Set<"tag" | "team" | "predicate" | "type" | "level" | "advancements" | "nbt" | "sort" | "distance" | "gamemode" | "limit" | "name" | "scores" | "x" | "y" | "z" | "dx" | "dy" | "dz" | "x_rotation" | "y_rotation">;
     type ArgumentKey = typeof ArgumentKeys extends Set<infer T> ? T : undefined;
     const enum Result {
         Ok = 0,
@@ -104,15 +110,85 @@ export interface FloatRangeNode extends core.AstNode {
     children: (core.FloatNode | core.LiteralNode)[];
     value: [number | undefined, number | undefined];
 }
-export interface ItemNode extends core.AstNode {
-    type: 'mcfunction:item';
-    children: (core.ResourceLocationNode | nbt.NbtCompoundNode)[];
+export interface ItemStackNode extends core.AstNode {
+    type: 'mcfunction:item_stack';
+    children: (core.ResourceLocationNode | ComponentListNode | nbt.NbtCompoundNode)[];
     id: core.ResourceLocationNode;
+    components?: ComponentListNode;
+    nbt?: nbt.NbtCompoundNode;
+}
+export declare namespace ItemStackNode {
+    function is(node: core.AstNode | undefined): node is ItemStackNode;
+    function mock(range: core.RangeLike): ItemStackNode;
+}
+export interface ComponentListNode extends core.AstNode {
+    type: 'mcfunction:component_list';
+    children: core.PairNode<core.ResourceLocationNode, nbt.NbtNode>[];
+}
+export declare namespace ComponentListNode {
+    function is(node: core.AstNode): node is ComponentListNode;
+}
+export interface ItemPredicateNode extends core.AstNode {
+    type: 'mcfunction:item_predicate';
+    children: (core.ResourceLocationNode | core.LiteralNode | ComponentTestsNode | nbt.NbtCompoundNode)[];
+    id: core.ResourceLocationNode | core.LiteralNode;
+    tests?: ComponentTestsNode;
     nbt?: nbt.NbtCompoundNode;
 }
-export declare namespace ItemNode {
-    function is(node: core.AstNode | undefined): node is ItemNode;
-    function mock(range: core.RangeLike, isPredicate: boolean): ItemNode;
+export declare namespace ItemPredicateNode {
+    function is(node: core.AstNode | undefined): node is ItemPredicateNode;
+    function mock(range: core.RangeLike): ItemPredicateNode;
+}
+export interface ComponentTestsNode extends core.AstNode {
+    type: 'mcfunction:component_tests';
+    children?: [ComponentTestsAnyOfNode];
+}
+export declare namespace ComponentTestsNode {
+    function is(node: core.AstNode): node is ComponentTestsNode;
+}
+export interface ComponentTestsAnyOfNode extends core.AstNode {
+    type: 'mcfunction:component_tests_any_of';
+    children: ComponentTestsAllOfNode[];
+}
+export declare namespace ComponentTestsAnyOfNode {
+    function is(node: core.AstNode): node is ComponentTestsAnyOfNode;
+}
+export interface ComponentTestsAllOfNode extends core.AstNode {
+    type: 'mcfunction:component_tests_all_of';
+    children: ComponentTestNode[];
+}
+export declare namespace ComponentTestsAllOfNode {
+    function is(node: core.AstNode): node is ComponentTestsAllOfNode;
+}
+export type ComponentTestNode = ComponentTestExactNode | ComponentTestExistsNode | ComponentTestSubpredicateNode;
+export interface ComponentTestBaseNode extends core.AstNode {
+    negated: boolean;
+}
+export interface ComponentTestExactNode extends ComponentTestBaseNode {
+    type: 'mcfunction:component_test_exact';
+    children: (core.ResourceLocationNode | nbt.NbtNode)[];
+    key: core.ResourceLocationNode;
+    value?: nbt.NbtNode;
+}
+export declare namespace ComponentTestExactNode {
+    function is(node: core.AstNode): node is ComponentTestExactNode;
+}
+export interface ComponentTestExistsNode extends ComponentTestBaseNode {
+    type: 'mcfunction:component_test_exists';
+    children: [core.ResourceLocationNode];
+    key: core.ResourceLocationNode;
+}
+export declare namespace ComponentTestExistsNode {
+    function is(node: core.AstNode): node is ComponentTestExistsNode;
+}
+export interface ComponentTestSubpredicateNode extends ComponentTestBaseNode {
+    type: 'mcfunction:component_test_sub_predicate';
+    children: (core.ResourceLocationNode | nbt.NbtNode)[];
+    key: core.ResourceLocationNode;
+    value?: nbt.NbtNode;
+}
+export declare namespace ComponentTestSubpredicateNode {
+    function is(node: core.AstNode): node is ComponentTestSubpredicateNode;
 }
 export interface IntRangeNode extends core.AstNode {
     type: 'mcfunction:int_range';
@@ -126,6 +202,30 @@ export interface MessageNode extends core.AstNode {
     type: 'mcfunction:message';
     children: (core.StringNode | EntitySelectorNode)[];
 }
+export interface NbtNode extends core.AstNode {
+    type: 'mcfunction:nbt';
+    children: [nbt.NbtNode];
+    properties?: NbtParserProperties;
+}
+export declare namespace NbtNode {
+    function is(node: core.AstNode): node is NbtNode;
+}
+export interface NbtPathNode extends core.AstNode {
+    type: 'mcfunction:nbt_path';
+    children: [nbt.NbtPathNode];
+    properties?: NbtParserProperties;
+}
+export declare namespace NbtPathNode {
+    function is(node: core.AstNode): node is NbtPathNode;
+}
+export interface NbtResourceNode extends core.AstNode {
+    type: 'mcfunction:nbt_resource';
+    children: [nbt.NbtNode];
+    category: string;
+}
+export declare namespace NbtResourceNode {
+    function is(node: core.AstNode): node is NbtResourceNode;
+}
 export interface ObjectiveCriteriaNode extends core.AstNode {
     type: 'mcfunction:objective_criteria';
     children?: [core.ResourceLocationNode, core.ResourceLocationNode];
@@ -133,19 +233,21 @@ export interface ObjectiveCriteriaNode extends core.AstNode {
 }
 export declare namespace ObjectiveCriteriaNode {
     const SimpleValues: string[];
-    const ComplexCategories: Map<string, "block" | "fluid" | "activity" | "attribute" | "block_entity_type" | "block_predicate_type" | "chunk_status" | "custom_stat" | "enchantment" | "entity_type" | "float_provider_type" | "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 ComplexCategories: Map<string, "block" | "fluid" | "activity" | "armor_material" | "attribute" | "block_entity_type" | "block_predicate_type" | "block_type" | "cat_variant" | "chunk_status" | "command_argument_type" | "creative_mode_tab" | "custom_stat" | "data_component_type" | "decorated_pot_pattern" | "enchantment_effect_component_type" | "enchantment_entity_effect_type" | "enchantment_level_based_value_type" | "enchantment_location_based_effect_type" | "enchantment_provider_type" | "enchantment_value_effect_type" | "entity_sub_predicate_type" | "entity_type" | "float_provider_type" | "frog_variant" | "game_event" | "height_provider_type" | "instrument" | "int_provider_type" | "item" | "item_sub_predicate_type" | "loot_condition_type" | "loot_function_type" | "loot_nbt_provider_type" | "loot_number_provider_type" | "loot_pool_entry_type" | "loot_score_provider_type" | "map_decoration_type" | "memory_module_type" | "menu" | "mob_effect" | "motive" | "number_format_type" | "particle_type" | "point_of_interest_type" | "pos_rule_test" | "position_source_type" | "potion" | "recipe_serializer" | "recipe_type" | "rule_block_entity_modifier" | "rule_test" | "schedule" | "sensor_type" | "sound_event" | "stat_type" | "trigger_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/density_function_type" | "worldgen/feature" | "worldgen/feature_size_type" | "worldgen/foliage_placer_type" | "worldgen/material_condition" | "worldgen/material_rule" | "worldgen/placement_modifier_type" | "worldgen/pool_alias_binding" | "worldgen/root_placer_type" | "worldgen/structure_feature" | "worldgen/structure_piece" | "worldgen/structure_placement" | "worldgen/structure_pool_element" | "worldgen/structure_processor" | "worldgen/structure_type" | "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)[];
+    children?: (core.ResourceLocationNode | core.FloatNode | core.IntegerNode | BlockNode | ItemStackNode | VectorNode | nbt.NbtCompoundNode)[];
     id: core.ResourceLocationNode;
 }
 export declare namespace ParticleNode {
     const SpecialTypes: Set<"block" | "item" | "block_marker" | "dust" | "dust_color_transition" | "falling_dust" | "sculk_charge" | "shriek" | "vibration">;
     export type SpecialType = typeof SpecialTypes extends Set<infer T> ? T : undefined;
     export function isSpecialType(type: string | undefined): type is SpecialType;
+    export type OptionType = typeof SpecialTypes extends Set<infer T> ? T : undefined;
+    export function requiresOptions(type: string | undefined): type is OptionType;
     export function is(node: core.AstNode | undefined): node is ParticleNode;
     export function mock(range: core.RangeLike): ParticleNode;
     export {};
@@ -186,4 +288,5 @@ export declare namespace VectorNode {
     }
     function mock(range: core.RangeLike, options: Options): VectorNode;
 }
+export {};
 //# sourceMappingURL=argument.d.ts.map

package/lib/mcfunction/node/argument.js

@@ -1,4 +1,5 @@
 import * as core from '@spyglassmc/core';
+import { ReleaseVersion } from '../../dependency/common.js';
 export var BlockStatesNode;
 (function (BlockStatesNode) {
     /* istanbul ignore next */
@@ -14,15 +15,13 @@ export var BlockNode;
     }
     BlockNode.is = is;
     function mock(range, isPredicate) {
-        const id = core.ResourceLocationNode.mock(range, {
-            category: 'block',
-            allowTag: isPredicate,
-        });
+        const id = core.ResourceLocationNode.mock(range, { category: 'block', allowTag: isPredicate });
         return {
             type: 'mcfunction:block',
             range: core.Range.get(range),
             children: [id],
             id,
+            isPredicate: false,
         };
     }
     BlockNode.mock = mock;
@@ -31,12 +30,7 @@ export const CoordinateNotations = ['', '~', '^'];
 export var CoordinateNode;
 (function (CoordinateNode) {
     function mock(range) {
-        return {
-            type: 'mcfunction:coordinate',
-            range: core.Range.get(range),
-            notation: '',
-            value: 0,
-        };
+        return { type: 'mcfunction:coordinate', range: core.Range.get(range), notation: '', value: 0 };
     }
     CoordinateNode.mock = mock;
     /**
@@ -53,12 +47,11 @@ export var EntitySelectorArgumentsNode;
 (function (EntitySelectorArgumentsNode) {
     /* istanbul ignore next */
     function is(node) {
-        return (node.type ===
-            'mcfunction:entity_selector/arguments');
+        return (node.type === 'mcfunction:entity_selector/arguments');
     }
     EntitySelectorArgumentsNode.is = is;
 })(EntitySelectorArgumentsNode || (EntitySelectorArgumentsNode = {}));
-export const EntitySelectorVariables = ['a', 'e', 'p', 'r', 's'];
+const EntitySelectorVariables = ['a', 'e', 'p', 'r', 's', 'n'];
 export var EntitySelectorVariable;
 (function (EntitySelectorVariable) {
     /* istanbul ignore next */
@@ -67,7 +60,7 @@ export var EntitySelectorVariable;
     }
     EntitySelectorVariable.is = is;
 })(EntitySelectorVariable || (EntitySelectorVariable = {}));
-export const EntitySelectorAtVariables = EntitySelectorVariables.map((v) => `@${v}`);
+const EntitySelectorAtVariables = EntitySelectorVariables.map((v) => `@${v}`);
 export var EntitySelectorAtVariable;
 (function (EntitySelectorAtVariable) {
     /* istanbul ignore next */
@@ -75,20 +68,24 @@ export var EntitySelectorAtVariable;
         return EntitySelectorAtVariables.includes(value);
     }
     EntitySelectorAtVariable.is = is;
+    /**
+     * Should be used to get a list of available selectors for the current version.
+     */
+    function filterAvailable(ctx) {
+        const release = ctx.project['loadedVersion'];
+        return EntitySelectorAtVariables.filter(variable => !(variable === '@n' && release && ReleaseVersion.cmp(release, '1.21') < 0));
+    }
+    EntitySelectorAtVariable.filterAvailable = filterAvailable;
 })(EntitySelectorAtVariable || (EntitySelectorAtVariable = {}));
 export var EntitySelectorNode;
 (function (EntitySelectorNode) {
     /* istanbul ignore next */
     function is(node) {
-        return (node?.type ===
-            'mcfunction:entity_selector');
+        return (node?.type === 'mcfunction:entity_selector');
     }
     EntitySelectorNode.is = is;
-    function mock(range) {
-        const literal = core.LiteralNode.mock(range, {
-            pool: EntitySelectorAtVariables,
-            colorTokenType: 'keyword',
-        });
+    function mock(range, options) {
+        const literal = core.LiteralNode.mock(range, options);
         return {
             type: 'mcfunction:entity_selector',
             range: core.Range.get(range),
@@ -122,9 +119,8 @@ export var EntitySelectorNode;
     ]);
     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);
+        const hasNonInvertedKey = (key) => !!argument.children.find((p) => p.key?.value === key
+            && !p.value?.inverted);
         switch (key) {
             case 'advancements':
             case 'distance':
@@ -152,9 +148,7 @@ export var EntitySelectorNode;
                         : 0 /* Result.Ok */;
             case 'type':
                 return selector.typeLimited
-                    ? hasKey(key)
-                        ? 1 /* Result.Duplicated */
-                        : 2 /* Result.NotApplicable */
+                    ? hasKey(key) ? 1 /* Result.Duplicated */ : 2 /* Result.NotApplicable */
                     : 0 /* Result.Ok */;
         }
         return 0 /* Result.Ok */;
@@ -168,26 +162,80 @@ export var EntityNode;
     }
     EntityNode.is = is;
 })(EntityNode || (EntityNode = {}));
-export var ItemNode;
-(function (ItemNode) {
+export var ItemStackNode;
+(function (ItemStackNode) {
     function is(node) {
-        return node?.type === 'mcfunction:item';
+        return node?.type === 'mcfunction:item_stack';
     }
-    ItemNode.is = is;
-    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,
-        };
+    ItemStackNode.is = is;
+    function mock(range) {
+        const id = core.ResourceLocationNode.mock(range, { category: 'item' });
+        return { type: 'mcfunction:item_stack', range: core.Range.get(range), children: [id], id };
+    }
+    ItemStackNode.mock = mock;
+})(ItemStackNode || (ItemStackNode = {}));
+export var ComponentListNode;
+(function (ComponentListNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_list';
+    }
+    ComponentListNode.is = is;
+})(ComponentListNode || (ComponentListNode = {}));
+export var ItemPredicateNode;
+(function (ItemPredicateNode) {
+    function is(node) {
+        return node?.type === 'mcfunction:item_predicate';
+    }
+    ItemPredicateNode.is = is;
+    function mock(range) {
+        const id = core.ResourceLocationNode.mock(range, { category: 'item', allowTag: true });
+        return { type: 'mcfunction:item_predicate', range: core.Range.get(range), children: [id], id };
+    }
+    ItemPredicateNode.mock = mock;
+})(ItemPredicateNode || (ItemPredicateNode = {}));
+export var ComponentTestsNode;
+(function (ComponentTestsNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_tests';
+    }
+    ComponentTestsNode.is = is;
+})(ComponentTestsNode || (ComponentTestsNode = {}));
+export var ComponentTestsAnyOfNode;
+(function (ComponentTestsAnyOfNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_tests_any_of';
+    }
+    ComponentTestsAnyOfNode.is = is;
+})(ComponentTestsAnyOfNode || (ComponentTestsAnyOfNode = {}));
+export var ComponentTestsAllOfNode;
+(function (ComponentTestsAllOfNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_tests_all_of';
+    }
+    ComponentTestsAllOfNode.is = is;
+})(ComponentTestsAllOfNode || (ComponentTestsAllOfNode = {}));
+export var ComponentTestExactNode;
+(function (ComponentTestExactNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_test_exact';
+    }
+    ComponentTestExactNode.is = is;
+})(ComponentTestExactNode || (ComponentTestExactNode = {}));
+export var ComponentTestExistsNode;
+(function (ComponentTestExistsNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_test_exists';
+    }
+    ComponentTestExistsNode.is = is;
+})(ComponentTestExistsNode || (ComponentTestExistsNode = {}));
+export var ComponentTestSubpredicateNode;
+(function (ComponentTestSubpredicateNode) {
+    function is(node) {
+        return node.type
+            === 'mcfunction:component_test_sub_predicate';
     }
-    ItemNode.mock = mock;
-})(ItemNode || (ItemNode = {}));
+    ComponentTestSubpredicateNode.is = is;
+})(ComponentTestSubpredicateNode || (ComponentTestSubpredicateNode = {}));
 export var IntRangeNode;
 (function (IntRangeNode) {
     function mock(range) {
@@ -200,6 +248,30 @@ export var IntRangeNode;
     }
     IntRangeNode.mock = mock;
 })(IntRangeNode || (IntRangeNode = {}));
+export var NbtNode;
+(function (NbtNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:nbt';
+    }
+    NbtNode.is = is;
+})(NbtNode || (NbtNode = {}));
+export var NbtPathNode;
+(function (NbtPathNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:nbt_path';
+    }
+    NbtPathNode.is = is;
+})(NbtPathNode || (NbtPathNode = {}));
+export var NbtResourceNode;
+(function (NbtResourceNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:nbt_resource';
+    }
+    NbtResourceNode.is = is;
+})(NbtResourceNode || (NbtResourceNode = {}));
 export var ObjectiveCriteriaNode;
 (function (ObjectiveCriteriaNode) {
     ObjectiveCriteriaNode.SimpleValues = [
@@ -228,15 +300,13 @@ export var ObjectiveCriteriaNode;
     ]);
     ObjectiveCriteriaNode.ComplexSep = ':';
     function mock(range) {
-        return {
-            type: 'mcfunction:objective_criteria',
-            range: core.Range.get(range),
-        };
+        return { type: 'mcfunction:objective_criteria', range: core.Range.get(range) };
     }
     ObjectiveCriteriaNode.mock = mock;
 })(ObjectiveCriteriaNode || (ObjectiveCriteriaNode = {}));
 export var ParticleNode;
 (function (ParticleNode) {
+    // until 1.20.5
     const SpecialTypes = new Set([
         'block',
         'block_marker',
@@ -252,20 +322,23 @@ export var ParticleNode;
         return SpecialTypes.has(type);
     }
     ParticleNode.isSpecialType = isSpecialType;
+    // since 1.20.5
+    const OptionTypes = new Set([
+        ...SpecialTypes,
+        'dust_pillar',
+        'entity_effect',
+    ]);
+    function requiresOptions(type) {
+        return OptionTypes.has(type);
+    }
+    ParticleNode.requiresOptions = requiresOptions;
     function is(node) {
         return node?.type === 'mcfunction:particle';
     }
     ParticleNode.is = is;
     function mock(range) {
-        const id = core.ResourceLocationNode.mock(range, {
-            category: 'particle_type',
-        });
-        return {
-            type: 'mcfunction:particle',
-            range: core.Range.get(range),
-            children: [id],
-            id,
-        };
+        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 || (ParticleNode = {}));
@@ -284,12 +357,7 @@ export var ScoreHolderNode;
 })(ScoreHolderNode || (ScoreHolderNode = {}));
 export var TimeNode;
 (function (TimeNode) {
-    TimeNode.UnitToTicks = new Map([
-        ['', 1],
-        ['t', 1],
-        ['s', 20],
-        ['d', 24000],
-    ]);
+    TimeNode.UnitToTicks = new Map([['', 1], ['t', 1], ['s', 20], ['d', 24000]]);
     TimeNode.Units = [...TimeNode.UnitToTicks.keys()];
 })(TimeNode || (TimeNode = {}));
 export var VectorNode;

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

@@ -1,16 +1,26 @@
 import * as core from '@spyglassmc/core';
 import * as json from '@spyglassmc/json';
 import * as mcf from '@spyglassmc/mcfunction';
-import type { BlockNode, ParticleNode } from '../node/index.js';
+import type { BlockNode, EntityNode, ParticleNode, ScoreHolderNode, UuidNode } from '../node/index.js';
+import { EntitySelectorNode } from '../node/index.js';
 /**
  * @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 function entity(amount: 'multiple' | 'single', type: 'entities' | 'players'): core.Parser<EntityNode>;
+export declare const itemSlots: core.InfallibleParser<core.LiteralNode>;
+export declare function jsonParser(typeRef: `::${string}::${string}`): core.Parser<json.TypedJsonNode>;
 export declare const particle: core.InfallibleParser<ParticleNode>;
-export declare const scoreHolderFakeName: core.Parser<core.SymbolNode>;
-export declare function tag(terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
+/**
+ * Failure when not beginning with `@[parse]`
+ */
+export declare function selector(ignoreInvalidPrefix?: boolean): core.Parser<EntitySelectorNode>;
+export declare function scoreHolderFakeName(usageType: core.SymbolUsageType): core.Parser<core.SymbolNode>;
+export declare function scoreHolder(usageType: core.SymbolUsageType, amount: 'multiple' | 'single'): core.Parser<ScoreHolderNode>;
+export declare function objective(usageType?: core.SymbolUsageType, terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
+export declare function tag(usageType?: core.SymbolUsageType, terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
 export declare function team(usageType?: core.SymbolUsageType, terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
+export declare const uuid: core.InfallibleParser<UuidNode>;
 //# sourceMappingURL=argument.d.ts.map