@spyglassmc/java-edition 0.3.18 → 0.3.20

package/lib/index.js

@@ -1,15 +1,16 @@
 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';
-import { getMcmetaSummary, getVanillaDatapack, getVanillaMcdoc, getVersions, PackMcmeta, ReleaseVersion, resolveConfiguredVersion, symbolRegistrar, } from './dependency/index.js';
+import { getMcmetaSummary, getVanillaDatapack, getVanillaMcdoc, getVanillaResourcepack, getVersions, PackMcmeta, resolveConfiguredVersion, symbolRegistrar, } from './dependency/index.js';
 import * as jeJson from './json/index.js';
+import { registerMcdocAttributes, registerPackFormatAttribute } from './mcdocAttributes.js';
 import * as jeMcf from './mcfunction/index.js';
 export * as binder from './binder/index.js';
 export * as dependency from './dependency/index.js';
 export * as json from './json/index.js';
+export * from './mcdocAttributes.js';
 export * as mcf from './mcfunction/index.js';
 export const initialize = async (ctx) => {
     const { config, downloader, externals, logger, meta, projectRoots } = ctx;
@@ -27,26 +28,28 @@ export const initialize = async (ctx) => {
         }
         return undefined;
     }
-    async function findPackMcmeta() {
-        const searched = new Set();
+    async function findPackMcmetas(versions) {
+        const searchedUris = new Set();
+        const packs = [];
         for (let depth = 0; depth <= 2; depth += 1) {
             for (const projectRoot of projectRoots) {
                 const files = await core.fileUtil.getAllFiles(externals, projectRoot, depth + 1);
                 for (const uri of files.filter(uri => uri.endsWith('/pack.mcmeta'))) {
-                    if (searched.has(uri)) {
+                    if (searchedUris.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;
-                    }
+                    searchedUris.add(uri);
+                    const packRoot = core.fileUtil.dirname(uri);
+                    const [packMcmeta, type] = await Promise.all([
+                        readPackMcmeta(uri),
+                        PackMcmeta.getType(packRoot, externals),
+                    ]);
+                    const versionInfo = resolveConfiguredVersion(config.env.gameVersion, versions, packMcmeta, type, logger);
+                    packs.push({ type, packRoot, packMcmeta, versionInfo });
                 }
             }
         }
-        logger.warn('[je.initialize] Failed finding a valid pack.mcmeta');
-        return undefined;
+        return packs;
     }
     meta.registerUriBinder(uriBinder);
     const versions = await getVersions(ctx.externals, ctx.downloader);
@@ -54,9 +57,32 @@ export const initialize = async (ctx) => {
         ctx.logger.error('[je-initialize] Failed loading game version list. Expect everything to be broken.');
         return;
     }
-    const version = await resolveConfiguredVersion(config.env.gameVersion, versions, findPackMcmeta);
+    const packs = await findPackMcmetas(versions);
+    function selectVersionInfo(packs, versions) {
+        // Select the first valid pack.mcmeta, prioritizing data packs
+        const pack = packs.find(p => p.packMcmeta !== undefined && p.type === 'data')
+            ?? packs.find(p => p.packMcmeta !== undefined && p.type === 'assets');
+        const version = pack === undefined
+            ? resolveConfiguredVersion(config.env.gameVersion, versions, undefined, undefined, logger)
+            : pack.versionInfo;
+        const packMessage = pack === undefined
+            ? 'Failed finding a valid pack.mcmeta'
+            : `Found a valid pack.mcmeta ${pack.packRoot}/pack.mcmeta`;
+        const reasonMessage = pack && version.reason === 'auto'
+            ? `using ${pack.type} pack format ${pack.packMcmeta?.pack.pack_format} to select`
+            : version.reason === 'config'
+                ? `but using config override "${config.env.gameVersion}" to select`
+                : version.reason === 'fallback'
+                    ? 'using fallback'
+                    : 'impossible'; // should never occur
+        const versionMessage = `version ${version.release}${version.id === version.release ? '' : ` (${version.id})`}`;
+        ctx.logger.info(`[je.initialize] ${packMessage}, ${reasonMessage} ${versionMessage}`);
+        return version;
+    }
+    const version = selectVersionInfo(packs, versions);
     const release = version.release;
     meta.registerDependencyProvider('@vanilla-datapack', () => getVanillaDatapack(downloader, version.id, version.isLatest));
+    meta.registerDependencyProvider('@vanilla-resourcepack', () => getVanillaResourcepack(downloader, version.id, version.isLatest));
     meta.registerDependencyProvider('@vanilla-mcdoc', () => getVanillaMcdoc(downloader));
     const summary = await getMcmetaSummary(ctx.externals, downloader, logger, version.id, version.isLatest, config.env.dataSource, config.env.mcmetaSummaryOverrides);
     if (!summary.blocks || !summary.commands || !summary.fluids || !summary.registries) {
@@ -64,8 +90,8 @@ export const initialize = async (ctx) => {
         return;
     }
     meta.registerSymbolRegistrar('mcmeta-summary', {
-        checksum: summary.checksum,
-        registrar: symbolRegistrar(summary),
+        checksum: `${summary.checksum}_v3`,
+        registrar: symbolRegistrar(summary, release),
     });
     meta.registerLinter('nameOfNbtKey', {
         configValidator: core.linter.configValidator.nameConvention,
@@ -82,70 +108,15 @@ export const initialize = async (ctx) => {
                 && mcdoc.StructKeyNode.is(n)
                 && !n.symbol?.path[0]?.startsWith('::minecraft')),
     });
-    mcdoc.runtime.registerAttribute(meta, 'since', mcdoc.runtime.attribute.validator.string, {
-        filterElement: (config, ctx) => {
-            if (!config.startsWith('1.')) {
-                ctx.logger.warn(`Invalid mcdoc attribute for "since": ${config}`);
-                return true;
-            }
-            return ReleaseVersion.cmp(release, config) >= 0;
-        },
-    });
-    mcdoc.runtime.registerAttribute(meta, 'until', mcdoc.runtime.attribute.validator.string, {
-        filterElement: (config, ctx) => {
-            if (!config.startsWith('1.')) {
-                ctx.logger.warn(`Invalid mcdoc attribute for "until": ${config}`);
-                return true;
-            }
-            return ReleaseVersion.cmp(release, config) < 0;
-        },
-    });
-    mcdoc.runtime.registerAttribute(meta, 'deprecated', mcdoc.runtime.attribute.validator.optional(mcdoc.runtime.attribute.validator.string), {
-        mapField: (config, field, ctx) => {
-            if (config === undefined) {
-                return { ...field, deprecated: true };
-            }
-            if (!config.startsWith('1.')) {
-                ctx.logger.warn(`Invalid mcdoc attribute for "deprecated": ${config}`);
-                return field;
-            }
-            if (ReleaseVersion.cmp(release, config) >= 0) {
-                return { ...field, deprecated: true };
-            }
-            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'),
-            }));
-        },
-    });
+    registerMcdocAttributes(meta, release);
+    registerPackFormatAttribute(meta, release, versions, packs);
+    meta.registerLanguage('zip', { extensions: ['.zip'] });
+    meta.registerLanguage('png', { extensions: ['.png'] });
+    meta.registerLanguage('ogg', { extensions: ['.ogg'] });
+    meta.registerLanguage('ttf', { extensions: ['.ttf'] });
+    meta.registerLanguage('otf', { extensions: ['.otf'] });
+    meta.registerLanguage('fsh', { extensions: ['.fsh'] });
+    meta.registerLanguage('vsh', { extensions: ['.vsh'] });
     json.initialize(ctx);
     jeJson.initialize(ctx);
     jeMcf.initialize(ctx, summary.commands, release);

package/lib/mcdocAttributes.d.ts

@@ -0,0 +1,6 @@
+import * as core from '@spyglassmc/core';
+import type { McmetaVersions, PackInfo } from './dependency';
+import { ReleaseVersion } from './dependency';
+export declare function registerMcdocAttributes(meta: core.MetaRegistry, release: ReleaseVersion): void;
+export declare function registerPackFormatAttribute(meta: core.MetaRegistry, release: ReleaseVersion, versions: McmetaVersions, packs: PackInfo[]): void;
+//# sourceMappingURL=mcdocAttributes.d.ts.map

package/lib/mcdocAttributes.js

@@ -0,0 +1,89 @@
+import * as core from '@spyglassmc/core';
+import { localize } from '@spyglassmc/locales';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { NEXT_RELEASE_VERSION, ReleaseVersion } from './dependency';
+export function registerMcdocAttributes(meta, release) {
+    mcdoc.runtime.registerAttribute(meta, 'since', mcdoc.runtime.attribute.validator.string, {
+        filterElement: (config, ctx) => {
+            if (!config.startsWith('1.')) {
+                ctx.logger.warn(`Invalid mcdoc attribute for "since": ${config}`);
+                return true;
+            }
+            return ReleaseVersion.cmp(release, config) >= 0;
+        },
+    });
+    mcdoc.runtime.registerAttribute(meta, 'until', mcdoc.runtime.attribute.validator.string, {
+        filterElement: (config, ctx) => {
+            if (!config.startsWith('1.')) {
+                ctx.logger.warn(`Invalid mcdoc attribute for "until": ${config}`);
+                return true;
+            }
+            return ReleaseVersion.cmp(release, config) < 0;
+        },
+    });
+    mcdoc.runtime.registerAttribute(meta, 'deprecated', mcdoc.runtime.attribute.validator.optional(mcdoc.runtime.attribute.validator.string), {
+        mapField: (config, field, ctx) => {
+            if (config === undefined) {
+                return { ...field, deprecated: true };
+            }
+            if (!config.startsWith('1.')) {
+                ctx.logger.warn(`Invalid mcdoc attribute for "deprecated": ${config}`);
+                return field;
+            }
+            if (ReleaseVersion.cmp(release, config) >= 0) {
+                return { ...field, deprecated: true };
+            }
+            return field;
+        },
+    });
+}
+export function registerPackFormatAttribute(meta, release, versions, packs) {
+    const dataFormats = new Map();
+    const assetsFormats = new Map();
+    if (versions[0]?.type !== 'release') {
+        dataFormats.set(versions[0].data_pack_version, [NEXT_RELEASE_VERSION]);
+        assetsFormats.set(versions[0].resource_pack_version, [NEXT_RELEASE_VERSION]);
+    }
+    for (const version of versions) {
+        if (version.type === 'release') {
+            dataFormats.set(version.data_pack_version, [
+                ...dataFormats.get(version.data_pack_version) ?? [],
+                version.id,
+            ]);
+            assetsFormats.set(version.resource_pack_version, [
+                ...assetsFormats.get(version.resource_pack_version) ?? [],
+                version.id,
+            ]);
+        }
+    }
+    function getFormats(packMcmetaUri) {
+        const thisPack = packs.find(p => core.fileUtil.isSubUriOf(packMcmetaUri, p.packRoot));
+        return thisPack?.type === 'assets' ? assetsFormats : dataFormats;
+    }
+    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 targetVersions = getFormats(ctx.doc.uri).get(target);
+                if (!targetVersions) {
+                    ctx.err.report(localize('java-edition.pack-format.unsupported', target), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+                else if (!targetVersions.some(v => v === release)) {
+                    ctx.err.report(localize('java-edition.pack-format.not-loaded', target, release), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+            };
+        },
+        numericCompleter: (_, ctx) => {
+            return [...getFormats(ctx.doc.uri).entries()].map(([k, v], i) => ({
+                range: core.Range.create(ctx.offset),
+                label: `${k}`,
+                labelSuffix: ` (${v[0]})`,
+                sortText: `${i}`.padStart(4, '0'),
+            }));
+        },
+    });
+}
+//# sourceMappingURL=mcdocAttributes.js.map

package/lib/mcfunction/checker/index.js

@@ -131,17 +131,17 @@ const itemStack = (node, ctx) => {
         return;
     }
     const groupedComponents = new Map();
-    for (const pair of node.components.children) {
-        if (!pair.key) {
+    for (const child of node.components.children) {
+        if (!child.key) {
             continue;
         }
-        const componentId = core.ResourceLocationNode.toString(pair.key, 'full');
+        const componentId = core.ResourceLocationNode.toString(child.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);
+        groupedComponents.get(componentId).push(child.key);
+        if (child.type === 'mcfunction:component' && child.value) {
+            nbt.checker.index('minecraft:data_component', componentId)(child.value, ctx);
         }
     }
     for (const [_, group] of groupedComponents) {
@@ -269,16 +269,13 @@ const particle = (node, ctx) => {
         return;
     }
     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));
-        }
+    if (options) {
+        // Even if particle isn't explicitly marked as requiring options,
+        // run the type checker anyways to allow an empty compound
+        nbt.checker.index('minecraft:particle', core.ResourceLocation.lengthen(id))(options, ctx);
     }
-    else if (options) {
-        ctx.err.report(localize('expected', localize('nothing')), options);
+    else if (ParticleNode.requiresOptions(id)) {
+        ctx.err.report(localize('expected', localize('nbt.node.compound')), core.Range.create(node.id.range.end, node.id.range.end + 1));
     }
 };
 // #endregion

package/lib/mcfunction/completer/argument.js

@@ -1,4 +1,4 @@
-import { AstNode, BooleanNode, BrigadierStringOptions, completer, CompletionItem, FloatNode, getStates, InsertTextBuilder, IntegerNode, LiteralNode, Range, ResourceLocation, ResourceLocationNode, StringNode, SymbolNode, } from '@spyglassmc/core';
+import { AstNode, binarySearch, BooleanNode, BrigadierStringOptions, completer, CompletionItem, FloatNode, getStates, InsertTextBuilder, IntegerNode, LiteralNode, Range, ResourceLocation, ResourceLocationNode, StringNode, SymbolNode, } from '@spyglassmc/core';
 import * as json from '@spyglassmc/json';
 import { localeQuote, localize } from '@spyglassmc/locales';
 import { getTagValues } from '../../common/index.js';
@@ -183,19 +183,32 @@ const blockStates = (node, ctx) => {
     })(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);
+    if (!Range.contains(Range.translate(node, 1, -1), ctx.offset, true)) {
+        return [];
+    }
+    const completeKey = (key) => {
+        const id = key
+            ?? ResourceLocationNode.mock(key ?? ctx.offset, { category: 'data_component_type' });
+        return completer.resourceLocation(id, ctx);
+    };
+    const index = binarySearch(node.children, ctx.offset, (n, o) => Range.compareOffset(n.range, o, true));
+    const child = index >= 0 ? node.children[index] : undefined;
+    if (!child) {
+        return [
+            ...completer.literal(LiteralNode.mock(ctx.offset, { pool: ['!'] }), ctx),
+            ...completeKey(undefined),
+        ];
+    }
+    if (child.type === 'mcfunction:component_removal') {
+        return completeKey(child.key);
+    }
+    if ((child.key && Range.contains(child.key, ctx.offset, true))) {
+        return completeKey(child.key);
+    }
+    if (child.value && Range.contains(child.value, ctx.offset, true)) {
+        return completer.dispatch(child.value, ctx);
+    }
+    return [];
 };
 const componentTests = (node, ctx) => {
     // TODO: improve this completer

package/lib/mcfunction/mcdocAttributes.js

@@ -57,7 +57,7 @@ export function registerMcdocAttributes(meta, rootTreeNode) {
         stringMocker: (_, __, ctx) => ScoreHolderNode.mock(ctx.offset),
     });
     mcdoc.runtime.registerAttribute(meta, 'tag', () => undefined, {
-        stringParser: () => parser.tag('definition'), // TODO: make this a config
+        stringParser: () => parser.tag('reference'),
         stringMocker: (_, __, ctx) => core.SymbolNode.mock(ctx.offset, { category: 'tag' }),
     });
     mcdoc.runtime.registerAttribute(meta, 'block_predicate', () => undefined, {

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

@@ -86,7 +86,7 @@ export interface EntitySelectorNode extends core.AstNode {
 export declare namespace EntitySelectorNode {
     function is<T extends core.DeepReadonly<core.AstNode> | undefined>(node: T): node is core.InheritReadonly<EntitySelectorNode, T>;
     function mock(range: core.RangeLike, options: core.LiteralOptions): EntitySelectorNode;
-    const ArgumentKeys: Set<"tag" | "team" | "predicate" | "type" | "level" | "advancements" | "nbt" | "sort" | "distance" | "gamemode" | "limit" | "name" | "scores" | "x" | "y" | "z" | "dx" | "dy" | "dz" | "x_rotation" | "y_rotation">;
+    const ArgumentKeys: Set<"tag" | "team" | "predicate" | "type" | "level" | "sort" | "advancements" | "nbt" | "distance" | "gamemode" | "limit" | "name" | "scores" | "x" | "y" | "z" | "dx" | "dy" | "dz" | "x_rotation" | "y_rotation">;
     type ArgumentKey = typeof ArgumentKeys extends Set<infer T> ? T : undefined;
     const enum Result {
         Ok = 0,
@@ -123,11 +123,29 @@ export declare namespace ItemStackNode {
 }
 export interface ComponentListNode extends core.AstNode {
     type: 'mcfunction:component_list';
-    children: core.PairNode<core.ResourceLocationNode, nbt.NbtNode>[];
+    children: (ComponentNode | ComponentRemovalNode)[];
 }
 export declare namespace ComponentListNode {
     function is(node: core.AstNode): node is ComponentListNode;
 }
+export interface ComponentNode extends core.AstNode {
+    type: 'mcfunction:component';
+    children: (core.ResourceLocationNode | nbt.NbtNode)[];
+    key: core.ResourceLocationNode;
+    value?: nbt.NbtNode;
+}
+export declare namespace ComponentNode {
+    function is(node: core.AstNode): node is ComponentNode;
+}
+export interface ComponentRemovalNode extends core.AstNode {
+    type: 'mcfunction:component_removal';
+    children: (core.LiteralNode | core.ResourceLocationNode)[];
+    prefix: core.LiteralNode;
+    key: core.ResourceLocationNode;
+}
+export declare namespace ComponentRemovalNode {
+    function is(node: core.AstNode): node is ComponentRemovalNode;
+}
 export interface ItemPredicateNode extends core.AstNode {
     type: 'mcfunction:item_predicate';
     children: (core.ResourceLocationNode | core.LiteralNode | ComponentTestsNode | nbt.NbtCompoundNode)[];
@@ -233,7 +251,7 @@ export interface ObjectiveCriteriaNode extends core.AstNode {
 }
 export declare namespace ObjectiveCriteriaNode {
     const SimpleValues: string[];
-    const ComplexCategories: Map<string, "block" | "fluid" | "instrument" | "activity" | "armor_material" | "attribute" | "block_entity_type" | "block_predicate_type" | "block_type" | "cat_variant" | "chunk_status" | "command_argument_type" | "creative_mode_tab" | "custom_stat" | "data_component_type" | "decorated_pot_pattern" | "enchantment_effect_component_type" | "enchantment_entity_effect_type" | "enchantment_level_based_value_type" | "enchantment_location_based_effect_type" | "enchantment_provider_type" | "enchantment_value_effect_type" | "entity_sub_predicate_type" | "entity_type" | "float_provider_type" | "frog_variant" | "game_event" | "height_provider_type" | "int_provider_type" | "item" | "item_sub_predicate_type" | "loot_condition_type" | "loot_function_type" | "loot_nbt_provider_type" | "loot_number_provider_type" | "loot_pool_entry_type" | "loot_score_provider_type" | "map_decoration_type" | "memory_module_type" | "menu" | "mob_effect" | "motive" | "number_format_type" | "particle_type" | "point_of_interest_type" | "pos_rule_test" | "position_source_type" | "potion" | "recipe_serializer" | "recipe_type" | "rule_block_entity_modifier" | "rule_test" | "schedule" | "sensor_type" | "sound_event" | "stat_type" | "trigger_type" | "villager_profession" | "villager_type" | "worldgen/biome_source" | "worldgen/block_placer_type" | "worldgen/block_state_provider_type" | "worldgen/carver" | "worldgen/chunk_generator" | "worldgen/decorator" | "worldgen/density_function_type" | "worldgen/feature" | "worldgen/feature_size_type" | "worldgen/foliage_placer_type" | "worldgen/material_condition" | "worldgen/material_rule" | "worldgen/placement_modifier_type" | "worldgen/pool_alias_binding" | "worldgen/root_placer_type" | "worldgen/structure_feature" | "worldgen/structure_piece" | "worldgen/structure_placement" | "worldgen/structure_pool_element" | "worldgen/structure_processor" | "worldgen/structure_type" | "worldgen/surface_builder" | "worldgen/tree_decorator_type" | "worldgen/trunk_placer_type">;
+    const ComplexCategories: Map<string, "block" | "fluid" | "instrument" | "activity" | "armor_material" | "attribute" | "block_entity_type" | "block_predicate_type" | "block_type" | "cat_variant" | "chunk_status" | "command_argument_type" | "consume_effect_type" | "creative_mode_tab" | "custom_stat" | "data_component_type" | "decorated_pot_pattern" | "decorated_pot_patterns" | "enchantment_effect_component_type" | "enchantment_entity_effect_type" | "enchantment_level_based_value_type" | "enchantment_location_based_effect_type" | "enchantment_provider_type" | "enchantment_value_effect_type" | "entity_sub_predicate_type" | "entity_type" | "float_provider_type" | "frog_variant" | "game_event" | "height_provider_type" | "int_provider_type" | "item" | "item_sub_predicate_type" | "loot_condition_type" | "loot_function_type" | "loot_nbt_provider_type" | "loot_number_provider_type" | "loot_pool_entry_type" | "loot_score_provider_type" | "map_decoration_type" | "memory_module_type" | "menu" | "mob_effect" | "motive" | "number_format_type" | "particle_type" | "point_of_interest_type" | "pos_rule_test" | "position_source_type" | "potion" | "recipe_book_category" | "recipe_display" | "recipe_serializer" | "recipe_type" | "rule_block_entity_modifier" | "rule_test" | "schedule" | "sensor_type" | "slot_display" | "sound_event" | "stat_type" | "trigger_type" | "villager_profession" | "villager_type" | "worldgen/biome_source" | "worldgen/block_placer_type" | "worldgen/block_state_provider_type" | "worldgen/carver" | "worldgen/chunk_generator" | "worldgen/decorator" | "worldgen/density_function_type" | "worldgen/feature" | "worldgen/feature_size_type" | "worldgen/foliage_placer_type" | "worldgen/material_condition" | "worldgen/material_rule" | "worldgen/placement_modifier_type" | "worldgen/pool_alias_binding" | "worldgen/root_placer_type" | "worldgen/structure_feature" | "worldgen/structure_piece" | "worldgen/structure_placement" | "worldgen/structure_pool_element" | "worldgen/structure_processor" | "worldgen/structure_type" | "worldgen/surface_builder" | "worldgen/tree_decorator_type" | "worldgen/trunk_placer_type">;
     const ComplexSep = ":";
     function mock(range: core.RangeLike): ObjectiveCriteriaNode;
 }
@@ -254,9 +272,10 @@ export declare namespace ParticleNode {
 }
 export interface ScoreHolderNode extends core.AstNode {
     type: 'mcfunction:score_holder';
-    children: [core.SymbolNode | EntitySelectorNode];
+    children: [core.LiteralNode | core.SymbolNode | EntitySelectorNode];
     fakeName?: core.SymbolNode;
     selector?: EntitySelectorNode;
+    wildcard?: core.LiteralNode;
 }
 export declare namespace ScoreHolderNode {
     function mock(range: core.RangeLike): ScoreHolderNode;

package/lib/mcfunction/node/argument.js

@@ -181,6 +181,20 @@ export var ComponentListNode;
     }
     ComponentListNode.is = is;
 })(ComponentListNode || (ComponentListNode = {}));
+export var ComponentNode;
+(function (ComponentNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component';
+    }
+    ComponentNode.is = is;
+})(ComponentNode || (ComponentNode = {}));
+export var ComponentRemovalNode;
+(function (ComponentRemovalNode) {
+    function is(node) {
+        return node.type === 'mcfunction:component_removal';
+    }
+    ComponentRemovalNode.is = is;
+})(ComponentRemovalNode || (ComponentRemovalNode = {}));
 export var ItemPredicateNode;
 (function (ItemPredicateNode) {
     function is(node) {
@@ -327,8 +341,10 @@ export var ParticleNode;
     // since 1.20.5
     const OptionTypes = new Set([
         ...SpecialTypes,
+        'block_crumble',
         'dust_pillar',
         'entity_effect',
+        'trail',
     ]);
     function requiresOptions(type) {
         return OptionTypes.has(type);