@spyglassmc/java-edition 0.3.8 → 0.3.10

package/lib/mcfunction/completer/argument.js

@@ -2,9 +2,11 @@ import { AstNode, BooleanNode, BrigadierStringOptions, completer, CompletionItem
 import * as json from '@spyglassmc/json';
 import { localeQuote, localize } from '@spyglassmc/locales';
 import { getTagValues } from '../../common/index.js';
-import { ColorArgumentValues, EntityAnchorArgumentValues, GamemodeArgumentValues, HeightmapValues, ItemSlotArgumentValues, MirrorValues, OperationArgumentValues, RotationValues, ScoreboardSlotArgumentValues, SwizzleArgumentValues, } from '../common/index.js';
-import { BlockNode, CoordinateNode, EntitySelectorNode, IntRangeNode, ItemNode, ObjectiveCriteriaNode, ParticleNode, ScoreHolderNode, VectorNode, } from '../node/index.js';
-export const getMockNodes = (rawTreeNode, range) => {
+import { ReleaseVersion } from '../../dependency/common.js';
+import { ColorArgumentValues, EntityAnchorArgumentValues, GamemodeArgumentValues, getItemSlotArgumentValues, getItemSlotsArgumentValues, getScoreboardSlotArgumentValues, HeightmapValues, MirrorValues, OperationArgumentValues, RotationValues, SwizzleArgumentValues, } from '../common/index.js';
+import { BlockNode, ComponentTestExactNode, ComponentTestSubpredicateNode, CoordinateNode, EntitySelectorAtVariable, EntitySelectorNode, IntRangeNode, ItemPredicateNode, ItemStackNode, ObjectiveCriteriaNode, ParticleNode, ScoreHolderNode, VectorNode, } from '../node/index.js';
+export const getMockNodes = (rawTreeNode, ctx) => {
+    const range = ctx.offset;
     const treeNode = rawTreeNode;
     switch (treeNode.parser) {
         case 'brigadier:bool':
@@ -44,7 +46,9 @@ export const getMockNodes = (rawTreeNode, range) => {
             return ResourceLocationNode.mock(range, { category: 'dimension' });
         case 'minecraft:entity':
         case 'minecraft:game_profile':
-            return EntitySelectorNode.mock(range);
+            return EntitySelectorNode.mock(range, {
+                pool: EntitySelectorAtVariable.filterAvailable(ctx),
+            });
         case 'minecraft:heightmap':
             return LiteralNode.mock(range, { pool: HeightmapValues });
         case 'minecraft:entity_anchor':
@@ -60,11 +64,19 @@ export const getMockNodes = (rawTreeNode, range) => {
         case 'minecraft:item_enchantment':
             return ResourceLocationNode.mock(range, { category: 'enchantment' });
         case 'minecraft:item_predicate':
-            return ItemNode.mock(range, true);
+            return ItemPredicateNode.mock(range);
         case 'minecraft:item_slot':
-            return LiteralNode.mock(range, { pool: ItemSlotArgumentValues });
+            return LiteralNode.mock(range, { pool: getItemSlotArgumentValues(ctx) });
+        case 'minecraft:item_slots':
+            return LiteralNode.mock(range, { pool: getItemSlotsArgumentValues(ctx) });
         case 'minecraft:item_stack':
-            return ItemNode.mock(range, false);
+            return ItemStackNode.mock(range);
+        case 'minecraft:loot_modifier':
+            return ResourceLocationNode.mock(range, { category: 'item_modifier' });
+        case 'minecraft:loot_predicate':
+            return ResourceLocationNode.mock(range, { category: 'predicate' });
+        case 'minecraft:loot_table':
+            return ResourceLocationNode.mock(range, { category: 'loot_table' });
         case 'minecraft:mob_effect':
             return ResourceLocationNode.mock(range, { category: 'mob_effect' });
         case 'minecraft:objective':
@@ -81,18 +93,23 @@ export const getMockNodes = (rawTreeNode, range) => {
         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 ResourceLocationNode.mock(range, {
                 category: ResourceLocation.shorten(treeNode.properties.registry),
-                allowTag: treeNode.parser === 'minecraft:resource_or_tag',
+                allowTag,
             });
         case 'minecraft:resource_location':
             return ResourceLocationNode.mock(range, treeNode.properties ?? { pool: [], allowUnknown: true });
         case 'minecraft:rotation':
             return VectorNode.mock(range, { dimension: 2, noLocal: true });
         case 'minecraft:scoreboard_slot':
-            return LiteralNode.mock(range, { pool: ScoreboardSlotArgumentValues });
+            return LiteralNode.mock(range, { pool: getScoreboardSlotArgumentValues(ctx) });
         case 'minecraft:score_holder':
             return ScoreHolderNode.mock(range);
+        case 'minecraft:style':
+            return json.JsonObjectNode.mock(range);
         case 'minecraft:swizzle':
             return LiteralNode.mock(range, { pool: SwizzleArgumentValues });
         case 'minecraft:team':
@@ -121,10 +138,12 @@ const block = (node, ctx) => {
     if (Range.contains(node.id, ctx.offset, true)) {
         ans.push(...completer.resourceLocation(node.id, ctx));
     }
-    if (node.states &&
-        Range.contains(Range.translate(node.states, 1, -1), ctx.offset, true)) {
+    if (node.states && Range.contains(Range.translate(node.states, 1, -1), ctx.offset, true)) {
         ans.push(...blockStates(node.states, ctx));
     }
+    if (node.nbt && Range.contains(Range.translate(node.nbt, 1, -1), ctx.offset, true)) {
+        ans.push(...completer.dispatch(node.nbt, ctx));
+    }
     return ans;
 };
 const blockStates = (node, ctx) => {
@@ -137,51 +156,90 @@ const blockStates = (node, ctx) => {
     const states = getStates('block', blocks, ctx);
     return completer.record({
         key: (_record, pair, _ctx, range, insertValue, insertComma, existingKeys) => {
-            return Object.keys(states)
-                .filter((k) => pair?.key?.value === k ||
-                !existingKeys.some((ek) => ek.value === k))
-                .map((k) => CompletionItem.create(k, range, {
+            return Object.keys(states).filter((k) => pair?.key?.value === k || !existingKeys.some((ek) => ek.value === k)).map((k) => CompletionItem.create(k, range, {
                 kind: 10 /* CompletionKind.Property */,
                 detail: localize('mcfunction.completer.block.states.default-value', localeQuote(states[k][0])),
-                insertText: new InsertTextBuilder()
-                    .literal(k)
-                    .if(insertValue, (b) => b.literal('=').placeholder(...states[k]))
-                    .if(insertComma, (b) => b.literal(','))
-                    .build(),
+                insertText: new InsertTextBuilder().literal(k).if(insertValue, (b) => b.literal('=').placeholder(...states[k])).if(insertComma, (b) => b.literal(',')).build(),
             }));
         },
         value: (_record, pair, ctx) => {
             if (pair.key && states[pair.key.value]) {
-                return states[pair.key.value].map((v) => CompletionItem.create(v, pair.value ?? ctx.offset, {
-                    kind: 12 /* CompletionKind.Value */,
-                }));
+                return states[pair.key.value].map((v) => CompletionItem.create(v, pair.value ?? ctx.offset, { kind: 12 /* CompletionKind.Value */ }));
             }
             return [];
         },
     })(node, ctx);
 };
+const componentList = (node, ctx) => {
+    return completer.record({
+        key: (_record, pair, ctx, range) => {
+            const id = pair?.key
+                ?? ResourceLocationNode.mock(pair?.key ?? range, { category: 'data_component_type' });
+            return completer.resourceLocation(id, ctx);
+        },
+        value: (_record, pair, ctx) => {
+            if (!pair.value) {
+                return [];
+            }
+            return completer.dispatch(pair.value, ctx);
+        },
+    })(node, ctx);
+};
+const componentTests = (node, ctx) => {
+    // TODO: improve this completer
+    const test = AstNode.findShallowestChild({
+        node: node,
+        needle: ctx.offset,
+        endInclusive: true,
+        predicate: (n) => ComponentTestExactNode.is(n) || ComponentTestSubpredicateNode.is(n),
+    });
+    if (test && ComponentTestExactNode.is(test) && test.value) {
+        return completer.dispatch(test.value, ctx);
+    }
+    else if (test && ComponentTestSubpredicateNode.is(test) && test.value) {
+        return completer.dispatch(test.value, ctx);
+    }
+    return [];
+};
 const coordinate = (node, _ctx) => {
     return [CompletionItem.create('~', node)];
 };
-const item = (node, ctx) => {
+const itemStack = (node, ctx) => {
     const ans = [];
     if (Range.contains(node.id, ctx.offset, true)) {
         ans.push(...completer.resourceLocation(node.id, ctx));
     }
+    if (node.components && Range.contains(node.components, ctx.offset, true)) {
+        ans.push(...componentList(node.components, ctx));
+    }
+    if (node.nbt && Range.contains(node.nbt, ctx.offset, true)) {
+        ans.push(...completer.dispatch(node.nbt, ctx));
+    }
+    return ans;
+};
+const itemPredicate = (node, ctx) => {
+    const ans = [];
+    if (Range.contains(node.id, ctx.offset, true)) {
+        ans.push(CompletionItem.create('*', node, { sortText: '##' }));
+        if (node.id.type === 'resource_location') {
+            ans.push(...completer.resourceLocation(node.id, ctx));
+        }
+    }
+    if (node.tests && Range.contains(node.tests, ctx.offset, true)) {
+        ans.push(...componentTests(node.tests, ctx));
+    }
+    if (node.nbt && Range.contains(node.nbt, ctx.offset, true)) {
+        ans.push(...completer.dispatch(node.nbt, ctx));
+    }
     return ans;
 };
 const objectiveCriteria = (node, ctx) => {
     const ans = ObjectiveCriteriaNode.SimpleValues.map((v) => CompletionItem.create(v, node));
-    if (!node.children?.[0] ||
-        Range.contains(node.children[0], ctx.offset, true)) {
-        ans.push(...completer.resourceLocation(node.children?.[0] ??
-            ResourceLocationNode.mock(node, {
-                category: 'stat_type',
-                namespacePathSep: '.',
-            }), ctx));
+    if (!node.children?.[0] || Range.contains(node.children[0], ctx.offset, true)) {
+        ans.push(...completer.resourceLocation(node.children?.[0]
+            ?? ResourceLocationNode.mock(node, { category: 'stat_type', namespacePathSep: '.' }), ctx));
     }
-    if (node.children?.[1] &&
-        Range.contains(node.children[1], ctx.offset, true)) {
+    if (node.children?.[1] && Range.contains(node.children[1], ctx.offset, true)) {
         ans.push(...completer.resourceLocation(node.children[1], ctx));
     }
     return ans;
@@ -191,21 +249,22 @@ const particle = (node, ctx) => {
     if (child) {
         return completer.dispatch(child, ctx);
     }
+    const release = ctx.project['loadedVersion'];
+    if (!release || ReleaseVersion.cmp(release, '1.20.5') >= 0) {
+        return [];
+    }
     const id = ResourceLocationNode.toString(node.id, 'short');
     const map = {
         block: [BlockNode.mock(ctx.offset, false)],
         block_marker: [BlockNode.mock(ctx.offset, false)],
-        dust: [
-            VectorNode.mock(ctx.offset, { dimension: 3 }),
-            FloatNode.mock(ctx.offset),
-        ],
+        dust: [VectorNode.mock(ctx.offset, { dimension: 3 }), FloatNode.mock(ctx.offset)],
         dust_color_transition: [
             VectorNode.mock(ctx.offset, { dimension: 3 }),
             FloatNode.mock(ctx.offset),
             VectorNode.mock(ctx.offset, { dimension: 3 }),
         ],
         falling_dust: [BlockNode.mock(ctx.offset, false)],
-        item: [ItemNode.mock(ctx.offset, false)],
+        item: [ItemStackNode.mock(ctx.offset)],
         sculk_charge: [FloatNode.mock(ctx.offset)],
         shriek: [IntegerNode.mock(ctx.offset)],
         vibration: [
@@ -215,8 +274,8 @@ const particle = (node, ctx) => {
         ],
     };
     if (ParticleNode.isSpecialType(id)) {
-        const numParamsBefore = node.children?.slice(1).filter((n) => n.range.end < ctx.offset).length ??
-            0;
+        const numParamsBefore = node.children?.slice(1).filter((n) => n.range.end < ctx.offset).length
+            ?? 0;
         const mock = map[id][numParamsBefore];
         if (mock) {
             return completer.dispatch(mock, ctx);
@@ -234,7 +293,7 @@ const scoreHolder = (node, ctx) => {
     }
     else {
         ans = completer.symbol(node.fakeName ?? SymbolNode.mock(node, { category: 'score_holder' }), ctx);
-        ans.push(...selector(EntitySelectorNode.mock(node), ctx));
+        ans.push(...selector(EntitySelectorNode.mock(node, { pool: EntitySelectorAtVariable.filterAvailable(ctx) }), ctx));
     }
     return ans;
 };
@@ -242,8 +301,7 @@ const selector = (node, ctx) => {
     if (Range.contains(node.children[0], ctx.offset, true)) {
         return completer.literal(node.children[0], ctx);
     }
-    if (node.arguments &&
-        Range.contains(Range.translate(node.arguments, 1, -1), ctx.offset, true)) {
+    if (node.arguments && Range.contains(Range.translate(node.arguments, 1, -1), ctx.offset, true)) {
         return selectorArguments(node.arguments, ctx);
     }
     return [];
@@ -255,16 +313,10 @@ const selectorArguments = (node, ctx) => {
     }
     return completer.record({
         key: (record, pair, _ctx, range, insertValue, insertComma) => {
-            return [...EntitySelectorNode.ArgumentKeys]
-                .filter((k) => EntitySelectorNode.canKeyExist(selector, record, k) ===
-                0 /* EntitySelectorNode.Result.Ok */)
-                .map((k) => CompletionItem.create(k, range, {
+            return [...EntitySelectorNode.ArgumentKeys].filter((k) => EntitySelectorNode.canKeyExist(selector, record, k) === 0 /* EntitySelectorNode.Result.Ok */).map((k) => CompletionItem.create(k, range, {
                 kind: 10 /* CompletionKind.Property */,
-                insertText: new InsertTextBuilder()
-                    .literal(k)
-                    .if(insertValue, (b) => b.literal('=').placeholder()) // TODO
-                    .if(insertComma, (b) => b.literal(','))
-                    .build(),
+                insertText: new InsertTextBuilder().literal(k).if(insertValue, (b) => b.literal('=').placeholder()) // TODO
+                    .if(insertComma, (b) => b.literal(',')).build(),
             }));
         },
         value: (_record, pair, ctx) => {
@@ -277,13 +329,13 @@ const selectorArguments = (node, ctx) => {
 };
 const intRange = (node, _ctx) => {
     return [
-        CompletionItem.create('-2147483648..2147483647', node, {
-            kind: 21 /* CompletionKind.Constant */,
-        }),
+        CompletionItem.create('-2147483648..2147483647', node, { kind: 21 /* CompletionKind.Constant */ }),
     ];
 };
 const vector = (node, _ctx) => {
-    const createCompletion = (coordinate, sortText) => CompletionItem.create(new Array(node.options.dimension).fill(coordinate).join(' '), node, { sortText });
+    const createCompletion = (coordinate, sortText) => CompletionItem.create(new Array(node.options.dimension).fill(coordinate).join(' '), node, {
+        sortText,
+    });
     const ans = [];
     ans.push(createCompletion('~', 'a'));
     if (!node.options.noLocal) {
@@ -294,11 +346,14 @@ const vector = (node, _ctx) => {
 };
 export function register(meta) {
     meta.registerCompleter('mcfunction:block', block);
+    meta.registerCompleter('mcfunction:component_list', componentList);
+    meta.registerCompleter('mcfunction:component_tests', componentTests);
     meta.registerCompleter('mcfunction:coordinate', coordinate);
     meta.registerCompleter('mcfunction:entity_selector', selector);
     meta.registerCompleter('mcfunction:entity_selector/arguments', selectorArguments);
     meta.registerCompleter('mcfunction:int_range', intRange);
-    meta.registerCompleter('mcfunction:item', item);
+    meta.registerCompleter('mcfunction:item_stack', itemStack);
+    meta.registerCompleter('mcfunction:item_predicate', itemPredicate);
     meta.registerCompleter('mcfunction:objective_criteria', objectiveCriteria);
     meta.registerCompleter('mcfunction:particle', particle);
     meta.registerCompleter('mcfunction:score_holder', scoreHolder);

package/lib/mcfunction/index.d.ts

@@ -1,5 +1,6 @@
-import type * as core from '@spyglassmc/core';
-import type { McmetaCommands, ReleaseVersion } from '../dependency/index.js';
+import * as core from '@spyglassmc/core';
+import type { McmetaCommands } from '../dependency/index.js';
+import { ReleaseVersion } from '../dependency/index.js';
 export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
 export * as completer from './completer/index.js';

package/lib/mcfunction/index.js

@@ -1,11 +1,16 @@
+import * as core from '@spyglassmc/core';
 import * as mcf from '@spyglassmc/mcfunction';
+import { registerCustomResources } from '../binder/index.js';
+import { ReleaseVersion } from '../dependency/index.js';
 import * as checker from './checker/index.js';
 import * as colorizer from './colorizer/index.js';
 import * as completer from './completer/index.js';
 import { inlayHintProvider } from './inlayHintProvider.js';
+import { registerMcdocAttributes } from './mcdocAttributes.js';
 import * as parser from './parser/index.js';
 import { signatureHelpProvider } from './signatureHelpProvider.js';
 import { getPatch } from './tree/patch.js';
+import { validatePatchedTree } from './tree/patchValidator.js';
 export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
 export * as completer from './completer/index.js';
@@ -13,36 +18,30 @@ export * as parser from './parser/index.js';
 /* istanbul ignore next */
 export const initialize = (ctx, commands, releaseVersion) => {
     const { meta } = ctx;
+    registerCustomResources(ctx.config);
+    const tree = core.merge(commands, getPatch(releaseVersion));
+    if (ctx.isDebugging) {
+        validatePatchedTree(tree, ctx.logger);
+    }
     mcf.initialize(ctx);
-    mcf.CommandTreeRegistry.instance.register(releaseVersion, commands, getPatch(releaseVersion));
+    const supportsBackslashContinuation = ReleaseVersion.cmp(releaseVersion, '1.20.2') >= 0;
+    const supportsMacros = ReleaseVersion.cmp(releaseVersion, '1.20.2') >= 0;
     meta.registerLanguage('mcfunction', {
         extensions: ['.mcfunction'],
-        parser: mcf.entry(releaseVersion, parser.argument),
-        completer: mcf.completer.entry(releaseVersion, completer.getMockNodes),
-        triggerCharacters: [
-            ' ',
-            '[',
-            '=',
-            '!',
-            ',',
-            '{',
-            ':',
-            '/',
-            '.',
-            '"',
-            "'",
-        ],
+        parser: mcf.entry(tree, parser.argument, { supportsBackslashContinuation, supportsMacros }),
+        completer: mcf.completer.entry(tree, completer.getMockNodes),
+        triggerCharacters: [' ', '[', '=', '!', ',', '{', ':', '/', '.', '"', "'"],
     });
     meta.registerParser('mcfunction:block_predicate', parser.blockPredicate);
-    meta.registerParser('mcfunction:component', parser.component);
     meta.registerParser('mcfunction:particle', parser.particle);
     meta.registerParser('mcfunction:tag', parser.tag());
     meta.registerParser('mcfunction:team', parser.team());
-    meta.registerParser('mcfunction:command', mcf.command(mcf.CommandTreeRegistry.instance.get(releaseVersion), parser.argument));
+    meta.registerParser('mcfunction:command', mcf.command(tree, parser.argument));
+    registerMcdocAttributes(meta, tree);
     checker.register(meta);
     colorizer.register(meta);
     completer.register(meta);
     meta.registerInlayHintProvider(inlayHintProvider);
-    meta.registerSignatureHelpProvider(signatureHelpProvider(releaseVersion));
+    meta.registerSignatureHelpProvider(signatureHelpProvider(tree));
 };
 //# sourceMappingURL=index.js.map

package/lib/mcfunction/inlayHintProvider.js

@@ -8,9 +8,8 @@ export const inlayHintProvider = (node, ctx) => {
     core.traversePreOrder(node, (_) => true, mcf.CommandChildNode.is, (n) => {
         const node = n;
         const config = ctx.config.env.feature.inlayHint;
-        if (config === true ||
-            (typeof config === 'object' &&
-                config.enabledNodes.includes(node.children[0].type))) {
+        if (config === true
+            || (typeof config === 'object' && config.enabledNodes.includes(node.children[0].type))) {
             ans.push({
                 offset: node.range.start,
                 label: `${node.path[node.path.length - 1]}:`,

package/lib/mcfunction/mcdocAttributes.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import * as mcf from '@spyglassmc/mcfunction';
+export declare function registerMcdocAttributes(meta: core.MetaRegistry, rootTreeNode: mcf.RootTreeNode): void;
+//# sourceMappingURL=mcdocAttributes.d.ts.map

package/lib/mcfunction/mcdocAttributes.js

@@ -0,0 +1,74 @@
+import * as core from '@spyglassmc/core';
+import * as json from '@spyglassmc/json';
+import { localize } from '@spyglassmc/locales';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import * as mcf from '@spyglassmc/mcfunction';
+import { getItemSlotsArgumentValues } from './common/index.js';
+import { EntitySelectorAtVariable, EntitySelectorNode, ScoreHolderNode } from './node/argument.js';
+import * as parser from './parser/index.js';
+const validator = mcdoc.runtime.attribute.validator;
+const entityValidator = validator.alternatives(validator.tree({
+    amount: validator.options('multiple', 'single'),
+    type: validator.options('entities', 'players'),
+}), () => ({ amount: 'multiple', type: 'entities' }));
+const scoreHolderValidator = validator.alternatives(validator.tree({
+    amount: validator.options('multiple', 'single'),
+}), () => ({ amount: 'multiple' }));
+export function registerMcdocAttributes(meta, rootTreeNode) {
+    mcdoc.runtime.registerAttribute(meta, 'command', () => undefined, {
+        // TODO: validate slash
+        // TODO: fix completer inside commands
+        stringParser: () => {
+            return mcf.command(rootTreeNode, parser.argument);
+        },
+    });
+    mcdoc.runtime.registerAttribute(meta, 'text_component', () => undefined, {
+        stringParser: () => makeInfallible(core.map(json.parser.entry, (res) => ({
+            type: 'json:typed',
+            range: res.range,
+            children: [res],
+            targetType: { kind: 'reference', path: '::java::server::util::text::Text' },
+        })), localize('text-component')),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'objective', () => undefined, {
+        stringParser: () => parser.objective('reference'),
+        stringMocker: (_, __, ctx) => core.SymbolNode.mock(ctx.offset, { category: 'objective' }),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'team', () => undefined, {
+        stringParser: () => parser.team('reference'),
+        stringMocker: (_, __, ctx) => core.SymbolNode.mock(ctx.offset, { category: 'team' }),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'score_holder', scoreHolderValidator, {
+        stringParser: (config) => makeInfallible(parser.scoreHolder('reference', config.amount), localize('score-holder')),
+        stringMocker: (_, __, ctx) => ScoreHolderNode.mock(ctx.offset),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'tag', () => undefined, {
+        stringParser: () => parser.tag('definition'), // TODO: make this a config
+        stringMocker: (_, __, ctx) => core.SymbolNode.mock(ctx.offset, { category: 'tag' }),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'entity', entityValidator, {
+        stringParser: (config) => makeInfallible(parser.entity(config.amount, config.type), localize('selector')),
+        stringMocker: (_, __, ctx) => EntitySelectorNode.mock(ctx.offset, {
+            pool: EntitySelectorAtVariable.filterAvailable(ctx),
+        }),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'item_slots', () => undefined, {
+        stringParser: () => parser.itemSlots,
+        stringMocker: (_, __, ctx) => core.LiteralNode.mock(ctx.offset, { pool: getItemSlotsArgumentValues(ctx) }),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'uuid', () => undefined, {
+        stringParser: () => parser.uuid,
+    });
+}
+function makeInfallible(parser, message) {
+    return (src, ctx) => {
+        const start = src.cursor;
+        const res = parser(src, ctx);
+        if (res === core.Failure) {
+            ctx.err.report(localize('expected', message), core.Range.create(start, src.skipRemaining()));
+            return undefined;
+        }
+        return res;
+    };
+}
+//# sourceMappingURL=mcdocAttributes.js.map