@spyglassmc/java-edition 0.3.1 → 0.3.3

package/lib/json/checker/data/text_component.js

@@ -1,6 +1,6 @@
 import { integer } from '@spyglassmc/core';
-import { any, as, boolean, dispatch, extract, having, int, listOf, literal, opt, pick, record, ref, resource, simpleString, string } from '@spyglassmc/json/lib/checker/primitives/index.js';
-import { deprecated, nbt, nbtPath, stringColor, uuid, versioned } from '../util/index.js';
+import { any, as, boolean, dispatch, extract, having, int, listOf, literal, opt, pick, record, ref, resource, simpleString, string, } from '@spyglassmc/json/lib/checker/primitives/index.js';
+import { deprecated, nbt, nbtPath, stringColor, uuid, versioned, } from '../util/index.js';
 const Keybinds = [
     'key.jump',
     'key.sneak',
@@ -69,11 +69,15 @@ const text_component_object = as('text_component', (node, ctx) => record({
                 },
                 entity: {
                     entity: simpleString,
-                    nbt: nbtPath({ registry: 'entity_type' /* FIXME: import { getTypesFromEntity } from '../../../../mcfunction/checker'; ids: getTypesFromEntity(somehowGetTheNodeHere, ctx) */ }),
+                    nbt: nbtPath({
+                        registry: 'entity_type', /* FIXME: import { getTypesFromEntity } from '../../../../mcfunction/checker'; ids: getTypesFromEntity(somehowGetTheNodeHere, ctx) */
+                    }),
                 },
                 storage: {
                     storage: resource('storage'),
-                    nbt: nbtPath({ registry: 'storage' /* FIXME:, id: extract('storage', props) */ }),
+                    nbt: nbtPath({
+                        registry: 'storage', /* FIXME:, id: extract('storage', props) */
+                    }),
                 },
             }),
             interpret: opt(boolean, false),
@@ -89,7 +93,14 @@ const text_component_object = as('text_component', (node, ctx) => record({
     obfuscated: opt(boolean),
     insertion: opt(simpleString),
     clickEvent: opt(dispatch('action', (action) => record({
-        action: literal(['open_url', 'open_file', 'run_command', 'suggest_command', 'change_page', 'copy_to_clipboard']),
+        action: literal([
+            'open_url',
+            'open_file',
+            'run_command',
+            'suggest_command',
+            'change_page',
+            'copy_to_clipboard',
+        ]),
         value: simpleString,
         ...pick(action, {
             run_command: {
@@ -108,11 +119,16 @@ const text_component_object = as('text_component', (node, ctx) => record({
                 contents: opt(versioned(ctx, '1.16', text_component)),
             },
             show_item: {
-                value: deprecated(ctx, '1.16', nbt({ definition: '::minecraft::util::invitem::InventoryItem' })),
-                contents: opt(versioned(ctx, '1.16', dispatch(props => record({
+                value: deprecated(ctx, '1.16', nbt({
+                    definition: '::minecraft::util::invitem::InventoryItem',
+                })),
+                contents: opt(versioned(ctx, '1.16', dispatch((props) => record({
                     id: resource('item'),
                     count: opt(int),
-                    tag: opt(nbt({ registry: 'item', id: extract('id', props) })),
+                    tag: opt(nbt({
+                        registry: 'item',
+                        id: extract('id', props),
+                    })),
                 })))),
             },
             show_entity: {

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

@@ -1,5 +1,12 @@
-import type { Checker, MetaRegistry } from '@spyglassmc/core';
+import * as core from '@spyglassmc/core';
 import type { JsonNode } from '@spyglassmc/json';
-export declare const entry: Checker<JsonNode>;
-export declare function register(meta: MetaRegistry): void;
+import * as mcdoc from '@spyglassmc/mcdoc';
+export declare const entry: core.Checker<JsonNode>;
+export declare function register(meta: core.MetaRegistry): void;
+/**
+ * @param identifier An identifier of mcdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
+ */
+export declare function definition(identifier: `::${string}::${string}`): core.SyncChecker<JsonNode>;
+export declare function object(typeDef: mcdoc.StructType): core.SyncChecker<JsonNode>;
+export declare function fieldValue(type: mcdoc.McdocType): core.SyncChecker<JsonNode>;
 //# sourceMappingURL=index.d.ts.map

package/lib/json/checker/index.js

@@ -1,12 +1,62 @@
+import * as core from '@spyglassmc/core';
+import { JsonObjectNode } from '@spyglassmc/json';
+import { localeQuote, localize } from '@spyglassmc/locales';
+import * as mcdoc from '@spyglassmc/mcdoc';
 import { dissectUri } from '../../binder/index.js';
-import { Checkers, pack_mcmeta } from './data/index.js';
+const Checkers = new Map([
+    ['advancement', '::java::data::advancement::Advancement'],
+    ['dimension', '::java::data::worldgen::dimension::Dimension'],
+    ['dimension_type', '::java::data::worldgen::dimension::DimensionType'],
+    ['item_modifier', '::java::data::item_modifier::ItemModifier'],
+    ['loot_table', '::java::data::loot::LootTable'],
+    ['predicate', '::java::data::predicate::Predicate'],
+    ['recipe', '::java::data::recipe::Recipe'],
+    ['worldgen/biome', '::java::data::worldgen::biome::Biome'],
+    [
+        'worldgen/configured_carver',
+        '::java::data::worldgen::carver::ConfiguredCarver',
+    ],
+    [
+        'worldgen/configured_surface_builder',
+        '::java::data::worldgen::surface_builder::ConfiguredSurfaceBuilder',
+    ],
+    ['worldgen/configured_feature', '::java::data::feature::ConfiguredFeature'],
+    [
+        'worldgen/configured_structure_feature',
+        '::java::data::worldgen::structure::Structure',
+    ],
+    [
+        'worldgen/density_function',
+        '::java::data::worldgen::density_function::DensityFunction',
+    ],
+    [
+        'worldgen/noise',
+        '::java::data::worldgen::dimension::biome_source::NoiseParameters',
+    ],
+    [
+        'worldgen/noise_settings',
+        '::java::data::worldgen::noise_settings::NoiseGeneratorSettings',
+    ],
+    [
+        'worldgen/processor_list',
+        '::java::data::worldgen::processor_list::ProcessorList',
+    ],
+    [
+        'worldgen/template_pool',
+        '::java::data::worldgen::template_pool::TemplatePool',
+    ],
+]);
 export const entry = (node, ctx) => {
     const parts = dissectUri(ctx.doc.uri, ctx);
     if (parts && Checkers.has(parts.category)) {
-        Checkers.get(parts.category)(node, { ...ctx, context: '' });
+        const identifier = Checkers.get(parts.category);
+        return definition(identifier)(node, ctx);
+    }
+    else if (parts?.category.startsWith('tag/')) {
+        // TODO
     }
     else if (ctx.doc.uri.endsWith('/pack.mcmeta')) {
-        pack_mcmeta(node, { ...ctx, context: '' });
+        return definition('::java::Pack')(node, ctx);
     }
     else {
         return;
@@ -20,4 +70,182 @@ export function register(meta) {
     meta.registerChecker('json:object', entry);
     meta.registerChecker('json:string', entry);
 }
+/**
+ * @param identifier An identifier of mcdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
+ */
+export function definition(identifier) {
+    return (node, ctx) => {
+        const symbol = ctx.symbols.query(ctx.doc, 'mcdoc', identifier);
+        const typeDef = symbol.getData(mcdoc.binder.TypeDefSymbolData.is)?.typeDef;
+        if (!typeDef) {
+            return;
+        }
+        switch (typeDef.kind) {
+            case 'struct':
+                object(typeDef)(node, ctx);
+                break;
+            default:
+                ctx.logger.error(`[json.checker.definition] Expected a struct type, but got ${typeDef.kind}`);
+        }
+    };
+}
+export function object(typeDef) {
+    return (node, ctx) => {
+        if (!JsonObjectNode.is(node)) {
+            // TODO
+            return;
+        }
+        for (const { key: keyNode, value: valueNode } of node.children) {
+            if (!keyNode || !valueNode) {
+                continue;
+            }
+            const key = keyNode.value;
+            // TODO: handle spread types
+            const fieldDef = typeDef.fields.find((p) => p.kind === 'pair' && p.key === key);
+            if (fieldDef) {
+                // TODO: enter a reference to the mcdoc key
+                fieldValue(fieldDef.type)(valueNode, ctx);
+            }
+            else {
+                ctx.err.report(localize('unknown-key', localeQuote(key)), keyNode, 2 /* core.ErrorSeverity.Warning */);
+            }
+        }
+        // TODO: check for required fields
+    };
+}
+export function fieldValue(type) {
+    const isInRange = (value, { kind, min = -Infinity, max = Infinity }) => {
+        const comparator = (a, b, exclusive) => exclusive ? a < b : a <= b;
+        return (comparator(min, value, kind & 0b10) &&
+            comparator(value, max, kind & 0b01));
+    };
+    const ExpectedTypes = {
+        boolean: 'json:boolean',
+        byte: 'json:number',
+        byte_array: 'json:array',
+        double: 'json:number',
+        float: 'json:number',
+        int: 'json:number',
+        int_array: 'json:array',
+        list: 'json:array',
+        long: 'json:number',
+        long_array: 'json:array',
+        short: 'json:number',
+        string: 'json:string',
+        struct: 'json:object',
+        tuple: 'json:array',
+    };
+    return (node, ctx) => {
+        // Rough type check.
+        if (type.kind !== 'any' &&
+            type.kind !== 'dispatcher' &&
+            type.kind !== 'enum' &&
+            type.kind !== 'literal' &&
+            type.kind !== 'reference' &&
+            type.kind !== 'union' &&
+            type.kind !== 'attributed' &&
+            type.kind !== 'unsafe' &&
+            type.kind !== 'concrete' &&
+            type.kind !== 'indexed' &&
+            type.kind !== 'template' &&
+            node.type !== ExpectedTypes[type.kind]) {
+            ctx.err.report(localize('expected', localizeTag(ExpectedTypes[type.kind])), node, 2 /* core.ErrorSeverity.Warning */);
+            return;
+        }
+        switch (type.kind) {
+            case 'boolean':
+                break;
+            case 'byte_array':
+            case 'int_array':
+            case 'long_array':
+                node = node;
+                if (type.lengthRange &&
+                    !isInRange(node.children.length, type.lengthRange)) {
+                    ctx.err.report(localize('expected', localize('json.checker.array.length-between', localizeTag(node.type), type.lengthRange.min ?? '-∞', type.lengthRange.max ?? '+∞')), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+                if (type.valueRange) {
+                    for (const { value: childNode } of node.children) {
+                        if (childNode?.type !== 'json:number') {
+                            ctx.err.report(localize('expected', localizeTag('json:number')), node, 2 /* core.ErrorSeverity.Warning */);
+                        }
+                        else if (childNode &&
+                            !isInRange(Number(childNode.value), type.valueRange)) {
+                            ctx.err.report(localize('number.between', type.valueRange.min ?? '-∞', type.valueRange.max ?? '+∞'), node, 2 /* core.ErrorSeverity.Warning */);
+                        }
+                    }
+                }
+                break;
+            case 'byte':
+            case 'short':
+            case 'int':
+            case 'long':
+            case 'float':
+            case 'double':
+                node = node;
+                if (type.valueRange &&
+                    !isInRange(Number(node.value), type.valueRange)) {
+                    ctx.err.report(localize('number.between', type.valueRange.min ?? '-∞', type.valueRange.max ?? '+∞'), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+                break;
+            case 'dispatcher':
+                node = node;
+                // const id = resolveFieldPath(node.parent?.parent, type.index.path)
+                // if (type.index.registry) {
+                // 	if (ExtendableRootRegistry.is(type.index.registry)) {
+                // 		index(type.index.registry, id ? core.ResourceLocation.lengthen(id) : undefined, options)(node, ctx)
+                // 	} else if (id) {
+                // 		index(type.index.registry, core.ResourceLocation.lengthen(id), options)(node, ctx)
+                // 	}
+                // }
+                break;
+            case 'list':
+                node = node;
+                type = mcdoc.simplifyListType(type);
+                if (type.lengthRange &&
+                    !isInRange(node.children.length, type.lengthRange)) {
+                    ctx.err.report(localize('expected', localize('json.checker.collection.length-between', localizeTag(node.type), type.lengthRange.min ?? '-∞', type.lengthRange.max ?? '+∞')), node, 2 /* core.ErrorSeverity.Warning */);
+                }
+                for (const { value: childNode } of node.children) {
+                    if (childNode) {
+                        fieldValue(type.item)(childNode, ctx);
+                    }
+                }
+                break;
+            case 'struct':
+                node = node;
+                object(type)(node, ctx);
+                break;
+            case 'string':
+                break;
+            case 'reference':
+                // node = node as JsonObjectNode
+                // if (type.symbol) {
+                // 	const { allowUnknownKey, value } = resolveSymbolPaths([type.symbol], ctx, node)
+                // 	compound(value, { ...options, allowUnknownKey: options.allowUnknownKey || allowUnknownKey })(node, ctx)
+                // }
+                break;
+            case 'union':
+                type = mcdoc.flattenUnionType(type);
+                if (type.members.length === 0) {
+                    ctx.err.report(localize('json.checker.object.field.union-empty-members'), core.PairNode.is(node.parent)
+                        ? node.parent.key ?? node.parent
+                        : node, 2 /* core.ErrorSeverity.Warning */);
+                }
+                else {
+                    ;
+                    core.checker.any(type.members.map((t) => fieldValue(t)))(node, ctx);
+                }
+                break;
+            case 'attributed':
+                // TODO: don't just ignore the attribute
+                fieldValue(type.child)(node, ctx);
+                break;
+        }
+    };
+}
+function localizeTag(type) {
+    const key = `json.node.${type.replace(/^json:/, '')}`;
+    const res = localize(key);
+    return res;
+}
 //# sourceMappingURL=index.js.map

package/lib/json/checker/util/advancement.js

@@ -7,9 +7,10 @@ export function criterionReference(advancement) {
             return;
         }
         const criteria = Object.values(ctx.symbols.query(ctx.doc, 'advancement', advancement).symbol
-            ?.members ?? {})
+            ?.members ??
+            {})
             .filter((m) => m?.subcategory === 'criterion')
-            .map(s => s.identifier);
+            .map((s) => s.identifier);
         literal(criteria)(node, ctx);
     };
 }

package/lib/json/checker/util/block_states.d.ts

@@ -7,7 +7,7 @@ interface Options {
     mixedTypes?: boolean;
     requireAll?: boolean;
 }
-export declare function blockStateMap({ category, id, ids, tag, mixedTypes, requireAll }: Options): JsonChecker;
-export declare function blockStateList({ category, id, ids, tag }: Options): JsonChecker;
+export declare function blockStateMap({ category, id, ids, tag, mixedTypes, requireAll, }: Options): JsonChecker;
+export declare function blockStateList({ category, id, ids, tag, }: Options): JsonChecker;
 export {};
 //# sourceMappingURL=block_states.d.ts.map

package/lib/json/checker/util/block_states.js

@@ -1,7 +1,7 @@
 import * as core from '@spyglassmc/core';
-import { any, boolean, intRange, listOf, literal, object, opt, record, simpleString } from '@spyglassmc/json/lib/checker/index.js';
+import { any, boolean, intRange, listOf, literal, object, opt, record, simpleString, } from '@spyglassmc/json/lib/checker/index.js';
 import { getTagValues } from '../../../common/index.js';
-export function blockStateMap({ category, id, ids, tag, mixedTypes, requireAll }) {
+export function blockStateMap({ category, id, ids, tag, mixedTypes, requireAll, }) {
     return (node, ctx) => {
         if (tag) {
             ids = getTagValues(`tag/${category ?? 'block'}`, tag, ctx);
@@ -11,8 +11,10 @@ export function blockStateMap({ category, id, ids, tag, mixedTypes, requireAll }
         }
         // FIXME: Temporary solution to make tests pass when ensureBindingStarted is not given.
         if (!ids?.length || !ctx.ensureBindingStarted) {
-            const values = mixedTypes ? any([boolean, simpleString, intBounds()]) : simpleString;
-            object(simpleString, () => requireAll ? values : opt(values))(node, ctx);
+            const values = mixedTypes
+                ? any([boolean, simpleString, intBounds()])
+                : simpleString;
+            object(simpleString, () => (requireAll ? values : opt(values)))(node, ctx);
             return;
         }
         const states = core.getStates(category ?? 'block', ids, ctx);
@@ -32,7 +34,7 @@ export function blockStateMap({ category, id, ids, tag, mixedTypes, requireAll }
         })(node, ctx);
     };
 }
-export function blockStateList({ category, id, ids, tag }) {
+export function blockStateList({ category, id, ids, tag, }) {
     return (node, ctx) => {
         if (tag) {
             ids = getTagValues(`tag/${category ?? 'block'}`, tag, ctx);

package/lib/json/checker/util/color.js

@@ -1,4 +1,4 @@
-import { Color, ColorFormat, Failure, parseStringValue, Range } from '@spyglassmc/core';
+import { Color, ColorFormat, Failure, parseStringValue, Range, } from '@spyglassmc/core';
 import { JsonNumberNode, JsonStringNode } from '@spyglassmc/json';
 import { localize } from '@spyglassmc/locales';
 export function stringColor() {
@@ -27,7 +27,13 @@ export function stringColor() {
         return Color.fromCompositeInt(value);
     };
     return (node, ctx) => {
-        node.expectation = [{ type: 'json:string', typedoc: 'String("Color")', pool: Color.ColorNames }];
+        node.expectation = [
+            {
+                type: 'json:string',
+                typedoc: 'String("Color")',
+                pool: Color.ColorNames,
+            },
+        ];
         if (!JsonStringNode.is(node)) {
             ctx.err.report(localize('expected', localize('string')), node);
         }

package/lib/json/checker/util/nbt.d.ts

@@ -9,7 +9,7 @@ interface RegistryOptions {
     ids?: readonly string[] | undefined;
     tag?: string | undefined;
 }
-declare type Options = DefinitionOptions | RegistryOptions;
+type Options = DefinitionOptions | RegistryOptions;
 export declare function nbt(options: Options): JsonChecker;
 export declare function nbtPath(options: RegistryOptions): JsonChecker;
 export {};

package/lib/json/checker/util/nbt.js

@@ -53,9 +53,11 @@ export function nbtPath(options) {
 }
 function getIds({ registry, id, idOrTag, ids, tag }, ctx) {
     if (idOrTag) {
-        idOrTag.startsWith('#') ? tag = idOrTag.slice(1) : id = idOrTag;
+        idOrTag.startsWith('#') ? (tag = idOrTag.slice(1)) : (id = idOrTag);
     }
-    if (tag && (registry === 'block' || registry === 'item' || registry === 'entity_type')) {
+    if (tag &&
+        (registry === 'block' || registry === 'item' ||
+            registry === 'entity_type')) {
         ids = getTagValues(`tag/${registry}`, tag, ctx);
     }
     else if (id) {

package/lib/json/checker/util/recipe.js

@@ -2,11 +2,12 @@ import { symbol } from '@spyglassmc/core';
 import { string } from '@spyglassmc/json/lib/checker/index.js';
 export const recipeGroup = string('recipe_group', symbol('recipe_group'));
 export function patternKeys(props) {
-    return [...new Set((props
-            .find(p => p.key?.value === 'pattern' && p.value?.type === 'json:array')?.value?.children ?? [])
-            .map(n => n.value)
-            .filter(n => n && n.type === 'json:string')
-            .flatMap(n => [...n.value])
-            .filter(v => v !== ' '))];
+    return [
+        ...new Set((props.find((p) => p.key?.value === 'pattern' && p.value?.type === 'json:array')?.value?.children ?? [])
+            .map((n) => n.value)
+            .filter((n) => n && n.type === 'json:string')
+            .flatMap((n) => [...n.value])
+            .filter((v) => v !== ' ')),
+    ];
 }
 //# sourceMappingURL=recipe.js.map

package/lib/json/checker/util/version.d.ts

@@ -1,6 +1,6 @@
 import type { JsonChecker, JsonCheckerContext, record } from '@spyglassmc/json/lib/checker/index.js';
 import { ReleaseVersion } from '../../../dependency/index.js';
-declare type CheckerRecord = Parameters<typeof record>[0];
+type CheckerRecord = Parameters<typeof record>[0];
 export declare function versioned(ctx: JsonCheckerContext, version: ReleaseVersion, checker: string[]): string[];
 export declare function versioned(ctx: JsonCheckerContext, version: ReleaseVersion, checker: JsonChecker | undefined): JsonChecker | undefined;
 export declare function versioned(ctx: JsonCheckerContext, version: ReleaseVersion, checker: CheckerRecord | undefined): CheckerRecord | undefined;

package/lib/json/checker/util/version.js

@@ -25,10 +25,10 @@ export function versioned(ctx, arg1, arg2, arg3) {
             return arg1;
         }
         else if (Array.isArray(arg1)) {
-            return check ? arg1 : (arg3 ?? []);
+            return check ? arg1 : arg3 ?? [];
         }
         else {
-            return check ? arg1 : (arg3 ?? undefined);
+            return check ? arg1 : arg3 ?? undefined;
         }
     }
 }

package/lib/mcfunction/checker/index.js

@@ -19,7 +19,7 @@ const getNode = (nodes, index) => {
     return nodes[index]?.children[0];
 };
 const rootCommand = (nodes, index, ctx) => {
-    for (const { children: [node] } of nodes) {
+    for (const { children: [node], } of nodes) {
         if (BlockNode.is(node)) {
             block(node, ctx);
         }
@@ -108,7 +108,8 @@ const rootCommand = (nodes, index, 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 ((getName(nodes, i) === 'if' || getName(nodes, i) === 'unless') &&
+                getName(nodes, i + 1) === 'data') {
                 // `if|unless data <$nbtPath$>`
                 nbtPath(nodes, i + 2, ctx);
                 i += 2;
@@ -123,7 +124,7 @@ const rootCommand = (nodes, index, ctx) => {
         summonNbt(nodes, index + 1, ctx);
     }
 };
-//#region Checkers for argument nodes
+// #region Checkers for argument nodes
 const block = (node, ctx) => {
     if (!node.nbt) {
         return;
@@ -131,7 +132,7 @@ const block = (node, ctx) => {
     nbt.checker.index('block', core.ResourceLocationNode.toString(node.id, 'full'))(node.nbt, ctx);
 };
 const entity = (node, ctx) => {
-    const nbtPair = node.selector?.arguments?.children.find(pair => pair.key?.value === 'nbt');
+    const nbtPair = node.selector?.arguments?.children.find((pair) => pair.key?.value === 'nbt');
     if (!nbtPair) {
         return;
     }
@@ -148,8 +149,8 @@ const item = (node, ctx) => {
 const particle = (node, ctx) => {
     core.checker.dispatchSync(node, ctx);
 };
-//#endregion
-//#region Checkers for command argument structure.
+// #endregion
+// #region Checkers for command argument structure.
 /**
  * - `block <targetPos: block_pos> <nbt: nbt_compound_tag>`
  * - `entity <target: entity> <nbt: nbt_compound_tag>`
@@ -177,7 +178,8 @@ const dataMergeTarget = (nodes, index, ctx) => {
         case 'storage': {
             const idNode = getNode(nodes, index + 1);
             const nbtNode = getNode(nodes, index + 2);
-            if (core.ResourceLocationNode.is(idNode) && nbt.NbtCompoundNode.is(nbtNode)) {
+            if (core.ResourceLocationNode.is(idNode) &&
+                nbt.NbtCompoundNode.is(nbtNode)) {
                 nbt.checker.index('storage', core.ResourceLocationNode.toString(idNode, 'full'))(nbtNode, ctx);
             }
             break;
@@ -224,11 +226,12 @@ const nbtPath = (nodes, index, ctx) => {
 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)) {
+    if (core.ResourceLocationNode.is(typeNode) &&
+        nbt.NbtCompoundNode.is(nbtNode)) {
         nbt.checker.index('entity_type', core.ResourceLocationNode.toString(typeNode, 'full'))(nbtNode, ctx);
     }
 };
-//#endregion
+// #endregion
 export const getTypesFromEntity = (entity, ctx) => {
     if (entity.playerName !== undefined || entity.selector?.playersOnly) {
         return ['minecraft:player'];
@@ -247,10 +250,10 @@ export const getTypesFromEntity = (entity, ctx) => {
             if (!valueNode || valueNode.inverted) {
                 continue;
             }
-            const value = core.ResourceLocationNode.toString(valueNode.value, 'full');
+            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));
+                types = types.filter((t) => tagValues.includes(t));
             }
             else {
                 types = [value];

package/lib/mcfunction/colorizer/index.js

@@ -1,8 +1,6 @@
 import * as core from '@spyglassmc/core';
-export const objectiveCriterion = node => [
-    core.ColorToken.create(node, 'type'),
-];
-export const vector = node => {
+export const objectiveCriterion = (node) => [core.ColorToken.create(node, 'type')];
+export const vector = (node) => {
     return [core.ColorToken.create(node, 'vector')];
 };
 export function register(meta) {

package/lib/mcfunction/common/index.js

@@ -2,24 +2,55 @@ import * as core from '@spyglassmc/core';
 export const ColorArgumentValues = [...core.Color.ColorNames, 'reset'];
 export const EntityAnchorArgumentValues = ['feet', 'eyes'];
 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',
+    ...[...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 OperationArgumentValues = ['=', '+=', '-=', '*=', '/=', '%=', '<', '>', '><'];
 export const ScoreboardSlotArgumentValues = [
-    'belowName', 'list', 'sidebar',
-    ...core.Color.ColorNames.map(n => `sidebar.team.${n}`),
+    'belowName',
+    'list',
+    'sidebar',
+    ...core.Color.ColorNames.map((n) => `sidebar.team.${n}`),
 ];
 export const SwizzleArgumentValues = [
-    'x', 'xy', 'xz', 'xyz', 'xzy',
-    'y', 'yx', 'yz', 'yxz', 'yzx',
-    'z', 'zx', 'zy', 'zxy', 'zyx',
+    'x',
+    'xy',
+    'xz',
+    'xyz',
+    'xzy',
+    'y',
+    'yx',
+    'yz',
+    'yxz',
+    'yzx',
+    'z',
+    'zx',
+    'zy',
+    'zxy',
+    'zyx',
 ];
 //# sourceMappingURL=index.js.map