@spyglassmc/java-edition 0.3.10 → 0.3.12

package/lib/index.js

@@ -1,5 +1,6 @@
 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 nbt from '@spyglassmc/nbt';
 import { uriBinder } from './binder/index.js';
@@ -11,7 +12,7 @@ export * as dependency from './dependency/index.js';
 export * as json from './json/index.js';
 export * as mcf from './mcfunction/index.js';
 export const initialize = async (ctx) => {
-    const { config, downloader, externals, logger, meta, projectRoot } = ctx;
+    const { config, downloader, externals, logger, meta, projectRoots } = ctx;
     async function readPackMcmeta(uri) {
         try {
             const data = await core.fileUtil.readJson(externals, uri);
@@ -21,7 +22,7 @@ export const initialize = async (ctx) => {
         catch (e) {
             if (!externals.error.isKind(e, 'ENOENT')) {
                 // `pack.mcmeta` exists but broken. Log an error.
-                logger.error(`[je.initialize] Failed loading pack.mcmeta “${uri}”`, e);
+                logger.error(`[je.initialize] Failed loading pack.mcmeta ${uri}`, e);
             }
         }
         return undefined;
@@ -29,16 +30,18 @@ export const initialize = async (ctx) => {
     async function findPackMcmeta() {
         const searched = new Set();
         for (let depth = 0; depth <= 2; depth += 1) {
-            const files = await externals.fs.getAllFiles(projectRoot, depth + 1);
-            for (const uri of files.filter(uri => uri.endsWith('/pack.mcmeta'))) {
-                if (searched.has(uri)) {
-                    continue;
-                }
-                searched.add(uri);
-                const data = await readPackMcmeta(uri);
-                if (data) {
-                    logger.info(`[je.initialize] Found a valid pack.mcmeta “${uri}” with pack_format “${data.pack.pack_format}”`);
-                    return data;
+            for (const projectRoot of projectRoots) {
+                const files = await externals.fs.getAllFiles(projectRoot, depth + 1);
+                for (const uri of files.filter(uri => uri.endsWith('/pack.mcmeta'))) {
+                    if (searched.has(uri)) {
+                        continue;
+                    }
+                    searched.add(uri);
+                    const data = await readPackMcmeta(uri);
+                    if (data) {
+                        logger.info(`[je.initialize] Found a valid pack.mcmeta ${uri} with pack_format ${data.pack.pack_format}`);
+                        return data;
+                    }
                 }
             }
         }
@@ -112,6 +115,37 @@ export const initialize = async (ctx) => {
             return field;
         },
     });
+    const packFormats = new Map();
+    for (const version of versions) {
+        if (version.type === 'release' && !packFormats.has(version.data_pack_version)) {
+            packFormats.set(version.data_pack_version, version);
+        }
+    }
+    mcdoc.runtime.registerAttribute(meta, 'pack_format', () => undefined, {
+        checker: (_, typeDef) => {
+            if (typeDef.kind !== 'literal' || typeof typeDef.value.value !== 'number') {
+                return undefined;
+            }
+            const target = typeDef.value.value;
+            return (node, ctx) => {
+                const targetVersion = packFormats.get(target);
+                if (!targetVersion) {
+                    ctx.err.report(localize('java-edition.pack-format.unsupported', target), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+                else if (targetVersion.id !== release) {
+                    ctx.err.report(localize('java-edition.pack-format.not-loaded', target, release), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+            };
+        },
+        numericCompleter: (_, ctx) => {
+            return [...packFormats.values()].map((v, i) => ({
+                range: core.Range.create(ctx.offset),
+                label: `${v.data_pack_version}`,
+                labelSuffix: ` (${v.id})`,
+                sortText: `${i}`.padStart(4, '0'),
+            }));
+        },
+    });
     json.initialize(ctx);
     jeJson.initialize(ctx);
     jeMcf.initialize(ctx, summary.commands, release);

package/lib/json/index.js

@@ -1,6 +1,8 @@
 /* istanbul ignore file */
 import * as checker from './checker/index.js';
+import { registerMcdocAttributes } from './mcdocAttributes.js';
 export const initialize = (ctx) => {
+    registerMcdocAttributes(ctx.meta);
     checker.register(ctx.meta);
 };
 //# sourceMappingURL=index.js.map

package/lib/json/mcdocAttributes.d.ts

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

package/lib/json/mcdocAttributes.js

@@ -0,0 +1,35 @@
+import * as core from '@spyglassmc/core';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { dissectUri } from '../binder/index.js';
+const validator = mcdoc.runtime.attribute.validator;
+const criterionValidator = validator.alternatives(validator.tree({
+    definition: validator.boolean,
+}), () => ({ definition: false }));
+export function registerMcdocAttributes(meta) {
+    mcdoc.runtime.registerAttribute(meta, 'criterion', criterionValidator, {
+        stringParser: (config, _, ctx) => {
+            const parts = dissectUri(ctx.doc.uri, ctx);
+            if (!parts || !parts.ok || parts.category !== 'advancement') {
+                return undefined;
+            }
+            return core.symbol({
+                category: 'advancement',
+                subcategory: 'criterion',
+                parentPath: [`${parts.namespace}:${parts.identifier}`],
+                usageType: config.definition ? 'definition' : 'reference',
+            });
+        },
+        stringMocker: (config, _, ctx) => {
+            const parts = dissectUri(ctx.doc.uri, ctx);
+            if (!parts || !parts.ok || parts.category !== 'advancement') {
+                return undefined;
+            }
+            return core.SymbolNode.mock(ctx.offset, {
+                category: 'advancement',
+                subcategory: 'criterion',
+                parentPath: [`${parts.namespace}:${parts.identifier}`],
+            });
+        },
+    });
+}
+//# sourceMappingURL=mcdocAttributes.js.map

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

@@ -1,5 +1,5 @@
 import * as core from '@spyglassmc/core';
-import * as mcf from '@spyglassmc/mcfunction';
+import type * as mcf from '@spyglassmc/mcfunction';
 export declare const command: core.Checker<mcf.CommandNode>;
 export declare function register(meta: core.MetaRegistry): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/checker/index.js

@@ -1,7 +1,6 @@
 import * as core from '@spyglassmc/core';
 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';
@@ -15,9 +14,6 @@ const entry = (node, 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);
 };
 function getEarlierNode(nodes, before, name) {

package/lib/mcfunction/completer/argument.js

@@ -5,7 +5,7 @@ import { getTagValues } from '../../common/index.js';
 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) => {
+export const getMockNodes = (rawTreeNode, prevNodes, ctx) => {
     const range = ctx.offset;
     const treeNode = rawTreeNode;
     switch (treeNode.parser) {
@@ -122,6 +122,18 @@ export const getMockNodes = (rawTreeNode, ctx) => {
             return VectorNode.mock(range, { dimension: 2, integersOnly: true });
         case 'minecraft:vec3':
             return VectorNode.mock(range, { dimension: 3 });
+        case 'spyglassmc:criterion':
+            const advancementNode = prevNodes.length > 0
+                ? prevNodes[prevNodes.length - 1].children[0]
+                : undefined;
+            if (ResourceLocationNode.is(advancementNode)) {
+                return SymbolNode.mock(range, {
+                    category: 'advancement',
+                    subcategory: 'criterion',
+                    parentPath: [ResourceLocationNode.toString(advancementNode, 'full')],
+                });
+            }
+            return [];
         case 'spyglassmc:tag':
             return SymbolNode.mock(range, { category: 'tag' });
         // ==== Unimplemented ====

package/lib/mcfunction/index.js

@@ -24,11 +24,16 @@ export const initialize = (ctx, commands, releaseVersion) => {
         validatePatchedTree(tree, ctx.logger);
     }
     mcf.initialize(ctx);
-    const supportsBackslashContinuation = ReleaseVersion.cmp(releaseVersion, '1.20.2') >= 0;
-    const supportsMacros = ReleaseVersion.cmp(releaseVersion, '1.20.2') >= 0;
+    const mcfunctionOptions = {
+        lineContinuation: ReleaseVersion.cmp(releaseVersion, '1.20.2') >= 0,
+        macros: ReleaseVersion.cmp(releaseVersion, '1.20.2') >= 0,
+        commandOptions: ReleaseVersion.cmp(releaseVersion, '1.20.5') >= 0
+            ? { maxLength: 2_000_000 }
+            : {},
+    };
     meta.registerLanguage('mcfunction', {
         extensions: ['.mcfunction'],
-        parser: mcf.entry(tree, parser.argument, { supportsBackslashContinuation, supportsMacros }),
+        parser: mcf.entry(tree, parser.argument, mcfunctionOptions),
         completer: mcf.completer.entry(tree, completer.getMockNodes),
         triggerCharacters: [' ', '[', '=', '!', ',', '{', ':', '/', '.', '"', "'"],
     });

package/lib/mcfunction/mcdocAttributes.js

@@ -7,6 +7,11 @@ 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 commandValidator = validator.alternatives(validator.tree({
+    slash: validator.optional(validator.options('allowed', 'required', 'chat')),
+    max_length: validator.optional(validator.number),
+    empty: validator.optional(validator.options('allowed')),
+}), () => ({}));
 const entityValidator = validator.alternatives(validator.tree({
     amount: validator.options('multiple', 'single'),
     type: validator.options('entities', 'players'),
@@ -15,11 +20,20 @@ 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
+    mcdoc.runtime.registerAttribute(meta, 'command', commandValidator, {
         // TODO: fix completer inside commands
-        stringParser: () => {
-            return mcf.command(rootTreeNode, parser.argument);
+        stringParser: ({ slash, max_length, empty }) => {
+            return (src, ctx) => {
+                if ((empty && !src.canRead()) || (slash === 'chat' && src.peek() !== '/')) {
+                    return core.string({
+                        unquotable: { blockList: new Set(), allowEmpty: true },
+                    })(src, ctx);
+                }
+                return mcf.command(rootTreeNode, parser.argument, {
+                    slash: slash === 'chat' ? 'allowed' : slash,
+                    maxLength: max_length,
+                })(src, ctx);
+            };
         },
     });
     mcdoc.runtime.registerAttribute(meta, 'text_component', () => undefined, {

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

@@ -36,7 +36,7 @@ export declare const enum CoordinateSystem {
     World = 0,
     Local = 1
 }
-export interface EntitySelectorAdvancementsArgumentCriteriaNode extends core.RecordBaseNode<core.StringNode, core.BooleanNode> {
+export interface EntitySelectorAdvancementsArgumentCriteriaNode extends core.RecordBaseNode<core.StringNode | core.SymbolNode, core.BooleanNode> {
     type: 'mcfunction:entity_selector/arguments/advancements/criteria';
 }
 export interface EntitySelectorAdvancementsArgumentNode extends core.RecordBaseNode<core.ResourceLocationNode, core.BooleanNode | EntitySelectorAdvancementsArgumentCriteriaNode> {

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

@@ -9,6 +9,7 @@ import { EntitySelectorNode } from '../node/index.js';
  */
 export declare const argument: mcf.ArgumentParserGetter;
 export declare const blockPredicate: core.InfallibleParser<BlockNode>;
+export declare function criterion(advancement: core.FullResourceLocation, usageType?: core.SymbolUsageType, terminators?: string[]): core.InfallibleParser<core.SymbolNode>;
 export declare function entity(amount: 'multiple' | 'single', type: 'entities' | 'players'): core.Parser<EntityNode>;
 export declare const itemSlots: core.InfallibleParser<core.LiteralNode>;
 export declare function jsonParser(typeRef: `::${string}::${string}`): core.Parser<json.TypedJsonNode>;

package/lib/mcfunction/parser/argument.js

@@ -45,7 +45,7 @@ function shouldUseOldItemStackFormat(ctx) {
  * @returns The parser for the specified argument tree node. All argument parsers used in the `mcfunction` package
  * fail on empty input.
  */
-export const argument = (rawTreeNode) => {
+export const argument = (rawTreeNode, prevNodes) => {
     const treeNode = rawTreeNode;
     const wrap = (parser) => core.failOnEmpty(core.stopBefore(parser, '\r', '\n'));
     switch (treeNode.parser) {
@@ -81,7 +81,7 @@ export const argument = (rawTreeNode) => {
             return wrap(core.map(core.literal(...ColorArgumentValues), (res) => ({
                 ...res,
                 color: core.Color.NamedColors.has(res.value)
-                    ? core.Color.fromCompositeInt(core.Color.NamedColors.get(res.value))
+                    ? core.Color.fromCompositeRGB(core.Color.NamedColors.get(res.value))
                     : undefined,
             })));
         case 'minecraft:column_pos':
@@ -186,6 +186,16 @@ export const argument = (rawTreeNode) => {
             return wrap(vector({ dimension: 2, noLocal: true }));
         case 'minecraft:vec3':
             return wrap(vector({ dimension: 3 }));
+        case 'spyglassmc:criterion':
+            const advancementNode = prevNodes.length > 0
+                ? prevNodes[prevNodes.length - 1].children[0]
+                : undefined;
+            if (core.ResourceLocationNode.is(advancementNode)) {
+                return wrap(criterion(core.ResourceLocationNode.toString(advancementNode, 'full'), core.SymbolUsageType.is(treeNode.properties?.usageType)
+                    ? treeNode.properties?.usageType
+                    : undefined));
+            }
+            return wrap(greedyString);
         case 'spyglassmc:tag':
             return wrap(tag(core.SymbolUsageType.is(treeNode.properties?.usageType)
                 ? treeNode.properties?.usageType
@@ -266,6 +276,9 @@ function coordinate(integerOnly = false) {
         return ans;
     };
 }
+export function criterion(advancement, usageType, terminators = []) {
+    return unquotableSymbol({ category: 'advancement', subcategory: 'criterion', parentPath: [advancement], usageType }, terminators);
+}
 export function entity(amount, type) {
     return core.map(core.select([{ predicate: (src) => src.peek() === '@', parser: selector() }, {
             parser: core.any([
@@ -588,26 +601,31 @@ export function selector(ignoreInvalidPrefix = false) {
                                                     category: 'advancement',
                                                 }),
                                                 sep: '=',
-                                                value: core.select([{
-                                                        predicate: (src) => src.peek() === '{',
-                                                        parser: core.map(core.record({
-                                                            start: '{',
-                                                            pair: {
-                                                                key: unquotedString,
-                                                                sep: '=',
-                                                                value: core.boolean,
-                                                                end: ',',
-                                                                trailingEnd: true,
-                                                            },
-                                                            end: '}',
-                                                        }), (res) => {
-                                                            const ans = {
-                                                                ...res,
-                                                                type: 'mcfunction:entity_selector/arguments/advancements/criteria',
-                                                            };
-                                                            return ans;
-                                                        }),
-                                                    }, { parser: core.boolean }]),
+                                                value: {
+                                                    get: (_, key) => core.select([{
+                                                            predicate: (src) => src.peek() === '{',
+                                                            parser: core.map(core.record({
+                                                                start: '{',
+                                                                pair: {
+                                                                    key: key
+                                                                        ? criterion(core.ResourceLocationNode
+                                                                            .toString(key, 'full'), 'reference', ['}', ',', '='])
+                                                                        : unquotedString,
+                                                                    sep: '=',
+                                                                    value: core.boolean,
+                                                                    end: ',',
+                                                                    trailingEnd: true,
+                                                                },
+                                                                end: '}',
+                                                            }), (res) => {
+                                                                const ans = {
+                                                                    ...res,
+                                                                    type: 'mcfunction:entity_selector/arguments/advancements/criteria',
+                                                                };
+                                                                return ans;
+                                                            }),
+                                                        }, { parser: core.boolean }]),
+                                                },
                                                 end: ',',
                                                 trailingEnd: true,
                                             },
@@ -1066,7 +1084,7 @@ const componentTest = (src, ctx) => {
             negated,
         };
         const value = nbt.parser.entry(src, ctx);
-        if (value == core.Failure) {
+        if (value === core.Failure) {
             ctx.err.report(localize('expected', localize('nbt.node')), src);
             src.skipUntilOrEnd(',', '|', ']');
         }
@@ -1090,7 +1108,7 @@ const componentTest = (src, ctx) => {
             negated,
         };
         const predicate = nbt.parser.entry(src, ctx);
-        if (predicate == core.Failure) {
+        if (predicate === core.Failure) {
             ctx.err.report(localize('expected', localize('nbt.node')), src);
             src.skipUntilOrEnd(',', '|', ']');
         }

package/lib/mcfunction/signatureHelpProvider.d.ts

@@ -1,6 +1,6 @@
 import * as core from '@spyglassmc/core';
 import * as mcf from '@spyglassmc/mcfunction';
-import type { RootTreeNode } from '../dependency';
+import type { RootTreeNode } from '../dependency/index.js';
 /**
  * Only command options that can be satisfied by the current command node will be listed in `signatures`.
  * Only parameters at and immediately after the `offset` will be listed in `parameters`.

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

@@ -257,8 +257,11 @@ export interface MinecraftVec2ArgumentTreeNode extends mcf.ArgumentTreeNode {
 export interface MinecraftVec3ArgumentTreeNode extends mcf.ArgumentTreeNode {
     parser: 'minecraft:vec3';
 }
+export interface SpyglassmcCriterionArgumentTreeNode extends mcf.ArgumentTreeNode {
+    parser: 'spyglassmc:criterion';
+}
 export interface SpyglassmcTagArgumentTreeNode extends mcf.ArgumentTreeNode {
     parser: 'spyglassmc:tag';
 }
-export type ArgumentTreeNode = BrigadierBoolArgumentTreeNode | BrigadierDoubleArgumentTreeNode | BrigadierFloatArgumentTreeNode | BrigadierIntegerArgumentTreeNode | BrigadierLongArgumentTreeNode | BrigadierStringArgumentTreeNode | MinecraftAngleArgumentTreeNode | MinecraftBlockPosArgumentTreeNode | MinecraftBlockPredicateArgumentTreeNode | MinecraftBlockStateArgumentTreeNode | MinecraftColorArgumentTreeNode | MinecraftColumnPosArgumentTreeNode | MinecraftComponentArgumentTreeNode | MinecraftDimensionArgumentTreeNode | MinecraftEntityArgumentTreeNode | MinecraftEntityAnchorArgumentTreeNode | MinecraftEntitySummonArgumentTreeNode | MinecraftFloatRangeArgumentTreeNode | MinecraftFunctionArgumentTreeNode | MinecraftGamemodeArgumentTreeNode | MinecraftGameProfileArgumentTreeNode | MinecraftHeightmapArgumentTreeNode | MinecraftIntRangeArgumentTreeNode | MinecraftItemEnchantmentArgumentTreeNode | MinecraftItemPredicateArgumentTreeNode | MinecraftItemSlotArgumentTreeNode | MinecraftItemSlotsArgumentTreeNode | MinecraftItemStackArgumentTreeNode | MinecraftLootModifierArgumentTreeNode | MinecraftLootPredicateArgumentTreeNode | MinecraftLootTableArgumentTreeNode | MinecraftMessageArgumentTreeNode | MinecraftMobEffectArgumentTreeNode | MinecraftNbtCompoundTagArgumentTreeNode | MinecraftNbtPathArgumentTreeNode | MinecraftNbtTagArgumentTreeNode | MinecraftObjectiveArgumentTreeNode | MinecraftObjectiveCriteriaArgumentTreeNode | MinecraftOperationArgumentTreeNode | MinecraftParticleArgumentTreeNode | MinecraftResourceArgumentTreeNode | MinecraftResourceKeyArgumentTreeNode | MinecraftResourceLocationArgumentTreeNode | MinecraftResourceOrTagArgumentTreeNode | MinecraftResourceOrTagKeyArgumentTreeNode | MinecraftRotationArgumentTreeNode | MinecraftScoreHolderArgumentTreeNode | MinecraftScoreboardSlotArgumentTreeNode | MinecraftStyleArgumentTreeNode | MinecraftSwizzleArgumentTreeNode | MinecraftTeamArgumentTreeNode | MinecraftTemplateMirrorArgumentTreeNode | MinecraftTemplateRotationArgumentTreeNode | MinecraftTimeArgumentTreeNode | MinecraftUuidArgumentTreeNode | MinecraftVec2ArgumentTreeNode | MinecraftVec3ArgumentTreeNode | SpyglassmcTagArgumentTreeNode;
+export type ArgumentTreeNode = BrigadierBoolArgumentTreeNode | BrigadierDoubleArgumentTreeNode | BrigadierFloatArgumentTreeNode | BrigadierIntegerArgumentTreeNode | BrigadierLongArgumentTreeNode | BrigadierStringArgumentTreeNode | MinecraftAngleArgumentTreeNode | MinecraftBlockPosArgumentTreeNode | MinecraftBlockPredicateArgumentTreeNode | MinecraftBlockStateArgumentTreeNode | MinecraftColorArgumentTreeNode | MinecraftColumnPosArgumentTreeNode | MinecraftComponentArgumentTreeNode | MinecraftDimensionArgumentTreeNode | MinecraftEntityArgumentTreeNode | MinecraftEntityAnchorArgumentTreeNode | MinecraftEntitySummonArgumentTreeNode | MinecraftFloatRangeArgumentTreeNode | MinecraftFunctionArgumentTreeNode | MinecraftGamemodeArgumentTreeNode | MinecraftGameProfileArgumentTreeNode | MinecraftHeightmapArgumentTreeNode | MinecraftIntRangeArgumentTreeNode | MinecraftItemEnchantmentArgumentTreeNode | MinecraftItemPredicateArgumentTreeNode | MinecraftItemSlotArgumentTreeNode | MinecraftItemSlotsArgumentTreeNode | MinecraftItemStackArgumentTreeNode | MinecraftLootModifierArgumentTreeNode | MinecraftLootPredicateArgumentTreeNode | MinecraftLootTableArgumentTreeNode | MinecraftMessageArgumentTreeNode | MinecraftMobEffectArgumentTreeNode | MinecraftNbtCompoundTagArgumentTreeNode | MinecraftNbtPathArgumentTreeNode | MinecraftNbtTagArgumentTreeNode | MinecraftObjectiveArgumentTreeNode | MinecraftObjectiveCriteriaArgumentTreeNode | MinecraftOperationArgumentTreeNode | MinecraftParticleArgumentTreeNode | MinecraftResourceArgumentTreeNode | MinecraftResourceKeyArgumentTreeNode | MinecraftResourceLocationArgumentTreeNode | MinecraftResourceOrTagArgumentTreeNode | MinecraftResourceOrTagKeyArgumentTreeNode | MinecraftRotationArgumentTreeNode | MinecraftScoreHolderArgumentTreeNode | MinecraftScoreboardSlotArgumentTreeNode | MinecraftStyleArgumentTreeNode | MinecraftSwizzleArgumentTreeNode | MinecraftTeamArgumentTreeNode | MinecraftTemplateMirrorArgumentTreeNode | MinecraftTemplateRotationArgumentTreeNode | MinecraftTimeArgumentTreeNode | MinecraftUuidArgumentTreeNode | MinecraftVec2ArgumentTreeNode | MinecraftVec3ArgumentTreeNode | SpyglassmcCriterionArgumentTreeNode | SpyglassmcTagArgumentTreeNode;
 //# sourceMappingURL=argument.d.ts.map

package/lib/mcfunction/tree/patch.js

@@ -758,6 +758,14 @@ const AdvancementTargets = Object.freeze({
                             properties: {
                                 category: 'advancement',
                             },
+                            children: {
+                                criterion: {
+                                    parser: 'spyglassmc:criterion',
+                                    properties: {
+                                        usageType: 'reference',
+                                    },
+                                },
+                            },
                         },
                     },
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/java-edition",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -17,12 +17,12 @@
     "release:dry": "npm publish --dry-run"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.7",
-    "@spyglassmc/json": "0.3.9",
-    "@spyglassmc/locales": "0.3.7",
-    "@spyglassmc/mcfunction": "0.2.9",
-    "@spyglassmc/mcdoc": "0.3.10",
-    "@spyglassmc/nbt": "0.3.10"
+    "@spyglassmc/core": "0.4.9",
+    "@spyglassmc/json": "0.3.11",
+    "@spyglassmc/locales": "0.3.8",
+    "@spyglassmc/mcfunction": "0.2.11",
+    "@spyglassmc/mcdoc": "0.3.12",
+    "@spyglassmc/nbt": "0.3.12"
   },
   "devDependencies": {
     "fast-glob": "^3.2.5"