@spyglassmc/java-edition 0.3.8 → 0.3.9

package/lib/mcfunction/checker/index.js

@@ -3,236 +3,300 @@ import * as json from '@spyglassmc/json';
 import { localize } from '@spyglassmc/locales';
 import * as mcf from '@spyglassmc/mcfunction';
 import * as nbt from '@spyglassmc/nbt';
+import { dissectUri, reportDissectError } from '../../binder/index.js';
 import { getTagValues } from '../../common/index.js';
-import { BlockNode, EntityNode, ItemNode, ParticleNode } from '../node/index.js';
+import { ReleaseVersion } from '../../dependency/common.js';
+import { BlockNode, ComponentTestExactNode, ComponentTestExistsNode, ComponentTestSubpredicateNode, EntityNode, ItemPredicateNode, ItemStackNode, NbtNode, NbtPathNode, NbtResourceNode, ParticleNode, } from '../node/index.js';
+const entry = (node, ctx) => {
+    const parts = dissectUri(ctx.doc.uri, ctx);
+    if (parts?.ok === false) {
+        reportDissectError(parts.path, parts.expected, ctx);
+    }
+    core.checker.dispatchSync(node, ctx);
+};
 export const command = (node, ctx) => {
     if (node.slash && node.parent && mcf.McfunctionNode.is(node.parent)) {
         ctx.err.report(localize('unexpected-leading-slash'), node.slash);
     }
     rootCommand(node.children, 0, ctx);
 };
-const getName = (nodes, index) => {
-    return nodes[index]?.path[nodes[index].path.length - 1];
-};
-const getNode = (nodes, index) => {
-    return nodes[index]?.children[0];
-};
+function getEarlierNode(nodes, before, name) {
+    if (name === undefined) {
+        return undefined;
+    }
+    for (let i = before - 1; i > 0; i -= 1) {
+        if (nodes[i].path[nodes[i].path.length - 1] === name) {
+            return nodes[i].children[0];
+        }
+    }
+    return undefined;
+}
 const rootCommand = (nodes, index, ctx) => {
-    for (const { children: [node], } of nodes) {
+    for (let i = 0; i < nodes.length; i += 1) {
+        const node = nodes[i].children[0];
         if (BlockNode.is(node)) {
             block(node, ctx);
         }
         else if (EntityNode.is(node)) {
             entity(node, ctx);
         }
-        else if (ItemNode.is(node)) {
-            item(node, ctx);
+        else if (ItemPredicateNode.is(node)) {
+            itemPredicate(node, ctx);
+        }
+        else if (ItemStackNode.is(node)) {
+            itemStack(node, ctx);
         }
         else if (ParticleNode.is(node)) {
             particle(node, ctx);
         }
-        else if (json.JsonNode.is(node)) {
-            // TODO v4.0: check text component
-        }
-    }
-    if (getName(nodes, index) === 'data') {
-        if (getName(nodes, index + 1) === 'get') {
-            nbtPath(nodes, index + 2, ctx);
-        }
-        else if (getName(nodes, index + 1) === 'merge') {
-            dataMergeTarget(nodes, index + 2, ctx);
+        else if (NbtResourceNode.is(node)) {
+            nbtResource(node, ctx);
         }
-        else if (getName(nodes, index + 1) === 'modify') {
-            nbtPath(nodes, index + 2, ctx);
-            const targetPath = getNode(nodes, index + 4);
-            // if (nbt.NbtPathNode.is(targetPath)) {
-            // 	const operationNode = getNode(nodes, index + 5)
-            // 	const operation = getName(nodes, index + 5) as 'append' | 'insert' | 'merge' | 'prepend' | 'set' | undefined
-            // 	const sourceTypeIndex = operation === 'insert' ? index + 7 : index + 6
-            // 	let targetMcdocType: mcdoc.McdocType | undefined = targetPath.targetType ? mcdoc.simplifyType(targetPath.targetType) : undefined
-            // 	const isType = (type: mcdoc.McdocType['kind']) => !targetMcdocType || targetMcdocType.kind === type || (targetMcdocType.type === 'union' && targetMcdocType.members.some(m => m.type === type))
-            // 	if (operation === 'merge') {
-            // 		if (!(isType('compound') || isType('index'))) {
-            // 			ctx.err.report(
-            // 				localize('mcfunction.checker.command.data-modify-unapplicable-operation', localeQuote(operation), localize('nbt.node.compound'), localeQuote(mcdoc.McdocType.toString(targetMcdocType))),
-            // 				core.Range.span(targetPath, operationNode!),
-            // 				core.ErrorSeverity.Warning
-            // 			)
-            // 			targetMcdocType = undefined
-            // 		}
-            // 	} else if (operation === 'append' || operation === 'insert' || operation === 'prepend') {
-            // 		if (isType('list') || isType('byte_array') || isType('int_array') || isType('long_array')) {
-            // 			if (targetMcdocType?.type === 'list') {
-            // 				targetMcdocType = targetMcdocType.item
-            // 			} else if (targetMcdocType?.type === 'byte_array') {
-            // 				targetMcdocType = { type: 'byte', valueRange: targetMcdocType.valueRange }
-            // 			} else if (targetMcdocType?.type === 'int_array') {
-            // 				targetMcdocType = { type: 'int', valueRange: targetMcdocType.valueRange }
-            // 			} else if (targetMcdocType?.type === 'long_array') {
-            // 				targetMcdocType = { type: 'long', valueRange: targetMcdocType.valueRange }
-            // 			}
-            // 		} else {
-            // 			ctx.err.report(
-            // 				localize('mcfunction.checker.command.data-modify-unapplicable-operation', localeQuote(operation), localize('nbt.node.list'), localeQuote(mcdoc.McdocType.toString(targetMcdocType))),
-            // 				core.Range.span(targetPath, operationNode!),
-            // 				core.ErrorSeverity.Warning
-            // 			)
-            // 			targetMcdocType = undefined
-            // 		}
-            // 	}
-            // 	if (targetMcdocType) {
-            // 		if (getName(nodes, sourceTypeIndex) === 'from') {
-            // 			// `from <$nbtPath$>`
-            // 			nbtPath(nodes, sourceTypeIndex + 1, ctx)
-            // 			const sourcePath = getNode(nodes, sourceTypeIndex + 3)
-            // 			if (nbt.NbtPathNode.is(sourcePath)) {
-            // 				const { errorMessage } = mcdoc.checkAssignability({ source: sourcePath.targetType, target: targetMcdocType })
-            // 				if (errorMessage) {
-            // 					ctx.err.report(errorMessage, core.Range.span(targetPath, sourcePath), core.ErrorSeverity.Warning)
-            // 				}
-            // 			}
-            // 		} else if (getName(nodes, sourceTypeIndex) === 'value') {
-            // 			// `value <value: nbt_tag>`
-            // 			const valueNode = getNode(nodes, sourceTypeIndex + 1)
-            // 			if (nbt.NbtNode.is(valueNode)) {
-            // 				nbt.checker.fieldValue(targetMcdocType, { allowUnknownKey: true })(valueNode, ctx)
-            // 			}
-            // 		}
-            // 	}
-            // }
+        else if (json.TypedJsonNode.is(node)) {
+            json.checker.typed(node, ctx);
         }
-        else if (getName(nodes, index + 1) === 'remove') {
-            nbtPath(nodes, index + 2, ctx);
+        else if (NbtNode.is(node) && node.properties) {
+            const dispatchedBy = getEarlierNode(nodes, i, node.properties.dispatchedBy);
+            const indexedBy = getEarlierNode(nodes, i, node.properties.indexedBy);
+            nbtChecker(dispatchedBy, indexedBy)(node, ctx);
         }
-    }
-    else if (getName(nodes, index) === 'execute') {
-        for (let i = index + 1; i < nodes.length; i++) {
-            if ((getName(nodes, i) === 'if' || getName(nodes, i) === 'unless') &&
-                getName(nodes, i + 1) === 'data') {
-                // `if|unless data <$nbtPath$>`
-                nbtPath(nodes, i + 2, ctx);
-                i += 2;
-            }
-            else if (getName(nodes, i) === 'run') {
-                rootCommand(nodes, i + 1, ctx);
-                break;
-            }
+        else if (NbtPathNode.is(node) && node.properties) {
+            const dispatchedBy = getEarlierNode(nodes, i, node.properties.dispatchedBy);
+            nbtPathChecker(dispatchedBy)(node, ctx);
         }
     }
-    else if (getName(nodes, index) === 'summon') {
-        summonNbt(nodes, index + 1, ctx);
-    }
 };
 // #region Checkers for argument nodes
 const block = (node, ctx) => {
     if (!node.nbt) {
         return;
     }
-    nbt.checker.index('block', core.ResourceLocationNode.toString(node.id, 'full'))(node.nbt, ctx);
+    const type = core.ResourceLocationNode.toString(node.id, 'full');
+    nbt.checker.index('minecraft:block', type, { isPredicate: node.isPredicate })(node.nbt, ctx);
 };
 const entity = (node, ctx) => {
-    const nbtPair = node.selector?.arguments?.children.find((pair) => pair.key?.value === 'nbt');
-    if (!nbtPair) {
-        return;
+    for (const pair of node.selector?.arguments?.children ?? []) {
+        if (pair.key?.value !== 'nbt' || !pair.value) {
+            continue;
+        }
+        const types = getTypesFromEntity(node, ctx);
+        if (!nbt.NbtCompoundNode.is(pair.value.value)) {
+            continue;
+        }
+        nbt.checker.index('minecraft:entity', types, { isPredicate: true })(pair.value.value, ctx);
     }
-    const types = getTypesFromEntity(node, ctx);
-    const nbtValue = nbtPair.value;
-    nbt.checker.index('entity_type', types)(nbtValue, ctx);
 };
-const item = (node, ctx) => {
-    if (!node.nbt) {
+const itemPredicate = (node, ctx) => {
+    if (node.nbt) {
+        const type = core.ResourceLocationNode.toString(node.id, 'full');
+        nbt.checker.index('minecraft:item', type, { isPredicate: true })(node.nbt, ctx);
+    }
+    if (!node.tests?.children) {
         return;
     }
-    nbt.checker.index('item', core.ResourceLocationNode.toString(node.id, 'full'))(node.nbt, ctx);
-};
-const particle = (node, ctx) => {
-    core.checker.dispatchSync(node, ctx);
-};
-// #endregion
-// #region Checkers for command argument structure.
-/**
- * - `block <targetPos: block_pos> <nbt: nbt_compound_tag>`
- * - `entity <target: entity> <nbt: nbt_compound_tag>`
- * - `storage <target: resource_location> <nbt: nbt_compound_tag>`
- */
-const dataMergeTarget = (nodes, index, ctx) => {
-    const registry = getName(nodes, index);
-    switch (registry) {
-        case 'block': {
-            const nbtNode = getNode(nodes, index + 2);
-            if (nbt.NbtCompoundNode.is(nbtNode)) {
-                nbt.checker.index('block', undefined)(nbtNode, ctx);
+    const anyOfTest = node.tests.children[0];
+    for (const allOfTest of anyOfTest.children) {
+        for (const test of allOfTest.children) {
+            const key = core.ResourceLocationNode.toString(test.key, 'full');
+            // count is a special case that's only valid in item predicate arguments, not json
+            // note: basically all errors checked here are otherwise accepted by vanilla, but it's good to report them
+            if (key === 'minecraft:count' && !ComponentTestExistsNode.is(test) && test.value) {
+                const validInt = { kind: 'int', valueRange: { kind: 0b00, min: 0 } };
+                const type = {
+                    kind: 'union',
+                    members: [
+                        validInt,
+                        {
+                            kind: 'struct',
+                            fields: [
+                                { kind: 'pair', key: 'min', optional: true, type: validInt },
+                                { kind: 'pair', key: 'max', optional: true, type: validInt },
+                            ],
+                        },
+                    ],
+                };
+                nbt.checker.typeDefinition(type)(test.value, ctx);
             }
-            break;
-        }
-        case 'entity': {
-            const entityNode = getNode(nodes, index + 1);
-            const nbtNode = getNode(nodes, index + 2);
-            if (EntityNode.is(entityNode) && nbt.NbtCompoundNode.is(nbtNode)) {
-                const types = getTypesFromEntity(entityNode, ctx);
-                nbt.checker.index('entity_type', types)(nbtNode, ctx);
+            else if (ComponentTestExactNode.is(test) && test.value) {
+                nbt.checker.index('minecraft:data_component', key)(test.value, ctx);
             }
-            break;
-        }
-        case 'storage': {
-            const idNode = getNode(nodes, index + 1);
-            const nbtNode = getNode(nodes, index + 2);
-            if (core.ResourceLocationNode.is(idNode) &&
-                nbt.NbtCompoundNode.is(nbtNode)) {
-                nbt.checker.index('storage', core.ResourceLocationNode.toString(idNode, 'full'))(nbtNode, ctx);
+            else if (ComponentTestSubpredicateNode.is(test) && test.value) {
+                nbt.checker.index('minecraft:item_sub_predicate', key)(test.value, ctx);
             }
-            break;
         }
     }
 };
-/**
- * - `block <block_pos> <nbt_path>`
- * - `entity <entity> <nbt_path>`
- * - `storage <resource_location> <nbt_path>`
- */
-const nbtPath = (nodes, index, ctx) => {
-    const registry = getName(nodes, index);
-    switch (registry) {
-        case 'block': {
-            const nbtNode = getNode(nodes, index + 2);
-            if (nbt.NbtPathNode.is(nbtNode)) {
-                nbt.checker.path('block', undefined)(nbtNode, ctx);
+const itemStack = (node, ctx) => {
+    const itemId = core.ResourceLocationNode.toString(node.id, 'full');
+    if (node.nbt) {
+        nbt.checker.index('minecraft:item', itemId)(node.nbt, ctx);
+    }
+    if (!node.components) {
+        return;
+    }
+    const groupedComponents = new Map();
+    for (const pair of node.components.children) {
+        if (!pair.key) {
+            continue;
+        }
+        const componentId = core.ResourceLocationNode.toString(pair.key, 'full');
+        if (!groupedComponents.has(componentId)) {
+            groupedComponents.set(componentId, []);
+        }
+        groupedComponents.get(componentId).push(pair.key);
+        if (pair.value) {
+            nbt.checker.index('minecraft:data_component', componentId)(pair.value, ctx);
+        }
+    }
+    for (const [_, group] of groupedComponents) {
+        if (group.length > 1) {
+            for (const node of group) {
+                ctx.err.report(localize('mcfunction.parser.duplicate-components'), node.range, 2 /* core.ErrorSeverity.Warning */);
             }
-            break;
         }
-        case 'entity': {
-            const entityNode = getNode(nodes, index + 1);
-            const nbtNode = getNode(nodes, index + 2);
-            if (EntityNode.is(entityNode) && nbt.NbtPathNode.is(nbtNode)) {
-                const types = getTypesFromEntity(entityNode, ctx);
-                nbt.checker.path('entity_type', types)(nbtNode, ctx);
+    }
+};
+const nbtResource = (node, ctx) => {
+    const type = {
+        kind: 'dispatcher',
+        registry: 'minecraft:resource',
+        parallelIndices: [{ kind: 'static', value: core.ResourceLocation.lengthen(node.category) }],
+    };
+    nbt.checker.typeDefinition(type)(node.children[0], ctx);
+};
+function nbtChecker(dispatchedBy, indexedBy) {
+    return (node, ctx) => {
+        if (!node.properties) {
+            return;
+        }
+        const tag = node.children[0];
+        if (indexedBy) {
+            if (NbtPathNode.is(indexedBy)) {
+                const indexedByTypedef = indexedBy.children[0].endTypeDef;
+                const typeDef = indexedByTypedef && node.properties.isListIndex
+                    ? getListLikeChild(indexedByTypedef)
+                    : indexedByTypedef;
+                if (typeDef) {
+                    nbt.checker.typeDefinition(typeDef, node.properties)(tag, ctx);
+                }
             }
-            break;
+            return;
         }
-        case 'storage': {
-            const idNode = getNode(nodes, index + 1);
-            const nbtNode = getNode(nodes, index + 2);
-            if (core.ResourceLocationNode.is(idNode) && nbt.NbtPathNode.is(nbtNode)) {
-                nbt.checker.path('storage', core.ResourceLocationNode.toString(idNode, 'full'))(nbtNode, ctx);
+        switch (node.properties.dispatcher) {
+            case 'minecraft:entity':
+                if (nbt.NbtCompoundNode.is(tag)) {
+                    const types = (EntityNode.is(dispatchedBy) || core.ResourceLocationNode.is(dispatchedBy))
+                        ? getTypesFromEntity(dispatchedBy, ctx)
+                        : undefined;
+                    nbt.checker.index('minecraft:entity', types, {
+                        isPredicate: node.properties.isPredicate,
+                        isMerge: node.properties.isMerge,
+                    })(tag, ctx);
+                }
+                break;
+            case 'minecraft:block':
+                if (nbt.NbtCompoundNode.is(tag)) {
+                    nbt.checker.index('minecraft:block', undefined, {
+                        isPredicate: node.properties.isPredicate,
+                        isMerge: node.properties.isMerge,
+                    })(tag, ctx);
+                }
+                break;
+            case 'minecraft:storage':
+                if (nbt.NbtCompoundNode.is(tag)) {
+                    const storage = core.ResourceLocationNode.is(dispatchedBy)
+                        ? core.ResourceLocationNode.toString(dispatchedBy)
+                        : undefined;
+                    nbt.checker.index('minecraft:storage', storage, {
+                        isPredicate: node.properties.isPredicate,
+                        isMerge: node.properties.isMerge,
+                    })(tag, ctx);
+                }
+                break;
+        }
+    };
+}
+function getListLikeChild(typeDef) {
+    switch (typeDef.kind) {
+        case 'list':
+            return typeDef.item;
+        case 'byte_array':
+            return { kind: 'byte' };
+        case 'int_array':
+            return { kind: 'int' };
+        case 'long_array':
+            return { kind: 'long' };
+        case 'union':
+            const members = typeDef.members
+                .map(m => getListLikeChild(m))
+                .filter((m) => m !== undefined);
+            if (members.length === 0) {
+                return undefined;
             }
-            break;
+            if (members.length === 1) {
+                return members[0];
+            }
+            return { kind: 'union', members };
+        default:
+            return undefined;
+    }
+}
+function nbtPathChecker(dispatchedBy) {
+    return (node, ctx) => {
+        if (!node.properties) {
+            return;
         }
+        const path = node.children[0];
+        switch (node.properties.dispatcher) {
+            case 'minecraft:entity':
+                const types = (EntityNode.is(dispatchedBy) || core.ResourceLocationNode.is(dispatchedBy))
+                    ? getTypesFromEntity(dispatchedBy, ctx)
+                    : undefined;
+                nbt.checker.path('minecraft:entity', types)(path, ctx);
+                break;
+            case 'minecraft:block':
+                nbt.checker.path('minecraft:block', undefined)(path, ctx);
+                break;
+            case 'minecraft:storage':
+                const storage = core.ResourceLocationNode.is(dispatchedBy)
+                    ? core.ResourceLocationNode.toString(dispatchedBy)
+                    : undefined;
+                nbt.checker.path('minecraft:storage', storage)(path, ctx);
+                break;
+        }
+    };
+}
+const particle = (node, ctx) => {
+    const id = core.ResourceLocationNode.toString(node.id, 'short');
+    const release = ctx.project['loadedVersion'];
+    if (release && ReleaseVersion.cmp(release, '1.20.5') < 0) {
+        return;
     }
-};
-/**
- * - `<entity: entity_summon> [<pos: vec3>] [<nbt: nbt_compound_tag>]`
- */
-const summonNbt = (nodes, index, ctx) => {
-    const typeNode = getNode(nodes, index);
-    const nbtNode = getNode(nodes, index + 2);
-    if (core.ResourceLocationNode.is(typeNode) &&
-        nbt.NbtCompoundNode.is(nbtNode)) {
-        nbt.checker.index('entity_type', core.ResourceLocationNode.toString(typeNode, 'full'))(nbtNode, ctx);
+    const options = node.children?.find(nbt.NbtCompoundNode.is);
+    if (ParticleNode.requiresOptions(id)) {
+        if (options) {
+            nbt.checker.index('minecraft:particle', core.ResourceLocation.lengthen(id))(options, ctx);
+        }
+        else {
+            ctx.err.report(localize('expected', localize('nbt.node.compound')), core.Range.create(node.id.range.end, node.id.range.end + 1));
+        }
+    }
+    else if (options) {
+        ctx.err.report(localize('expected', localize('nothing')), options);
     }
 };
 // #endregion
-export const getTypesFromEntity = (entity, ctx) => {
-    if (entity.playerName !== undefined || entity.selector?.playersOnly) {
+function getTypesFromEntity(entity, ctx) {
+    if (core.ResourceLocationNode.is(entity)) {
+        const value = core.ResourceLocationNode.toString(entity, 'full', true);
+        if (value.startsWith(core.ResourceLocation.TagPrefix)) {
+            return getTagValues('tag/entity_type', value.slice(1), ctx);
+        }
+        else {
+            return [value];
+        }
+    }
+    else if (entity.playerName !== undefined || entity.selector?.playersOnly) {
         return ['minecraft:player'];
     }
     else if (entity.selector) {
@@ -240,7 +304,7 @@ export const getTypesFromEntity = (entity, ctx) => {
         if (!argumentsNode) {
             return undefined;
         }
-        let types = [];
+        let types = undefined;
         for (const pairNode of argumentsNode.children) {
             if (pairNode.key?.value !== 'type') {
                 continue;
@@ -252,7 +316,12 @@ export const getTypesFromEntity = (entity, ctx) => {
             const value = core.ResourceLocationNode.toString(valueNode.value, 'full', true);
             if (value.startsWith(core.ResourceLocation.TagPrefix)) {
                 const tagValues = getTagValues('tag/entity_type', value.slice(1), ctx);
-                types = types.filter((t) => tagValues.includes(t));
+                if (types === undefined) {
+                    types = tagValues.map(core.ResourceLocation.lengthen);
+                }
+                else {
+                    types = types.filter((t) => tagValues.includes(t));
+                }
             }
             else {
                 types = [value];
@@ -261,12 +330,14 @@ export const getTypesFromEntity = (entity, ctx) => {
         return types;
     }
     return undefined;
-};
+}
 export function register(meta) {
+    meta.registerChecker('mcfunction:entry', entry);
     meta.registerChecker('mcfunction:command', command);
     meta.registerChecker('mcfunction:block', block);
     meta.registerChecker('mcfunction:entity', entity);
-    meta.registerChecker('mcfunction:item', item);
+    meta.registerChecker('mcfunction:item_stack', itemStack);
+    meta.registerChecker('mcfunction:item_predicate', itemPredicate);
     meta.registerChecker('mcfunction:particle', particle);
 }
 //# sourceMappingURL=index.js.map

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

@@ -1,9 +1,11 @@
+import * as core from '@spyglassmc/core';
 export declare const ColorArgumentValues: string[];
 export declare const EntityAnchorArgumentValues: string[];
 export declare const GamemodeArgumentValues: string[];
-export declare const ItemSlotArgumentValues: string[];
+export declare function getItemSlotArgumentValues(ctx: core.ContextBase): string[];
+export declare function getItemSlotsArgumentValues(ctx: core.ContextBase): string[];
 export declare const OperationArgumentValues: string[];
-export declare const ScoreboardSlotArgumentValues: string[];
+export declare function getScoreboardSlotArgumentValues(ctx: core.ContextBase): string[];
 export declare const SwizzleArgumentValues: string[];
 export declare const HeightmapValues: string[];
 export declare const RotationValues: string[];

package/lib/mcfunction/common/index.js

@@ -1,47 +1,60 @@
 import * as core from '@spyglassmc/core';
+import { ReleaseVersion } from '../../dependency/index.js';
 export const ColorArgumentValues = [...core.Color.ColorNames, 'reset'];
 export const EntityAnchorArgumentValues = ['feet', 'eyes'];
-export const GamemodeArgumentValues = [
-    'adventure',
-    'survival',
-    'creative',
-    'spectator',
-];
-export const ItemSlotArgumentValues = [
-    ...[...Array(54).keys()].map((n) => `container.${n}`),
-    ...[...Array(27).keys()].map((n) => `enderchest.${n}`),
-    ...[...Array(15).keys()].map((n) => `horse.${n}`),
-    ...[...Array(9).keys()].map((n) => `hotbar.${n}`),
-    ...[...Array(27).keys()].map((n) => `inventory.${n}`),
-    ...[...Array(8).keys()].map((n) => `villager.${n}`),
-    'armor.chest',
-    'armor.feet',
-    'armor.head',
-    'armor.legs',
-    'horse.armor',
-    'horse.chest',
-    'horse.saddle',
-    'weapon',
-    'weapon.mainhand',
-    'weapon.offhand',
-];
-export const OperationArgumentValues = [
-    '=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '%=',
-    '<',
-    '>',
-    '><',
-];
-export const ScoreboardSlotArgumentValues = [
-    'belowName',
-    'list',
-    'sidebar',
-    ...core.Color.ColorNames.map((n) => `sidebar.team.${n}`),
-];
+export const GamemodeArgumentValues = ['adventure', 'survival', 'creative', 'spectator'];
+export function getItemSlotArgumentValues(ctx) {
+    const release = ctx.project['loadedVersion'];
+    const output = [
+        ...[...Array(54).keys()].map((n) => `container.${n}`),
+        ...[...Array(27).keys()].map((n) => `enderchest.${n}`),
+        ...[...Array(15).keys()].map((n) => `horse.${n}`),
+        ...[...Array(9).keys()].map((n) => `hotbar.${n}`),
+        ...[...Array(27).keys()].map((n) => `inventory.${n}`),
+        ...[...Array(8).keys()].map((n) => `villager.${n}`),
+        'armor.chest',
+        'armor.feet',
+        'armor.head',
+        'armor.legs',
+        'horse.chest',
+        'horse.saddle',
+        'weapon',
+        'weapon.mainhand',
+        'weapon.offhand',
+    ];
+    if (ReleaseVersion.cmp(release, '1.20.5') >= 0) {
+        output.push(...[...Array(4).keys()].map((n) => `player.crafting.${n}`), 'armor.body', 'contents', 'player.cursor');
+    }
+    else {
+        output.push('horse.armor');
+    }
+    return output;
+}
+// Only exists since 1.20.5
+export function getItemSlotsArgumentValues(ctx) {
+    return [
+        ...getItemSlotArgumentValues(ctx),
+        'armor.*',
+        'container.*',
+        'enderchest.*',
+        'horse.*',
+        'hotbar.*',
+        'inventory.*',
+        'player.crafting.*',
+        'villager.*',
+        'weapon.*',
+    ];
+}
+export const OperationArgumentValues = ['=', '+=', '-=', '*=', '/=', '%=', '<', '>', '><'];
+export function getScoreboardSlotArgumentValues(ctx) {
+    const release = ctx.project['loadedVersion'];
+    return [
+        ReleaseVersion.cmp(release, '1.20.2') < 0 ? 'belowName' : 'below_name',
+        'list',
+        'sidebar',
+        ...core.Color.ColorNames.map((n) => `sidebar.team.${n}`),
+    ];
+}
 export const SwizzleArgumentValues = [
     'x',
     'xy',
@@ -67,15 +80,6 @@ export const HeightmapValues = [
     'world_surface',
     'world_surface_wg',
 ];
-export const RotationValues = [
-    'none',
-    'clockwise_90',
-    '180',
-    'counterclockwise_90',
-];
-export const MirrorValues = [
-    'none',
-    'left_right',
-    'front_back',
-];
+export const RotationValues = ['none', 'clockwise_90', '180', 'counterclockwise_90'];
+export const MirrorValues = ['none', 'left_right', 'front_back'];
 //# sourceMappingURL=index.js.map