@spyglassmc/nbt 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# `@spyglassmc/nbt`
+
+![banner](https://raw.githubusercontent.com/SpyglassMC/logo/main/banner.png)
+
+[![npm](https://img.shields.io/npm/v/@spyglassmc/nbt.svg?logo=npm&style=flat-square)](https://npmjs.com/package/@spyglassmc/nbt)
+
+This package contains parsers and processors for [stringified NBT][nbt-format].
+
+# Contributions
+
+## Languages
+
+- `nbt` language that is associated with the `.snbt` file extension.
+
+## AST Nodes
+
+## Processors
+
+[nbt-format]: https://minecraft.gamepedia.com/NBT_format

package/lib/checker/index.d.ts

@@ -0,0 +1,40 @@
+import * as core from '@spyglassmc/core';
+import * as nbtdoc from '@spyglassmc/nbtdoc';
+import type { NbtNode, NbtPathNode } from '../node';
+import { NbtCompoundNode, NbtPrimitiveNode } from '../node';
+interface Options {
+    allowUnknownKey?: boolean;
+    isPredicate?: boolean;
+}
+declare global {
+    interface ArrayConstructor {
+        isArray(arg: unknown): arg is unknown[] | readonly unknown[];
+    }
+}
+/**
+* @param id If the registry is under the `custom` namespace, `id` can only be a string. Otherwise it can be a string, string array, or `undefined`.
+* If set to `undefined` or an empty array, all nbtdoc compound definitions for this registry will be merged for checking, and unknown keys are allowed.
+*/
+export declare function index(registry: nbtdoc.ExtendableRootRegistry, id: core.FullResourceLocation | readonly core.FullResourceLocation[] | undefined, options?: Options): core.SyncChecker<NbtCompoundNode>;
+export declare function index(registry: nbtdoc.ResolvedRootRegistry, id: core.FullResourceLocation, options?: Options): core.SyncChecker<NbtCompoundNode>;
+/**
+ * @param identifier An identifier of nbtdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
+ */
+export declare function definition(identifier: `::${string}::${string}`, options?: Options): core.SyncChecker<NbtCompoundNode>;
+export declare function blockStates(blocks: string[], _options?: Options): core.SyncChecker<NbtCompoundNode>;
+/**
+ * @param path The {@link core.SymbolPath} to the compound definition.
+ */
+export declare function compound(data: ResolvedCompoundData, options?: Options): core.SyncChecker<NbtCompoundNode>;
+export declare function enum_(path: core.SymbolPath | undefined, _options?: Options): core.SyncChecker<NbtPrimitiveNode>;
+/**
+ * @param id If set to `undefined` or an empty array, all nbtdoc compound definitions for this registry will be merged for checking, and unknown keys are allowed.
+ */
+export declare function path(registry: nbtdoc.ExtendableRootRegistry, id: core.FullResourceLocation | readonly core.FullResourceLocation[] | undefined): core.SyncChecker<NbtPathNode>;
+export declare function fieldValue(type: nbtdoc.NbtdocType, options: Options): core.SyncChecker<NbtNode>;
+declare type ResolvedCompoundData = Record<string, {
+    data: nbtdoc.NbtdocType;
+    query?: core.SymbolQuery;
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/checker/index.js

@@ -0,0 +1,593 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldValue = exports.path = exports.enum_ = exports.compound = exports.blockStates = exports.definition = exports.index = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const nbtdoc = __importStar(require("@spyglassmc/nbtdoc"));
+const lib_1 = require("../../../locales/lib");
+const node_1 = require("../node");
+const util_1 = require("../util");
+const nbtdocUtil_1 = require("./nbtdocUtil");
+function index(registry, id, options = {}) {
+    switch (registry) {
+        case 'custom:blockitemstates':
+            const blockIds = (0, nbtdocUtil_1.getBlocksFromItem)(id);
+            return blockIds
+                ? blockStates(blockIds, options)
+                : core.checker.noop;
+        case 'custom:blockstates':
+            return blockStates([id], options);
+        case 'custom:spawnitemtag':
+            const entityId = (0, nbtdocUtil_1.getEntityFromItem)(id);
+            return entityId
+                ? index('entity_type', entityId, options)
+                : core.checker.noop;
+        default:
+            return (node, ctx) => {
+                const { allowUnknownKey, value } = resolveRootRegistry(registry, id, ctx, node);
+                options.allowUnknownKey || (options.allowUnknownKey = allowUnknownKey);
+                compound(value, options)(node, ctx);
+            };
+    }
+}
+exports.index = index;
+/**
+ * @param identifier An identifier of nbtdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
+ */
+function definition(identifier, options = {}) {
+    const index = identifier.lastIndexOf('::');
+    const module = identifier.slice(0, index);
+    const compoundDef = identifier.slice(index + 2);
+    const path = { category: 'nbtdoc', path: [module, compoundDef] };
+    return (node, ctx) => {
+        const { allowUnknownKey, value } = resolveSymbolPaths([path], ctx, node);
+        options.allowUnknownKey || (options.allowUnknownKey = allowUnknownKey);
+        compound(value, options)(node, ctx);
+    };
+}
+exports.definition = definition;
+function blockStates(blocks, _options = {}) {
+    return (node, ctx) => {
+        const states = core.getStates('block', blocks, ctx);
+        for (const { key: keyNode, value: valueNode } of node.children) {
+            if (!keyNode || !valueNode) {
+                continue;
+            }
+            // Type check.
+            if (valueNode.type === 'nbt:byte' && (ctx.src.slice(valueNode.range).toLowerCase() === 'false' || ctx.src.slice(valueNode.range).toLowerCase() === 'true')) {
+                ctx.err.report((0, lib_1.localize)('nbt.checker.block-states.fake-boolean'), valueNode, 2 /* Warning */);
+                continue;
+            }
+            else if (valueNode.type !== 'string' && valueNode.type !== 'nbt:int') {
+                ctx.err.report((0, lib_1.localize)('nbt.checker.block-states.unexpected-value-type'), valueNode, 2 /* Warning */);
+                continue;
+            }
+            if (Object.keys(states).includes(keyNode.value)) {
+                // The current state exists. Check the value.
+                const stateValues = states[keyNode.value];
+                if (!stateValues.includes(valueNode.value.toString())) {
+                    ctx.err.report((0, lib_1.localize)('expected-got', stateValues, (0, lib_1.localeQuote)(valueNode.value.toString())), valueNode, 2 /* Warning */);
+                }
+            }
+            else {
+                // The current state doesn't exist.
+                ctx.err.report((0, lib_1.localize)('nbt.checker.block-states.unknown-state', (0, lib_1.localeQuote)(keyNode.value), blocks), keyNode, 2 /* Warning */);
+            }
+        }
+    };
+}
+exports.blockStates = blockStates;
+/**
+ * @param path The {@link core.SymbolPath} to the compound definition.
+ */
+function compound(data, options = {}) {
+    return (node, ctx) => {
+        for (const { key: keyNode, value: valueNode } of node.children) {
+            if (!keyNode || !valueNode) {
+                continue;
+            }
+            const key = keyNode.value;
+            const fieldData = data[key];
+            if (fieldData) {
+                fieldData.query?.enter({ usage: { type: 'reference', node: keyNode } });
+                fieldValue(fieldData.data, options)(valueNode, ctx);
+            }
+            else if (!options.allowUnknownKey) {
+                ctx.err.report((0, lib_1.localize)('unknown-key', (0, lib_1.localeQuote)(key)), keyNode, 2 /* Warning */);
+            }
+        }
+    };
+}
+exports.compound = compound;
+function enum_(path, _options = {}) {
+    if (!path) {
+        return core.checker.noop;
+    }
+    return (node, ctx) => {
+        const query = ctx.symbols.query(ctx.doc, path.category, ...path.path);
+        const data = query.symbol?.data;
+        // Check type.
+        if (data?.enumType && node.type !== data.enumType && node.type !== `nbt:${data.enumType}`) {
+            ctx.err.report((0, lib_1.localize)('expected', (0, lib_1.localize)(`nbt.node.${data.enumType}`)), node, 2 /* Warning */);
+        }
+        // Get all enum members.
+        const enumMembers = {};
+        query.forEachMember((name, memberQuery) => {
+            const value = memberQuery.symbol?.data?.value;
+            if (value !== undefined) {
+                enumMembers[name] = value.toString();
+            }
+        });
+        // Check value.
+        if (!Object.values(enumMembers).includes(node.value.toString())) {
+            ctx.err.report((0, lib_1.localize)('expected', Object.entries(enumMembers).map(([k, v]) => `${k} = ${v}`)), node, 2 /* Warning */);
+        }
+    };
+}
+exports.enum_ = enum_;
+/**
+ * @param id If set to `undefined` or an empty array, all nbtdoc compound definitions for this registry will be merged for checking, and unknown keys are allowed.
+ */
+function path(registry, id) {
+    return (node, ctx) => {
+        const resolveResult = resolveRootRegistry(registry, id, ctx, undefined);
+        let data = { type: 'resolved_compound', data: resolveResult.value };
+        let targetType = { type: 'compound', symbol: { category: 'nbtdoc', path: [] } };
+        const options = { allowUnknownKey: resolveResult.allowUnknownKey, isPredicate: true };
+        let currentCompound;
+        for (const child of node.children) {
+            if (node_1.NbtCompoundNode.is(child)) {
+                // Compound filter.
+                currentCompound = child;
+                if (data?.type === 'resolved_compound') {
+                    compound(data.data, options)(child, ctx);
+                }
+                else {
+                    ctx.err.report((0, lib_1.localize)('nbt.checker.path.unexpected-filter'), child, 2 /* Warning */);
+                }
+            }
+            else if (core.StringNode.is(child)) {
+                // Key.
+                if (data?.type === 'resolved_compound') {
+                    const fieldData = data.data[child.value];
+                    if (fieldData) {
+                        fieldData.query?.enter({ usage: { type: 'reference', node: child } });
+                        if (fieldData.data.type === 'byte_array' || fieldData.data.type === 'int_array' || fieldData.data.type === 'long_array' || fieldData.data.type === 'list') {
+                            data = fieldData.data;
+                        }
+                        else {
+                            const resolveResult = resolveSymbolData(fieldData.data, ctx, currentCompound);
+                            if (resolveResult.value) {
+                                options.allowUnknownKey || (options.allowUnknownKey = resolveResult.allowUnknownKey);
+                                data.data = resolveResult.value;
+                            }
+                            else {
+                                data = undefined;
+                            }
+                        }
+                        targetType = fieldData.data;
+                    }
+                    else {
+                        if (!options.allowUnknownKey) {
+                            ctx.err.report((0, lib_1.localize)('unknown-key', (0, lib_1.localeQuote)(child.value)), child, 2 /* Warning */);
+                        }
+                        targetType = undefined;
+                        break;
+                    }
+                }
+                else {
+                    ctx.err.report((0, lib_1.localize)('nbt.checker.path.unexpected-key'), child, 2 /* Warning */);
+                    targetType = undefined;
+                    break;
+                }
+                currentCompound = undefined;
+            }
+            else {
+                // Index.
+                if (data?.type === 'byte_array' || data?.type === 'int_array' || data?.type === 'long_array' || data?.type === 'list') {
+                    // Check content.
+                    if (child.children !== undefined) {
+                        const [content] = child.children;
+                        if (content.type === 'integer') {
+                            const absIndex = content.value < 0 ? -1 - content.value : content.value;
+                            const [, maxLength] = data.lengthRange ?? [undefined, undefined];
+                            if (maxLength !== undefined && absIndex >= maxLength) {
+                                ctx.err.report((0, lib_1.localize)('nbt.checker.path.index-out-of-bound', content.value, maxLength), content, 2 /* Warning */);
+                            }
+                        }
+                        else {
+                            let isUnexpectedFilter = true;
+                            if (data.type === 'list') {
+                                const { allowUnknownKey, value } = resolveSymbolData(data.item, ctx, currentCompound);
+                                options.allowUnknownKey || (options.allowUnknownKey = allowUnknownKey);
+                                if (value) {
+                                    isUnexpectedFilter = false;
+                                    compound(value, options)(content, ctx);
+                                }
+                            }
+                            if (isUnexpectedFilter) {
+                                ctx.err.report((0, lib_1.localize)('nbt.checker.path.unexpected-filter'), content, 2 /* Warning */);
+                                targetType = undefined;
+                                break;
+                            }
+                            currentCompound = content;
+                        }
+                    }
+                    // Set data for the next iteration.
+                    if (data.type === 'list') {
+                        const { allowUnknownKey, value } = resolveSymbolData(data.item, ctx, currentCompound);
+                        options.allowUnknownKey || (options.allowUnknownKey = allowUnknownKey);
+                        targetType = data.item;
+                        if (value) {
+                            data = { type: 'resolved_compound', data: value };
+                        }
+                        else {
+                            data = undefined;
+                        }
+                    }
+                    else {
+                        targetType = {
+                            type: data.type.split('_')[0],
+                            valueRange: data.valueRange,
+                        };
+                        data = undefined;
+                    }
+                }
+                else {
+                    ctx.err.report((0, lib_1.localize)('nbt.checker.path.unexpected-index'), child, 2 /* Warning */);
+                    targetType = undefined;
+                    break;
+                }
+            }
+        }
+        ctx.ops.set(node, 'targetType', targetType);
+    };
+}
+exports.path = path;
+function fieldValue(type, options) {
+    const isInRange = (value, [min, max]) => (min ?? -Infinity) <= value && value <= (max ?? Infinity);
+    const ExpectedTypes = {
+        boolean: 'nbt:byte',
+        byte: 'nbt:byte',
+        byte_array: 'nbt:byte_array',
+        compound: 'nbt:compound',
+        double: 'nbt:double',
+        float: 'nbt:float',
+        id: 'string',
+        index: 'nbt:compound',
+        int: 'nbt:int',
+        int_array: 'nbt:int_array',
+        list: 'nbt:list',
+        long: 'nbt:long',
+        long_array: 'nbt:long_array',
+        short: 'nbt:short',
+        string: 'string',
+    };
+    return (node, ctx) => {
+        // Rough type check.
+        if (type.type !== 'enum' && type.type !== 'union' && node.type !== ExpectedTypes[type.type]) {
+            ctx.err.report((0, lib_1.localize)('expected', (0, util_1.localizeTag)(ExpectedTypes[type.type])), node, 2 /* Warning */);
+            return;
+        }
+        switch (type.type) {
+            case 'boolean':
+                node = node;
+                if (node.value !== 0 && node.value !== 1) {
+                    ctx.err.report((0, lib_1.localize)('nbt.checker.boolean.out-of-range', (0, lib_1.localeQuote)('0b'), (0, lib_1.localeQuote)('1b')), node, 2 /* Warning */);
+                }
+                break;
+            case 'byte_array':
+            case 'int_array':
+            case 'long_array':
+                node = node;
+                if (type.lengthRange && !isInRange(node.children.length, type.lengthRange)) {
+                    ctx.err.report((0, lib_1.localize)('expected', (0, lib_1.localize)('nbt.checker.collection.length-between', (0, util_1.localizeTag)(node.type), type.lengthRange[0] ?? '-∞', type.lengthRange[1] ?? '+∞')), node, 2 /* Warning */);
+                }
+                if (type.valueRange) {
+                    for (const { value: childNode } of node.children) {
+                        if (childNode && !isInRange(Number(childNode.value), type.valueRange)) {
+                            ctx.err.report((0, lib_1.localize)('number.between', type.valueRange[0] ?? '-∞', type.valueRange[1] ?? '+∞'), node, 2 /* 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((0, lib_1.localize)('number.between', type.valueRange[0] ?? '-∞', type.valueRange[1] ?? '+∞'), node, 2 /* Warning */);
+                }
+                break;
+            case 'index':
+                node = node;
+                const id = resolveFieldPath(node.parent?.parent, type.index.path);
+                if (type.index.registry && id) {
+                    index(type.index.registry, core.ResourceLocation.lengthen(id), options)(node, ctx);
+                }
+                break;
+            case 'id':
+                node = node;
+                core.parseStringValue(core.resourceLocation(type.registry
+                    ? { category: type.registry, isPredicate: options.isPredicate }
+                    : { allowUnknown: true, pool: [], isPredicate: options.isPredicate }), node.value, node.valueMap, ctx);
+                break;
+            case 'list':
+                node = node;
+                type = nbtdoc.simplifyListType(type);
+                if (type.lengthRange && !isInRange(node.children.length, type.lengthRange)) {
+                    ctx.err.report((0, lib_1.localize)('expected', (0, lib_1.localize)('nbt.checker.collection.length-between', (0, util_1.localizeTag)(node.type), type.lengthRange[0] ?? '-∞', type.lengthRange[1] ?? '+∞')), node, 2 /* Warning */);
+                }
+                for (const { value: childNode } of node.children) {
+                    if (childNode) {
+                        fieldValue(type.item, options)(childNode, ctx);
+                    }
+                }
+                break;
+            case 'string':
+                node = node;
+                let suffix = '';
+                let valueNode = node;
+                if (core.ItemNode.is(node.parent) && node_1.NbtListNode.is(node.parent.parent)) {
+                    suffix = '[]';
+                    valueNode = node.parent.parent;
+                }
+                if (core.PairNode.is(valueNode.parent)) {
+                    const compoundNbtdocPath = valueNode.parent.key?.symbol?.parentSymbol?.path.join('::');
+                    const key = valueNode.parent.key?.value;
+                    const path = `${compoundNbtdocPath}.${key}${suffix}`;
+                    const parserName = (0, nbtdocUtil_1.getSpecialStringParser)(path);
+                    if (parserName) {
+                        try {
+                            const parser = ctx.meta.getParser(parserName);
+                            const result = core.parseStringValue(parser, node.value, node.valueMap, ctx);
+                            if (result !== core.Failure) {
+                                ctx.ops.set(node, 'children', [result]);
+                                result.parent = node;
+                            }
+                        }
+                        catch (e) {
+                            ctx.logger.error('[nbt.checker.fieldValue#string]', e);
+                        }
+                    }
+                }
+                break;
+            case 'compound':
+                node = node;
+                if (type.symbol) {
+                    const { allowUnknownKey, value } = resolveSymbolPaths([type.symbol], ctx, node);
+                    compound(value, { ...options, allowUnknownKey: options.allowUnknownKey || allowUnknownKey })(node, ctx);
+                }
+                break;
+            case 'enum':
+                node = node;
+                enum_(type.symbol, options)(node, ctx);
+                break;
+            case 'union':
+                type = nbtdoc.flattenUnionType(type);
+                if (type.members.length === 0) {
+                    ctx.err.report((0, lib_1.localize)('nbt.checker.compound.field.union-empty-members'), core.PairNode.is(node.parent)
+                        ? (node.parent.key ?? node.parent)
+                        : node, 2 /* Warning */);
+                }
+                else {
+                    core.checker.any(type.members.map(t => fieldValue(t, options)))(node, ctx);
+                }
+                break;
+        }
+    };
+}
+exports.fieldValue = fieldValue;
+function resolveFieldPath(compound, fieldPath) {
+    let node = compound;
+    for (const path of fieldPath) {
+        if (!node) {
+            break;
+        }
+        if (typeof path === 'object') {
+            // Super.
+            node = node.parent;
+        }
+        else {
+            // Field key.
+            if (!node_1.NbtCompoundNode.is(node)) {
+                break;
+            }
+            node = node.children.find(({ key }) => key?.value === path)?.value;
+        }
+    }
+    return node && node_1.NbtPrimitiveNode.is(node)
+        ? node.value.toString()
+        : undefined;
+}
+const getUnwrapper = (out) => (result) => {
+    out.allowUnknownKey || (out.allowUnknownKey = result.allowUnknownKey);
+    return result.value;
+};
+const map = (result, cb) => {
+    const ans = cb(result.value);
+    return {
+        allowUnknownKey: result.allowUnknownKey || ans.allowUnknownKey,
+        value: ans.value,
+    };
+};
+function getPathsFromRootRegistry(registry, inputIds, ctx) {
+    if (!registry) {
+        return { allowUnknownKey: true, value: [] };
+    }
+    const normalizeIds = (input, descriptionQuery) => {
+        let allowUnknownKey = false;
+        let ids;
+        if (input === undefined || (Array.isArray(input) && input.length === 0)) {
+            ids = Object.keys(descriptionQuery.visibleMembers);
+            allowUnknownKey = true;
+        }
+        else if (!Array.isArray(input)) {
+            ids = [input];
+        }
+        else {
+            ids = input;
+        }
+        return { allowUnknownKey, value: ids };
+    };
+    const collectPaths = (ids, descriptionQuery) => {
+        let allowUnknownKey = false;
+        const paths = new core.SymbolPathCollector();
+        descriptionQuery.ifKnown(() => {
+            for (const id of ids) {
+                descriptionQuery.member(id, member => member
+                    .ifKnown(symbol => paths.add(symbol.relations?.describedBy))
+                    .else(() => descriptionQuery.member('@default', defaultMember => {
+                    allowUnknownKey = true;
+                    paths.add(defaultMember.symbol?.relations?.describedBy);
+                })));
+            }
+        });
+        return { allowUnknownKey, value: paths.collect() };
+    };
+    const descriptionQuery = ctx.symbols.query(ctx.doc, 'nbtdoc/description', registry);
+    return map(normalizeIds(inputIds, descriptionQuery), ids => collectPaths(ids, descriptionQuery));
+}
+function resolveSymbolPaths(paths, ctx, compound) {
+    if (paths.length === 0) {
+        return { allowUnknownKey: true, value: {} };
+    }
+    const getDefinitionQuery = (path) => {
+        return {
+            allowUnknownKey: (0, nbtdocUtil_1.isExpandableCompound)(path.path.join('::')),
+            value: ctx.symbols.query(ctx.doc, path.category, ...path.path),
+        };
+    };
+    const getPathsFromSuper = (extendable) => {
+        if (extendable.type === 'compound') {
+            return { allowUnknownKey: false, value: extendable.symbol ? [extendable.symbol] : [] };
+        }
+        else {
+            const id = resolveFieldPath(compound, extendable.index.path);
+            return getPathsFromRootRegistry(extendable.index.registry, id ? core.ResourceLocation.lengthen(id) : undefined, ctx);
+        }
+    };
+    const getPathsRecursively = (paths) => {
+        const collector = new core.SymbolPathCollector();
+        const out = { allowUnknownKey: false };
+        const unwrap = getUnwrapper(out);
+        const iterate = (paths) => {
+            for (const path of paths) {
+                if (collector.has(path)) {
+                    continue;
+                }
+                collector.add(path);
+                const query = unwrap(getDefinitionQuery(path));
+                const data = query.symbol?.data;
+                if (data) {
+                    const superPaths = data.extends ? unwrap(getPathsFromSuper(data.extends)) : [];
+                    iterate(superPaths);
+                }
+                else {
+                    out.allowUnknownKey = true;
+                }
+            }
+        };
+        iterate(paths);
+        return { allowUnknownKey: out.allowUnknownKey, value: collector.collect() };
+    };
+    const ans = Object.create(null);
+    const out = { allowUnknownKey: false };
+    const unwrap = getUnwrapper(out);
+    const allPaths = unwrap(getPathsRecursively(paths));
+    for (const path of allPaths) {
+        const query = unwrap(getDefinitionQuery(path));
+        query.forEachMember((key, keyQuery) => {
+            const data = keyQuery.symbol?.data;
+            if (!data) {
+                return;
+            }
+            if (ans[key]) {
+                delete ans[key].query;
+                const existingData = ans[key].data;
+                if (existingData.type === 'union') {
+                    existingData.members.push(data.fieldType);
+                }
+                else {
+                    ans[key].data = { type: 'union', members: [existingData, data.fieldType] };
+                }
+            }
+            else {
+                ans[key] = { data: data.fieldType, query: keyQuery };
+            }
+        });
+    }
+    return { allowUnknownKey: out.allowUnknownKey, value: ans };
+}
+/**
+ * @param registry If `undefined`, allows unknown key.
+ * @param id If `undefined` or an empty array, merges all available definitions and allows unknown key.
+ */
+function resolveRootRegistry(registry, inputIds, ctx, compound) {
+    const out = { allowUnknownKey: false };
+    const unwrap = getUnwrapper(out);
+    const paths = unwrap(getPathsFromRootRegistry(registry, inputIds, ctx));
+    const data = unwrap(resolveSymbolPaths(paths, ctx, compound));
+    return { allowUnknownKey: out.allowUnknownKey, value: data };
+}
+function resolveSymbolData(data, ctx, compound) {
+    const out = { allowUnknownKey: false };
+    const unwrap = getUnwrapper(out);
+    const paths = unwrap(getPathsFromSymbolData(data, ctx, compound));
+    if (!paths) {
+        return { allowUnknownKey: out.allowUnknownKey, value: undefined };
+    }
+    const ans = unwrap(resolveSymbolPaths(paths, ctx, compound));
+    return { allowUnknownKey: out.allowUnknownKey, value: ans };
+}
+function getPathsFromSymbolData(data, ctx, compound) {
+    const collector = new core.SymbolPathCollector();
+    const out = { allowUnknownKey: false };
+    const unwrap = getUnwrapper(out);
+    const iterate = (data) => {
+        if (data.type === 'compound') {
+            collector.add(data.symbol);
+            return true;
+        }
+        else if (data.type === 'index') {
+            const id = resolveFieldPath(compound, data.index.path);
+            const paths = unwrap(getPathsFromRootRegistry(data.index.registry, id ? core.ResourceLocation.lengthen(id) : undefined, ctx));
+            for (const path of paths) {
+                collector.add(path);
+            }
+            return true;
+        }
+        else if (data.type === 'union') {
+            let ans = false;
+            for (const member of data.members) {
+                ans || (ans = iterate(member));
+            }
+            return ans;
+        }
+        return false;
+    };
+    const isCompoundData = iterate(data);
+    return { allowUnknownKey: out.allowUnknownKey, value: isCompoundData ? collector.collect() : undefined };
+}
+//# sourceMappingURL=index.js.map

package/lib/checker/nbtdocUtil.d.ts

@@ -0,0 +1,9 @@
+import type * as core from '../../../core/lib';
+export declare function getBlocksFromItem(item: core.FullResourceLocation): core.FullResourceLocation[] | undefined;
+export declare function getEntityFromItem(item: core.FullResourceLocation): core.FullResourceLocation | undefined;
+export declare function getSpecialStringParser(nbtdocPath: string): string | undefined;
+/**
+ * @param nbtdocPath Path of the nbtdoc compound definition.
+ */
+export declare function isExpandableCompound(nbtdocPath: string): boolean;
+//# sourceMappingURL=nbtdocUtil.d.ts.map