@spyglassmc/java-edition 0.3.7 → 0.3.9

package/lib/mcfunction/parser/argument.js

@@ -5,8 +5,8 @@ import { localeQuote, localize } from '@spyglassmc/locales';
 import * as mcf from '@spyglassmc/mcfunction';
 import * as nbt from '@spyglassmc/nbt';
 import { ReleaseVersion } from '../../dependency/index.js';
-import { ColorArgumentValues, EntityAnchorArgumentValues, GamemodeArgumentValues, HeightmapValues, ItemSlotArgumentValues, MirrorValues, OperationArgumentValues, RotationValues, ScoreboardSlotArgumentValues, SwizzleArgumentValues, } from '../common/index.js';
-import { BlockStatesNode, EntitySelectorArgumentsNode, EntitySelectorAtVariable, EntitySelectorAtVariables, EntitySelectorNode, ObjectiveCriteriaNode, TimeNode, } from '../node/index.js';
+import { ColorArgumentValues, EntityAnchorArgumentValues, GamemodeArgumentValues, getItemSlotArgumentValues, getItemSlotsArgumentValues, getScoreboardSlotArgumentValues, HeightmapValues, MirrorValues, OperationArgumentValues, RotationValues, SwizzleArgumentValues, } from '../common/index.js';
+import { BlockStatesNode, ComponentListNode, ComponentTestsNode, EntitySelectorArgumentsNode, EntitySelectorAtVariable, EntitySelectorNode, ObjectiveCriteriaNode, TimeNode, } from '../node/index.js';
 const IntegerPattern = /^-?\d+$/;
 /**
  * A combination of:
@@ -37,6 +37,10 @@ function shouldValidateLength(ctx) {
     const release = ctx.project['loadedVersion'];
     return !release || ReleaseVersion.cmp(release, '1.18') < 0;
 }
+function shouldUseOldItemStackFormat(ctx) {
+    const release = ctx.project['loadedVersion'];
+    return !release || ReleaseVersion.cmp(release, '1.20.5') < 0;
+}
 /**
  * @returns The parser for the specified argument tree node. All argument parsers used in the `mcfunction` package
  * fail on empty input.
@@ -83,26 +87,19 @@ export const argument = (rawTreeNode) => {
         case 'minecraft:column_pos':
             return wrap(vector({ dimension: 2, integersOnly: true }));
         case 'minecraft:component':
-            return wrap(component);
+            return wrap(jsonParser('::java::server::util::text::Text'));
         case 'minecraft:dimension':
-            return wrap(core.resourceLocation({
-                category: 'dimension',
-            }));
+            return wrap(core.resourceLocation({ category: 'dimension' }));
         case 'minecraft:entity':
             return wrap(entity(treeNode.properties.amount, treeNode.properties.type));
         case 'minecraft:entity_anchor':
             return wrap(core.literal(...EntityAnchorArgumentValues));
         case 'minecraft:entity_summon':
-            return wrap(core.resourceLocation({
-                category: 'entity_type',
-            }));
+            return wrap(core.resourceLocation({ category: 'entity_type' }));
         case 'minecraft:float_range':
             return wrap(range('float'));
         case 'minecraft:function':
-            return wrap(core.resourceLocation({
-                category: 'function',
-                allowTag: true,
-            }));
+            return wrap(core.resourceLocation({ category: 'function', allowTag: true }));
         case 'minecraft:gamemode':
             return wrap(core.literal(...GamemodeArgumentValues));
         case 'minecraft:game_profile':
@@ -112,27 +109,31 @@ export const argument = (rawTreeNode) => {
         case 'minecraft:int_range':
             return wrap(range('integer'));
         case 'minecraft:item_enchantment':
-            return wrap(core.resourceLocation({
-                category: 'enchantment',
-            }));
+            return wrap(core.resourceLocation({ category: 'enchantment' }));
         case 'minecraft:item_predicate':
             return wrap(itemPredicate);
         case 'minecraft:item_slot':
-            return wrap(core.literal(...ItemSlotArgumentValues));
+            return wrap(itemSlot);
+        case 'minecraft:item_slots':
+            return wrap(itemSlots);
         case 'minecraft:item_stack':
             return wrap(itemStack);
+        case 'minecraft:loot_modifier':
+            return wrap(resourceOrInline('item_modifier'));
+        case 'minecraft:loot_predicate':
+            return wrap(resourceOrInline('predicate'));
+        case 'minecraft:loot_table':
+            return wrap(resourceOrInline('loot_table'));
         case 'minecraft:message':
             return wrap(message);
         case 'minecraft:mob_effect':
-            return wrap(core.resourceLocation({
-                category: 'mob_effect',
-            }));
+            return wrap(core.resourceLocation({ category: 'mob_effect' }));
         case 'minecraft:nbt_compound_tag':
-            return wrap(nbt.parser.compound);
+            return wrap(nbtParser(nbt.parser.compound, treeNode.properties));
         case 'minecraft:nbt_path':
-            return wrap(nbt.parser.path);
+            return wrap(nbtPathParser(nbt.parser.path, treeNode.properties));
         case 'minecraft:nbt_tag':
-            return wrap(nbt.parser.entry);
+            return wrap(nbtParser(nbt.parser.entry, treeNode.properties));
         case 'minecraft:objective':
             return wrap(objective(core.SymbolUsageType.is(treeNode.properties?.usageType)
                 ? treeNode.properties?.usageType
@@ -140,32 +141,33 @@ export const argument = (rawTreeNode) => {
         case 'minecraft:objective_criteria':
             return wrap(objectiveCriteria);
         case 'minecraft:operation':
-            return wrap(core.literal({
-                pool: OperationArgumentValues,
-                colorTokenType: 'operator',
-            }));
+            return wrap(core.literal({ pool: OperationArgumentValues, colorTokenType: 'operator' }));
         case 'minecraft:particle':
             return wrap(particle);
         case 'minecraft:resource':
         case 'minecraft:resource_key':
         case 'minecraft:resource_or_tag':
+        case 'minecraft:resource_or_tag_key':
+            const allowTag = treeNode.parser === 'minecraft:resource_or_tag'
+                || treeNode.parser === 'minecraft:resource_or_tag_key';
             return wrap(core.resourceLocation({
                 category: core.ResourceLocation.shorten(treeNode.properties.registry),
-                allowTag: treeNode.parser === 'minecraft:resource_or_tag',
+                allowTag,
             }));
         case 'minecraft:resource_location':
-            return wrap(core.resourceLocation(treeNode.properties ?? {
-                pool: [],
-                allowUnknown: true,
-            }));
+            return wrap(core.resourceLocation(treeNode.properties ?? { pool: [], allowUnknown: true }));
         case 'minecraft:rotation':
             return wrap(vector({ dimension: 2, noLocal: true }));
         case 'minecraft:score_holder':
-            return wrap(scoreHolder(treeNode.properties.amount));
+            return wrap(scoreHolder(treeNode.properties.usageType, treeNode.properties.amount));
         case 'minecraft:scoreboard_slot':
             // `BELOWNAME` and `sidebar.team.r--.+++e----__d` are also legal slots.
             // But I do not want to spend time supporting them.
-            return wrap(core.literal(...ScoreboardSlotArgumentValues));
+            return wrap((src, ctx) => {
+                return core.literal(...getScoreboardSlotArgumentValues(ctx))(src, ctx);
+            });
+        case 'minecraft:style':
+            return wrap(jsonParser('::java::server::util::text::TextStyle'));
         case 'minecraft:swizzle':
             return wrap(core.literal(...SwizzleArgumentValues));
         case 'minecraft:team':
@@ -185,7 +187,9 @@ export const argument = (rawTreeNode) => {
         case 'minecraft:vec3':
             return wrap(vector({ dimension: 3 }));
         case 'spyglassmc:tag':
-            return wrap(tag());
+            return wrap(tag(core.SymbolUsageType.is(treeNode.properties?.usageType)
+                ? treeNode.properties?.usageType
+                : undefined));
         default:
             // Unknown parser.
             return undefined;
@@ -207,10 +211,7 @@ function block(isPredicate) {
                 trailingEnd: true,
             },
             end: ']',
-        })), (res) => ({
-            ...res,
-            type: 'mcfunction:block/states',
-        }))),
+        })), (res) => ({ ...res, type: 'mcfunction:block/states' }))),
         core.optional(core.failOnEmpty(nbt.parser.compound)),
     ]), (res) => {
         const ans = {
@@ -220,33 +221,21 @@ function block(isPredicate) {
             id: res.children.find(core.ResourceLocationNode.is),
             states: res.children.find(BlockStatesNode.is),
             nbt: res.children.find(nbt.NbtCompoundNode.is),
+            isPredicate,
         };
         return ans;
     });
 }
 const blockState = block(false);
 export const blockPredicate = block(true);
-export const component = json.parser.entry;
 function double(min = DoubleMin, max = DoubleMax) {
-    return core.float({
-        pattern: FloatPattern,
-        min,
-        max,
-    });
+    return core.float({ pattern: FloatPattern, min, max });
 }
 function float(min = FloatMin, max = FloatMax) {
-    return core.float({
-        pattern: FloatPattern,
-        min,
-        max,
-    });
+    return core.float({ pattern: FloatPattern, min, max });
 }
 function integer(min = IntegerMin, max = IntegerMax) {
-    return core.integer({
-        pattern: IntegerPattern,
-        min,
-        max,
-    });
+    return core.integer({ pattern: IntegerPattern, min, max });
 }
 function long(min, max) {
     return core.long({
@@ -277,24 +266,14 @@ function coordinate(integerOnly = false) {
         return ans;
     };
 }
-function entity(amount, type) {
-    return core.map(core.select([
-        {
-            predicate: (src) => EntitySelectorAtVariable.is(src.peek(2)),
-            parser: selector(),
-        },
-        {
+export function entity(amount, type) {
+    return core.map(core.select([{ predicate: (src) => src.peek() === '@', parser: selector() }, {
             parser: core.any([
+                core.failOnError(uuid),
                 validateLength(core.brigadierString, PlayerNameMaxLength, 'mcfunction.parser.entity-selector.player-name.too-long'),
-                uuid,
             ]),
-        },
-    ]), (res, _src, ctx) => {
-        const ans = {
-            type: 'mcfunction:entity',
-            range: res.range,
-            children: [res],
-        };
+        }]), (res, _src, ctx) => {
+        const ans = { type: 'mcfunction:entity', range: res.range, children: [res] };
         if (core.StringNode.is(res)) {
             ans.playerName = res;
         }
@@ -307,11 +286,9 @@ function entity(amount, type) {
         if (amount === 'single' && ans.selector && !ans.selector.single) {
             ctx.err.report(localize('mcfunction.parser.entity-selector.multiple-disallowed'), ans);
         }
-        if (type === 'players' &&
-            (ans.uuid ||
-                (ans.selector &&
-                    !ans.selector.playersOnly &&
-                    !ans.selector.currentEntity))) {
+        if (type === 'players'
+            && (ans.uuid
+                || (ans.selector && !ans.selector.playersOnly && !ans.selector.currentEntity))) {
             ctx.err.report(localize('mcfunction.parser.entity-selector.entities-disallowed'), ans);
         }
         return ans;
@@ -320,23 +297,64 @@ function entity(amount, type) {
 const greedyString = core.string({
     unquotable: { blockList: new Set(['\n', '\r']) },
 });
-function item(isPredicate) {
+const itemSlot = (src, ctx) => {
+    return core.literal(...getItemSlotArgumentValues(ctx))(src, ctx);
+};
+export const itemSlots = (src, ctx) => {
+    return core.literal(...getItemSlotsArgumentValues(ctx))(src, ctx);
+};
+const itemStack = (src, ctx) => {
+    const oldFormat = shouldUseOldItemStackFormat(ctx);
     return core.map(core.sequence([
-        core.resourceLocation({ category: 'item', allowTag: isPredicate }),
-        core.optional(core.failOnEmpty(nbt.parser.compound)),
+        core.resourceLocation({ category: 'item' }),
+        oldFormat
+            ? core.optional(core.failOnEmpty(nbt.parser.compound))
+            : core.optional(core.failOnEmpty(components)),
     ]), (res) => {
         const ans = {
-            type: 'mcfunction:item',
+            type: 'mcfunction:item_stack',
             range: res.range,
             children: res.children,
             id: res.children.find(core.ResourceLocationNode.is),
+            components: res.children.find(ComponentListNode.is),
             nbt: res.children.find(nbt.NbtCompoundNode.is),
         };
         return ans;
-    });
+    })(src, ctx);
+};
+const itemPredicate = (src, ctx) => {
+    const oldFormat = shouldUseOldItemStackFormat(ctx);
+    return core.map(core.sequence([
+        oldFormat
+            ? core.resourceLocation({ category: 'item', allowTag: true })
+            : core.any([
+                core.resourceLocation({ category: 'item', allowTag: true }),
+                core.literal('*'),
+            ]),
+        oldFormat
+            ? core.optional(core.failOnEmpty(nbt.parser.compound))
+            : core.optional(componentTests),
+    ]), (res) => {
+        const ans = {
+            type: 'mcfunction:item_predicate',
+            range: res.range,
+            children: res.children,
+            id: (res.children.find(core.ResourceLocationNode.is)
+                || res.children.find(core.LiteralNode.is)),
+            tests: res.children.find(ComponentTestsNode.is),
+            nbt: res.children.find(nbt.NbtCompoundNode.is),
+        };
+        return ans;
+    })(src, ctx);
+};
+export function jsonParser(typeRef) {
+    return core.map(json.parser.entry, (res) => ({
+        type: 'json:typed',
+        range: res.range,
+        children: [res],
+        targetType: { kind: 'reference', path: typeRef },
+    }));
 }
-const itemStack = item(false);
-const itemPredicate = item(true);
 const message = (src, ctx) => {
     const ans = {
         type: 'mcfunction:message',
@@ -345,15 +363,47 @@ const message = (src, ctx) => {
     };
     while (src.canReadInLine()) {
         if (EntitySelectorAtVariable.is(src.peek(2))) {
-            ans.children.push(selector()(src, ctx));
+            ans.children.push(selector(true)(src, ctx));
         }
         else {
-            ans.children.push(core.stopBefore(greedyString, ...EntitySelectorAtVariables)(src, ctx));
+            ans.children.push(core.stopBefore(greedyString, ...EntitySelectorAtVariable.filterAvailable(ctx))(src, ctx));
         }
     }
     return ans;
 };
-export const particle = (() => {
+function nbtParser(parser, properties) {
+    return core.map(parser, (res) => {
+        const ans = { type: 'mcfunction:nbt', range: res.range, children: [res], properties };
+        return ans;
+    });
+}
+function nbtPathParser(parser, properties) {
+    return core.map(parser, (res) => {
+        const ans = {
+            type: 'mcfunction:nbt_path',
+            range: res.range,
+            children: [res],
+            properties,
+        };
+        return ans;
+    });
+}
+export const particle = (src, ctx) => {
+    const release = ctx.project['loadedVersion'];
+    if (!release || ReleaseVersion.cmp(release, '1.20.5') >= 0) {
+        return core.map(sequence([
+            core.resourceLocation({ category: 'particle_type' }),
+            core.optional(core.failOnEmpty(nbt.parser.compound)),
+        ]), (res) => {
+            const ans = {
+                type: 'mcfunction:particle',
+                range: res.range,
+                children: res.children,
+                id: res.children.find(core.ResourceLocationNode.is),
+            };
+            return ans;
+        })(src, ctx);
+    }
     const sep = core.map(mcf.sep, () => []);
     const vec = vector({ dimension: 3 });
     const color = core.map(vec, (res) => ({
@@ -376,14 +426,11 @@ export const particle = (() => {
         shriek: integer(),
         vibration: sequence([vec, integer()], sep),
     };
-    return core.map(sequence([
-        core.resourceLocation({ category: 'particle_type' }),
-        {
+    return core.map(sequence([core.resourceLocation({ category: 'particle_type' }), {
             get: (res) => {
                 return map[core.ResourceLocationNode.toString(res.children[0], 'short')];
             },
-        },
-    ], sep), (res) => {
+        }], sep), (res) => {
         const ans = {
             type: 'mcfunction:particle',
             range: res.range,
@@ -391,10 +438,12 @@ export const particle = (() => {
             id: res.children.find(core.ResourceLocationNode.is),
         };
         return ans;
-    });
-})();
+    })(src, ctx);
+};
 function range(type, min, max, cycleable) {
-    const number = type === 'float' ? float(min, max) : integer(min, max);
+    const number = type === 'float'
+        ? float(min, max)
+        : integer(min, max);
     const low = core.failOnEmpty(core.stopBefore(number, '..'));
     const sep = core.failOnEmpty(core.literal({ pool: ['..'], colorTokenType: 'keyword' }));
     const high = core.failOnEmpty(number);
@@ -409,9 +458,7 @@ function range(type, min, max, cycleable) {
             : res.children.filter(core.IntegerNode.is);
         const sepNode = res.children.find(core.LiteralNode.is);
         const ans = {
-            type: type === 'float'
-                ? 'mcfunction:float_range'
-                : 'mcfunction:int_range',
+            type: type === 'float' ? 'mcfunction:float_range' : 'mcfunction:int_range',
             range: res.range,
             children: res.children,
             value: sepNode
@@ -422,19 +469,59 @@ function range(type, min, max, cycleable) {
                         : [undefined, valueNodes[0].value]
                 : [valueNodes[0].value, valueNodes[0].value],
         };
-        if (!cycleable &&
-            ans.value[0] !== undefined &&
-            ans.value[1] !== undefined &&
-            ans.value[0] > ans.value[1]) {
+        if (!cycleable
+            && ans.value[0] !== undefined
+            && ans.value[1] !== undefined
+            && ans.value[0] > ans.value[1]) {
             ctx.err.report(localize('mcfunction.parser.range.min>max', ans.value[0], ans.value[1]), res);
         }
         return ans;
     });
 }
+function resourceOrInline(category) {
+    return core.select([{
+            predicate: (src) => core.LegalResourceLocationCharacters.has(src.peek()),
+            parser: core.resourceLocation({ category }),
+        }, {
+            parser: core.map(nbt.parser.entry, (res) => {
+                const ans = {
+                    type: 'mcfunction:nbt_resource',
+                    range: res.range,
+                    children: [res],
+                    category,
+                };
+                return ans;
+            }),
+        }]);
+}
+function selectorPrefix(ignoreInvalidPrefix) {
+    return (src, ctx) => {
+        const start = src.cursor;
+        let value;
+        if (ignoreInvalidPrefix) {
+            value = src.peek(2);
+            src.skip(2);
+        }
+        else {
+            value = src.readUntil(' ', '\r', '\n', '[');
+        }
+        const allowedVariables = EntitySelectorAtVariable.filterAvailable(ctx);
+        const ans = {
+            type: 'literal',
+            range: core.Range.create(start, src),
+            options: { pool: allowedVariables },
+            value,
+        };
+        if (!allowedVariables.includes(value) && !ignoreInvalidPrefix) {
+            ctx.err.report(localize('mcfunction.parser.entity-selector.invalid', ans.value), ans);
+        }
+        return ans;
+    };
+}
 /**
  * Failure when not beginning with `@[parse]`
  */
-function selector() {
+export function selector(ignoreInvalidPrefix = false) {
     let chunkLimited;
     let currentEntity;
     let dimensionLimited;
@@ -442,12 +529,7 @@ function selector() {
     let predicates;
     let single;
     let typeLimited;
-    return core.map(core.sequence([
-        core.failOnEmpty(core.literal({
-            pool: EntitySelectorAtVariables,
-            colorTokenType: 'keyword',
-        })),
-        {
+    return core.map(core.sequence([core.failOnEmpty(selectorPrefix(ignoreInvalidPrefix)), {
             get: (res) => {
                 const variable = core.LiteralNode.is(res.children?.[0])
                     ? res.children[0].value
@@ -457,16 +539,11 @@ function selector() {
                     ? variable === '@p' || variable === '@a' || variable === '@r'
                     : undefined;
                 predicates = variable === '@e' ? ['Entity::isAlive'] : undefined;
-                single = variable
-                    ? variable === '@p' || variable === '@r' || variable === '@s'
-                    : undefined;
+                single = variable ? ['@p', '@r', '@s', '@n'].includes(variable) : undefined;
                 typeLimited = playersOnly;
                 function invertable(parser) {
                     return core.map(core.sequence([
-                        core.optional(core.failOnEmpty(core.literal({
-                            pool: ['!'],
-                            colorTokenType: 'keyword',
-                        }))),
+                        core.optional(core.failOnEmpty(core.literal({ pool: ['!'], colorTokenType: 'keyword' }))),
                         (src) => {
                             src.skipSpace();
                             return undefined;
@@ -490,9 +567,7 @@ function selector() {
                             ...core.BrigadierStringOptions,
                             value: {
                                 parser: core.literal({
-                                    pool: [
-                                        ...EntitySelectorNode.ArgumentKeys,
-                                    ],
+                                    pool: [...EntitySelectorNode.ArgumentKeys],
                                     colorTokenType: 'property',
                                 }),
                                 type: 'literal',
@@ -502,8 +577,8 @@ function selector() {
                         value: {
                             get: (record, key) => {
                                 const hasKey = (key) => !!record.children.find((p) => p.key?.value === key);
-                                const hasNonInvertedKey = (key) => !!record.children.find((p) => p.key?.value === key &&
-                                    !p.value?.inverted);
+                                const hasNonInvertedKey = (key) => !!record.children.find((p) => p.key?.value === key
+                                    && !p.value?.inverted);
                                 switch (key?.value) {
                                     case 'advancements':
                                         return core.map(core.record({
@@ -513,16 +588,14 @@ function selector() {
                                                     category: 'advancement',
                                                 }),
                                                 sep: '=',
-                                                value: core.select([
-                                                    {
+                                                value: core.select([{
                                                         predicate: (src) => src.peek() === '{',
                                                         parser: core.map(core.record({
                                                             start: '{',
                                                             pair: {
                                                                 key: unquotedString,
                                                                 sep: '=',
-                                                                value: core
-                                                                    .boolean,
+                                                                value: core.boolean,
                                                                 end: ',',
                                                                 trailingEnd: true,
                                                             },
@@ -534,11 +607,7 @@ function selector() {
                                                             };
                                                             return ans;
                                                         }),
-                                                    },
-                                                    {
-                                                        parser: core.boolean,
-                                                    },
-                                                ]),
+                                                    }, { parser: core.boolean }]),
                                                 end: ',',
                                                 trailingEnd: true,
                                             },
@@ -557,8 +626,8 @@ function selector() {
                                         return core.map(range('float', 0), (res, _, ctx) => {
                                             dimensionLimited = true;
                                             // x, y, z, dx, dy, dz take precedence over distance, so we use ??= instead of = to ensure it won't override the result.
-                                            chunkLimited ??= !playersOnly &&
-                                                res.value[1] !== undefined;
+                                            chunkLimited ??= !playersOnly
+                                                && res.value[1] !== undefined;
                                             if (hasKey(key.value)) {
                                                 ctx.err.report(localize('duplicate-key', localeQuote(key.value)), key);
                                             }
@@ -566,8 +635,7 @@ function selector() {
                                         });
                                     case 'gamemode':
                                         return core.map(invertable(core.string({
-                                            unquotable: core
-                                                .BrigadierUnquotableOption,
+                                            unquotable: core.BrigadierUnquotableOption,
                                             value: {
                                                 type: 'literal',
                                                 parser: core.literal(...GamemodeArgumentValues),
@@ -612,9 +680,7 @@ function selector() {
                                     case 'nbt':
                                         return invertable(nbt.parser.compound);
                                     case 'predicate':
-                                        return invertable(core.resourceLocation({
-                                            category: 'predicate',
-                                        }));
+                                        return invertable(core.resourceLocation({ category: 'predicate' }));
                                     case 'scores':
                                         return core.map(core.record({
                                             start: '{',
@@ -645,8 +711,7 @@ function selector() {
                                         });
                                     case 'sort':
                                         return core.map(core.string({
-                                            unquotable: core
-                                                .BrigadierUnquotableOption,
+                                            unquotable: core.BrigadierUnquotableOption,
                                             value: {
                                                 type: 'literal',
                                                 parser: core.literal('arbitrary', 'furthest', 'nearest', 'random'),
@@ -661,23 +726,9 @@ function selector() {
                                             return res;
                                         });
                                     case 'tag':
-                                        return invertable(tag([
-                                            '[',
-                                            '=',
-                                            ',',
-                                            ']',
-                                            '{',
-                                            '}',
-                                        ]));
+                                        return invertable(tag('reference', ['[', '=', ',', ']', '{', '}']));
                                     case 'team':
-                                        return core.map(invertable(team('reference', [
-                                            '[',
-                                            '=',
-                                            ',',
-                                            ']',
-                                            '{',
-                                            '}',
-                                        ])), (res, _, ctx) => {
+                                        return core.map(invertable(team('reference', ['[', '=', ',', ']', '{', '}'])), (res, _, ctx) => {
                                             if (res.inverted
                                                 ? hasNonInvertedKey(key.value)
                                                 : hasKey(key.value)) {
@@ -698,11 +749,9 @@ function selector() {
                                                     ctx.err.report(localize('mcfunction.parser.entity-selector.arguments.not-applicable', localeQuote(key.value)), key);
                                                 }
                                             }
-                                            else if (!res.inverted &&
-                                                !res.value.isTag) {
+                                            else if (!res.inverted && !res.value.isTag) {
                                                 typeLimited = true;
-                                                if (core.ResourceLocationNode
-                                                    .toString(res.value, 'short') === 'player') {
+                                                if (core.ResourceLocationNode.toString(res.value, 'short') === 'player') {
                                                     playersOnly = true;
                                                 }
                                             }
@@ -761,15 +810,12 @@ function selector() {
                     return ans;
                 }));
             },
-        },
-    ]), (res) => {
+        }]), (res) => {
         const ans = {
             type: 'mcfunction:entity_selector',
             range: res.range,
             children: res.children,
-            variable: res.children
-                .find(core.LiteralNode.is)
-                .value.slice(1),
+            variable: res.children.find(core.LiteralNode.is).value.slice(1),
             arguments: res.children.find(EntitySelectorArgumentsNode.is),
             chunkLimited,
             currentEntity,
@@ -799,17 +845,12 @@ function getEntitySelectorHover(node) {
 - \`currentEntity\`: \`${node.currentEntity}\``;
     }
     else {
-        const amountOfTrue = [
-            node.chunkLimited,
-            node.dimensionLimited,
-            node.playersOnly,
-            node.typeLimited,
-        ].filter((v) => v).length;
+        const amountOfTrue = [node.chunkLimited, node.dimensionLimited, node.playersOnly, node.typeLimited].filter((v) => v).length;
         ans = `**Performance**: ${grades.get(amountOfTrue)}
 - \`chunkLimited\`: \`${!!node.chunkLimited}\`
 - \`dimensionLimited\`: \`${!!node.dimensionLimited}\`
 - \`playersOnly\`: \`${!!node.playersOnly}\`
-- \`typeLimited\`: \`${!!node.chunkLimited}\``;
+- \`typeLimited\`: \`${!!node.typeLimited}\``;
     }
     if (node.predicates?.length) {
         ans += `
@@ -820,17 +861,13 @@ ${node.predicates.map((p) => `- \`${p}\``).join('\n')}`;
     }
     return ans;
 }
-export const scoreHolderFakeName = validateLength(symbol('score_holder'), FakeNameMaxLength, 'mcfunction.parser.score_holder.fake-name.too-long');
-function scoreHolder(amount) {
-    return core.map(core.select([
-        {
-            predicate: (src) => EntitySelectorAtVariable.is(src.peek(2)),
-            parser: selector(),
-        },
-        {
-            parser: scoreHolderFakeName,
-        },
-    ]), (res, _src, ctx) => {
+export function scoreHolderFakeName(usageType) {
+    return validateLength(symbol({ category: 'score_holder', usageType }), FakeNameMaxLength, 'mcfunction.parser.score_holder.fake-name.too-long');
+}
+export function scoreHolder(usageType, amount) {
+    return core.map(core.select([{ predicate: (src) => src.peek() === '@', parser: selector() }, {
+            parser: scoreHolderFakeName(usageType),
+        }]), (res, _src, ctx) => {
         const ans = {
             type: 'mcfunction:score_holder',
             range: res.range,
@@ -851,43 +888,28 @@ function scoreHolder(amount) {
 function symbol(options, terminators = []) {
     return core.stopBefore(core.symbol(options), core.Whitespaces, terminators);
 }
-function objective(usageType, terminators = []) {
+export function objective(usageType, terminators = []) {
     return validateLength(unquotableSymbol({ category: 'objective', usageType }, terminators), ObjectiveMaxLength, 'mcfunction.parser.objective.too-long');
 }
-const objectiveCriteria = core
-    .map(core.any([
+const objectiveCriteria = core.map(core.any([
     core.sequence([
-        core.stopBefore(core.resourceLocation({
-            category: 'stat_type',
-            namespacePathSep: '.',
-        }), ':'),
+        core.stopBefore(core.resourceLocation({ category: 'stat_type', namespacePathSep: '.' }), ':'),
         core.failOnEmpty(core.literal(':')),
         {
             get: (res) => {
                 if (core.ResourceLocationNode.is(res.children[0])) {
-                    const category = ObjectiveCriteriaNode.ComplexCategories
-                        .get(core.ResourceLocationNode.toString(res.children[0], 'short'));
+                    const category = ObjectiveCriteriaNode.ComplexCategories.get(core.ResourceLocationNode.toString(res.children[0], 'short'));
                     if (category) {
-                        return core.resourceLocation({
-                            category,
-                            namespacePathSep: '.',
-                        });
+                        return core.resourceLocation({ category, namespacePathSep: '.' });
                     }
                 }
-                return core.resourceLocation({
-                    pool: [],
-                    allowUnknown: true,
-                    namespacePathSep: '.',
-                });
+                return core.resourceLocation({ pool: [], allowUnknown: true, namespacePathSep: '.' });
             },
         },
     ]),
     core.literal(...ObjectiveCriteriaNode.SimpleValues),
 ]), (res) => {
-    const ans = {
-        type: 'mcfunction:objective_criteria',
-        range: res.range,
-    };
+    const ans = { type: 'mcfunction:objective_criteria', range: res.range };
     if (core.LiteralNode.is(res)) {
         ans.simpleValue = res.value;
     }
@@ -896,8 +918,8 @@ const objectiveCriteria = core
     }
     return ans;
 });
-export function tag(terminators = []) {
-    return unquotableSymbol('tag', terminators);
+export function tag(usageType, terminators = []) {
+    return unquotableSymbol({ category: 'tag', usageType }, terminators);
 }
 export function team(usageType, terminators = []) {
     return unquotableSymbol({ category: 'team', usageType }, terminators);
@@ -924,12 +946,8 @@ const unquotedString = core.string({
     unquotable: core.BrigadierUnquotableOption,
 });
 const UuidPattern = /^[0-9a-f]+-[0-9a-f]+-[0-9a-f]+-[0-9a-f]+-[0-9a-f]+$/i;
-const uuid = (src, ctx) => {
-    const ans = {
-        type: 'mcfunction:uuid',
-        range: core.Range.create(src),
-        bits: [0n, 0n],
-    };
+export const uuid = (src, ctx) => {
+    const ans = { type: 'mcfunction:uuid', range: core.Range.create(src), bits: [0n, 0n] };
     const raw = src.readUntil(' ', '\r', '\n', '\r');
     /**
      * According to the implementation of Minecraft's UUID parser and Java's `UUID#fromString` method,
@@ -999,8 +1017,7 @@ function vector(options) {
                 ? coordinate(options.integersOnly)(src, ctx)
                 : coordinate(options.integersOnly)(src, ctx);
             ans.children.push(coord);
-            if ((ans.system === 1 /* CoordinateSystem.Local */) !==
-                (coord.notation === '^')) {
+            if ((ans.system === 1 /* CoordinateSystem.Local */) !== (coord.notation === '^')) {
                 ctx.err.report(localize('mcfunction.parser.vector.mixed'), coord);
             }
         }
@@ -1011,4 +1028,155 @@ function vector(options) {
         return ans;
     };
 }
+const components = core.map(core.record({
+    start: '[',
+    pair: {
+        key: core.resourceLocation({ category: 'data_component_type' }),
+        sep: '=',
+        value: nbt.parser.entry,
+        end: ',',
+        trailingEnd: true,
+    },
+    end: ']',
+}), (res) => {
+    const ans = {
+        type: 'mcfunction:component_list',
+        range: res.range,
+        children: res.children,
+    };
+    return ans;
+});
+const componentTest = (src, ctx) => {
+    const start = src.cursor;
+    src.skipWhitespace();
+    const negated = src.trySkip('!');
+    src.skipWhitespace();
+    const key = core.resourceLocation({ category: 'data_component_type' })(src, ctx);
+    src.skipWhitespace();
+    if (core.ResourceLocationNode.toString(key, 'full') === 'minecraft:count') {
+        key.options.category = undefined;
+        key.options.pool = ['minecraft:count'];
+    }
+    if (src.trySkip('=')) {
+        const ans = {
+            type: 'mcfunction:component_test_exact',
+            range: core.Range.create(start, src),
+            children: [key],
+            key,
+            negated,
+        };
+        const value = nbt.parser.entry(src, ctx);
+        if (value == core.Failure) {
+            ctx.err.report(localize('expected', localize('nbt.node')), src);
+            src.skipUntilOrEnd(',', '|', ']');
+        }
+        else {
+            ans.children.push(value);
+            ans.value = value;
+        }
+        src.skipWhitespace();
+        ans.range.end = src.cursor;
+        return ans;
+    }
+    if (src.trySkip('~')) {
+        if (key.options.category !== undefined) {
+            key.options.category = 'item_sub_predicate_type';
+        }
+        const ans = {
+            type: 'mcfunction:component_test_sub_predicate',
+            range: core.Range.create(start, src),
+            children: [key],
+            key,
+            negated,
+        };
+        const predicate = nbt.parser.entry(src, ctx);
+        if (predicate == core.Failure) {
+            ctx.err.report(localize('expected', localize('nbt.node')), src);
+            src.skipUntilOrEnd(',', '|', ']');
+        }
+        else {
+            ans.children.push(predicate);
+            ans.value = predicate;
+        }
+        src.skipWhitespace();
+        ans.range.end = src.cursor;
+        return ans;
+    }
+    const ans = {
+        type: 'mcfunction:component_test_exists',
+        range: core.Range.create(start, src),
+        children: [key],
+        key,
+        negated,
+    };
+    return ans;
+};
+const componentTestsAllOf = (src, ctx) => {
+    const ans = {
+        type: 'mcfunction:component_tests_all_of',
+        range: core.Range.create(src),
+        children: [],
+    };
+    while (src.canRead()) {
+        src.skipWhitespace();
+        const testNode = componentTest(src, ctx);
+        ans.children.push(testNode);
+        src.skipWhitespace();
+        if (src.peek() === ',') {
+            src.skip();
+        }
+        else if (src.peek() === '|' || src.peek() === ']') {
+            break;
+        }
+        else {
+            ctx.err.report(localize('expected', localeQuote(']')), src);
+            src.skipUntilOrEnd(',', '|', ']');
+        }
+    }
+    ans.range.end = src.cursor;
+    return ans;
+};
+const componentTestsAnyOf = (src, ctx) => {
+    const ans = {
+        type: 'mcfunction:component_tests_any_of',
+        range: core.Range.create(src),
+        children: [],
+    };
+    while (src.canRead()) {
+        src.skipWhitespace();
+        const allOfNode = componentTestsAllOf(src, ctx);
+        ans.children.push(allOfNode);
+        src.skipWhitespace();
+        if (src.peek() === '|') {
+            src.skip();
+        }
+        else if (src.peek() === ']') {
+            break;
+        }
+        else {
+            ctx.err.report(localize('expected', localeQuote(']')), src);
+            src.skipUntilOrEnd('|', ']');
+        }
+    }
+    ans.range.end = src.cursor;
+    return ans;
+};
+const componentTests = (src, ctx) => {
+    const ans = {
+        type: 'mcfunction:component_tests',
+        range: core.Range.create(src),
+    };
+    if (!src.trySkip('[')) {
+        return core.Failure;
+    }
+    src.skipWhitespace();
+    const tests = core.optional(core.failOnEmpty(componentTestsAnyOf))(src, ctx);
+    if (tests) {
+        ans.children = [tests];
+    }
+    src.skipWhitespace();
+    core.literal(']')(src, ctx);
+    ans.range.end = src.cursor;
+    return ans;
+};
 //# sourceMappingURL=argument.js.map