@spyglassmc/java-edition 0.1.0

package/lib/json/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/* istanbul ignore file */
+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.initialize = exports.checker = void 0;
+const json = __importStar(require("@spyglassmc/json"));
+const checker = __importStar(require("./checker"));
+exports.checker = __importStar(require("./checker"));
+const initialize = (ctx) => {
+    json.initialize(ctx);
+    checker.register(ctx.meta);
+};
+exports.initialize = initialize;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+import * as core from '@spyglassmc/core';
+import * as mcf from '@spyglassmc/mcfunction';
+import { EntityNode } from '../node';
+export declare const command: core.Checker<mcf.CommandNode>;
+export declare const getTypesFromEntity: (entity: EntityNode, ctx: core.CheckerContext) => core.FullResourceLocation[] | undefined;
+export declare function register(meta: core.MetaRegistry): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/checker/index.js

@@ -0,0 +1,217 @@
+"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.register = exports.getTypesFromEntity = exports.command = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const json = __importStar(require("@spyglassmc/json"));
+const lib_1 = require("@spyglassmc/locales/lib");
+const mcf = __importStar(require("@spyglassmc/mcfunction"));
+const nbt = __importStar(require("@spyglassmc/nbt"));
+const nbtdoc = __importStar(require("@spyglassmc/nbtdoc"));
+const common_1 = require("../../common");
+const text_component_1 = require("../../json/checker/data/text_component");
+const node_1 = require("../node");
+const command = (node, ctx) => {
+    if (node.slash && node.parent && mcf.McfunctionNode.is(node.parent)) {
+        ctx.err.report((0, lib_1.localize)('unexpected-leading-slash'), node.slash);
+    }
+    rootCommand(node.children, 0, ctx);
+};
+exports.command = command;
+const getName = (nodes, index) => {
+    return nodes[index]?.path[nodes[index].path.length - 1];
+};
+const getNode = (nodes, index) => {
+    return nodes[index]?.children[0];
+};
+const rootCommand = (nodes, index, ctx) => {
+    if (getName(nodes, index) === 'data') {
+        if (getName(nodes, index + 1) === 'get') {
+            nbtPath(nodes, index + 2, ctx);
+        }
+        else if (getName(nodes, index + 1) === 'merge') {
+            dataMergeTarget(nodes, index + 2, ctx);
+        }
+        else if (getName(nodes, index + 1) === 'modify') {
+            nbtPath(nodes, index + 2, ctx);
+            const targetPath = getNode(nodes, index + 4);
+            const operation = getName(nodes, index + 5);
+            const sourceTypeIndex = operation === 'insert' ? index + 7 : index + 6;
+            if (getName(nodes, sourceTypeIndex) === 'from') {
+                // `from <$nbtPath$>`
+                nbtPath(nodes, sourceTypeIndex + 1, ctx);
+                const sourcePath = getNode(nodes, sourceTypeIndex + 3);
+                if (nbt.NbtPathNode.is(targetPath) && nbt.NbtPathNode.is(sourcePath)) {
+                    const { errorMessage } = nbtdoc.checkAssignability({ source: sourcePath.targetType, target: targetPath.targetType });
+                    if (errorMessage) {
+                        ctx.err.report(errorMessage, core.Range.span(targetPath, sourcePath), 2 /* Warning */);
+                    }
+                }
+            }
+            else if (getName(nodes, sourceTypeIndex) === 'value') {
+                // `value <value: nbt_tag>`
+                const valueNode = getNode(nodes, sourceTypeIndex + 1);
+                if (nbt.NbtPathNode.is(targetPath) && targetPath.targetType && nbt.NbtNode.is(valueNode)) {
+                    nbt.checker.fieldValue(targetPath.targetType, { allowUnknownKey: true })(valueNode, ctx);
+                }
+            }
+        }
+        else if (getName(nodes, index + 1) === 'remove') {
+            nbtPath(nodes, index + 2, 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|unless data <$nbtPath$>`
+                nbtPath(nodes, i + 2, ctx);
+                i += 2;
+            }
+            else if (getName(nodes, i) === 'run') {
+                rootCommand(nodes, i + 1, ctx);
+                break;
+            }
+        }
+    }
+    else if (getName(nodes, index) === 'summon') {
+        summonNbt(nodes, index + 1, ctx);
+    }
+    for (const { children: [node] } of nodes) {
+        if (json.JsonNode.is(node)) {
+            (0, text_component_1.text_component)(node, { ...ctx, context: '' });
+        }
+    }
+};
+/**
+ * - `block <targetPos: block_pos> <nbt: nbt_compound_tag>`
+ * - `entity <target: entity> <nbt: nbt_compound_tag>`
+ * - `storage <target: resource_location> <nbt: nbt_compound_tag>`
+ */
+const dataMergeTarget = (nodes, index, ctx) => {
+    const registry = getName(nodes, index);
+    switch (registry) {
+        case 'block': {
+            const nbtNode = getNode(nodes, index + 2);
+            if (nbt.NbtCompoundNode.is(nbtNode)) {
+                nbt.checker.index('block', undefined)(nbtNode, ctx);
+            }
+            break;
+        }
+        case 'entity': {
+            const entityNode = getNode(nodes, index + 1);
+            const nbtNode = getNode(nodes, index + 2);
+            if (node_1.EntityNode.is(entityNode) && nbt.NbtCompoundNode.is(nbtNode)) {
+                const types = (0, exports.getTypesFromEntity)(entityNode, ctx);
+                nbt.checker.index('entity_type', types)(nbtNode, ctx);
+            }
+            break;
+        }
+        case 'storage': {
+            const idNode = getNode(nodes, index + 1);
+            const nbtNode = getNode(nodes, index + 2);
+            if (core.ResourceLocationNode.is(idNode) && nbt.NbtCompoundNode.is(nbtNode)) {
+                nbt.checker.index('storage', core.ResourceLocationNode.toString(idNode, 'full'))(nbtNode, ctx);
+            }
+            break;
+        }
+    }
+};
+/**
+ * - `block <block_pos> <nbt_path>`
+ * - `entity <entity> <nbt_path>`
+ * - `storage <resource_location> <nbt_path>`
+ */
+const nbtPath = (nodes, index, ctx) => {
+    const registry = getName(nodes, index);
+    switch (registry) {
+        case 'block': {
+            const nbtNode = getNode(nodes, index + 2);
+            if (nbt.NbtPathNode.is(nbtNode)) {
+                nbt.checker.path('block', undefined)(nbtNode, ctx);
+            }
+            break;
+        }
+        case 'entity': {
+            const entityNode = getNode(nodes, index + 1);
+            const nbtNode = getNode(nodes, index + 2);
+            if (node_1.EntityNode.is(entityNode) && nbt.NbtPathNode.is(nbtNode)) {
+                const types = (0, exports.getTypesFromEntity)(entityNode, ctx);
+                nbt.checker.path('entity_type', types)(nbtNode, ctx);
+            }
+            break;
+        }
+        case 'storage': {
+            const idNode = getNode(nodes, index + 1);
+            const nbtNode = getNode(nodes, index + 2);
+            if (core.ResourceLocationNode.is(idNode) && nbt.NbtPathNode.is(nbtNode)) {
+                nbt.checker.path('storage', core.ResourceLocationNode.toString(idNode, 'full'))(nbtNode, ctx);
+            }
+            break;
+        }
+    }
+};
+/**
+ * - `<entity: entity_summon> [<pos: vec3>] [<nbt: nbt_compound_tag>]`
+ */
+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)) {
+        nbt.checker.index('entity_type', core.ResourceLocationNode.toString(typeNode, 'full'))(nbtNode, ctx);
+    }
+};
+const getTypesFromEntity = (entity, ctx) => {
+    if (entity.playerName !== undefined || entity.selector?.playersOnly) {
+        return ['minecraft:player'];
+    }
+    else if (entity.selector) {
+        const argumentsNode = entity.selector.arguments;
+        if (!argumentsNode) {
+            return undefined;
+        }
+        let types = [];
+        for (const pairNode of argumentsNode.children) {
+            if (pairNode.key?.value !== 'type') {
+                continue;
+            }
+            const valueNode = pairNode.value;
+            if (!valueNode || valueNode.inverted) {
+                continue;
+            }
+            const value = core.ResourceLocationNode.toString(valueNode.value, 'full');
+            if (value.startsWith(core.ResourceLocation.TagPrefix)) {
+                const tagValues = (0, common_1.getTagValues)('tag/entity_type', value.slice(1), ctx);
+                types = types.filter(t => tagValues.includes(t));
+            }
+            else {
+                types = [value];
+            }
+        }
+        return types;
+    }
+    return undefined;
+};
+exports.getTypesFromEntity = getTypesFromEntity;
+function register(meta) {
+    meta.registerChecker('mcfunction:command', exports.command);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+import * as core from '@spyglassmc/core';
+import type { ObjectiveCriteriaNode, VectorNode } from '../node';
+export declare const objectiveCriterion: core.Colorizer<ObjectiveCriteriaNode>;
+export declare const vector: core.Colorizer<VectorNode>;
+export declare function register(meta: core.MetaRegistry): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/colorizer/index.js

@@ -0,0 +1,38 @@
+"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.register = exports.vector = exports.objectiveCriterion = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const objectiveCriterion = node => [
+    core.ColorToken.create(node, 'type'),
+];
+exports.objectiveCriterion = objectiveCriterion;
+const vector = node => {
+    return [core.ColorToken.create(node, 'vector')];
+};
+exports.vector = vector;
+function register(meta) {
+    meta.registerColorizer('mcfunction:coordinate', core.colorizer.number);
+    meta.registerColorizer('mcfunction:vector', exports.vector);
+    meta.registerColorizer('mcfunction:objective_criteria', exports.objectiveCriterion);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+export declare const ColorArgumentValues: string[];
+export declare const EntityAnchorArgumentValues: string[];
+export declare const ItemSlotArgumentValues: string[];
+export declare const OperationArgumentValues: string[];
+export declare const ScoreboardSlotArgumentValues: string[];
+export declare const SwizzleArgumentValues: string[];
+//# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/common/index.js

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

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

@@ -0,0 +1,5 @@
+import type { MetaRegistry } from '@spyglassmc/core';
+import type * as mcf from '@spyglassmc/mcfunction';
+export declare const getMockNodes: mcf.completer.MockNodesGetter;
+export declare function register(meta: MetaRegistry): void;
+//# sourceMappingURL=argument.d.ts.map

package/lib/mcfunction/completer/argument.js

@@ -0,0 +1,292 @@
+"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.register = exports.getMockNodes = void 0;
+const core_1 = require("@spyglassmc/core");
+const json = __importStar(require("@spyglassmc/json"));
+const locales_1 = require("@spyglassmc/locales");
+const common_1 = require("../../common");
+const common_2 = require("../common");
+const node_1 = require("../node");
+const getMockNodes = (rawTreeNode, range) => {
+    const treeNode = rawTreeNode;
+    switch (treeNode.parser) {
+        case 'brigadier:bool':
+            return core_1.BooleanNode.mock(range);
+        case 'brigadier:double':
+        case 'brigadier:float':
+        case 'brigadier:integer':
+        case 'brigadier:long':
+        case 'minecraft:float_range':
+        case 'minecraft:message':
+        case 'minecraft:time':
+        case 'minecraft:uuid':
+            return [];
+        case 'brigadier:string':
+            return treeNode.properties.type === 'phrase'
+                ? core_1.StringNode.mock(range, core_1.BrigadierStringOptions)
+                : [];
+        case 'minecraft:angle':
+            return node_1.CoordinateNode.mock(range);
+        case 'minecraft:block_pos':
+            return node_1.VectorNode.mock(range, { dimension: 3, integersOnly: true });
+        case 'minecraft:block_predicate':
+            return node_1.BlockNode.mock(range, true);
+        case 'minecraft:block_state':
+            return node_1.BlockNode.mock(range, false);
+        case 'minecraft:color':
+            return core_1.LiteralNode.mock(range, { pool: common_2.ColorArgumentValues });
+        case 'minecraft:column_pos':
+            return node_1.VectorNode.mock(range, { dimension: 2, integersOnly: true });
+        case 'minecraft:component':
+            return [
+                json.JsonArrayNode.mock(range),
+                json.JsonObjectNode.mock(range),
+                json.JsonStringNode.mock(range),
+            ];
+        case 'minecraft:dimension':
+            return core_1.ResourceLocationNode.mock(range, { category: 'dimension' });
+        case 'minecraft:entity':
+        case 'minecraft:game_profile':
+            return node_1.EntitySelectorNode.mock(range);
+        case 'minecraft:entity_anchor':
+            return core_1.LiteralNode.mock(range, { pool: common_2.EntityAnchorArgumentValues });
+        case 'minecraft:entity_summon':
+            return core_1.ResourceLocationNode.mock(range, { category: 'entity_type' });
+        case 'minecraft:function':
+            return core_1.ResourceLocationNode.mock(range, { category: 'function' });
+        case 'minecraft:int_range':
+            return node_1.IntRangeNode.mock(range);
+        case 'minecraft:item_enchantment':
+            return core_1.ResourceLocationNode.mock(range, { category: 'enchantment' });
+        case 'minecraft:item_predicate':
+            return node_1.ItemNode.mock(range, true);
+        case 'minecraft:item_slot':
+            return core_1.LiteralNode.mock(range, { pool: common_2.ItemSlotArgumentValues });
+        case 'minecraft:item_stack':
+            return node_1.ItemNode.mock(range, false);
+        case 'minecraft:mob_effect':
+            return core_1.ResourceLocationNode.mock(range, { category: 'mob_effect' });
+        case 'minecraft:objective':
+            return core_1.SymbolNode.mock(range, { category: 'objective' });
+        case 'minecraft:objective_criteria':
+            return node_1.ObjectiveCriteriaNode.mock(range);
+        case 'minecraft:operation':
+            return core_1.LiteralNode.mock(range, { pool: common_2.OperationArgumentValues, colorTokenType: 'operator' });
+        case 'minecraft:particle':
+            return node_1.ParticleNode.mock(range);
+        case 'minecraft:resource':
+        case 'minecraft:resource_or_tag':
+            return core_1.ResourceLocationNode.mock(range, {
+                category: core_1.ResourceLocation.shorten(treeNode.properties.registry),
+                allowTag: treeNode.parser === 'minecraft:resource_or_tag',
+            });
+        case 'minecraft:resource_location':
+            return core_1.ResourceLocationNode.mock(range, treeNode.properties ?? { pool: [], allowUnknown: true });
+        case 'minecraft:rotation':
+            return node_1.VectorNode.mock(range, { dimension: 2, noLocal: true });
+        case 'minecraft:scoreboard_slot':
+            return core_1.LiteralNode.mock(range, { pool: common_2.ScoreboardSlotArgumentValues });
+        case 'minecraft:score_holder':
+            return node_1.ScoreHolderNode.mock(range);
+        case 'minecraft:swizzle':
+            return core_1.LiteralNode.mock(range, { pool: common_2.SwizzleArgumentValues });
+        case 'minecraft:team':
+            return core_1.SymbolNode.mock(range, { category: 'team' });
+        case 'minecraft:vec2':
+            return node_1.VectorNode.mock(range, { dimension: 2, integersOnly: true });
+        case 'minecraft:vec3':
+            return node_1.VectorNode.mock(range, { dimension: 3 });
+        case 'spyglassmc:tag':
+            return core_1.SymbolNode.mock(range, { category: 'tag' });
+        // ==== Unimplemented ====
+        case 'minecraft:nbt_compound_tag':
+        case 'minecraft:nbt_path':
+        case 'minecraft:nbt_tag':
+        default:
+            // Unknown parser.
+            return [];
+    }
+};
+exports.getMockNodes = getMockNodes;
+const block = (node, ctx) => {
+    const ans = [];
+    if (core_1.Range.contains(node.id, ctx.offset, true)) {
+        ans.push(...core_1.completer.resourceLocation(node.id, ctx));
+    }
+    if (node.states && core_1.Range.contains(core_1.Range.translate(node.states, 1, -1), ctx.offset, true)) {
+        ans.push(...blockStates(node.states, ctx));
+    }
+    return ans;
+};
+const blockStates = (node, ctx) => {
+    if (!node_1.BlockNode.is(node.parent)) {
+        return [];
+    }
+    const idNode = node.parent.id;
+    const id = core_1.ResourceLocationNode.toString(idNode, 'full');
+    const blocks = idNode.isTag ? (0, common_1.getTagValues)('tag/block', id, ctx) : [id];
+    const states = (0, core_1.getStates)('block', blocks, ctx);
+    return core_1.completer.record({
+        key: (_record, pair, _ctx, range, insertValue, insertComma, existingKeys) => {
+            return Object.keys(states)
+                .filter(k => pair?.key?.value === k || !existingKeys.some(ek => ek.value === k))
+                .map(k => core_1.CompletionItem.create(k, range, {
+                kind: 10 /* Property */,
+                detail: (0, locales_1.localize)('mcfunction.completer.block.states.default-value', (0, locales_1.localeQuote)(states[k][0])),
+                insertText: new core_1.InsertTextBuilder()
+                    .literal(k)
+                    .if(insertValue, b => b.literal('=').placeholder(...states[k]))
+                    .if(insertComma, b => b.literal(','))
+                    .build(),
+            }));
+        },
+        value: (_record, pair, ctx) => {
+            if (pair.key && states[pair.key.value]) {
+                return states[pair.key.value].map(v => core_1.CompletionItem.create(v, pair.value ?? ctx.offset, {
+                    kind: 12 /* Value */,
+                }));
+            }
+            return [];
+        },
+    })(node, ctx);
+};
+const coordinate = (node, _ctx) => {
+    return [core_1.CompletionItem.create('~', node)];
+};
+const item = (node, ctx) => {
+    const ans = [];
+    if (core_1.Range.contains(node.id, ctx.offset, true)) {
+        ans.push(...core_1.completer.resourceLocation(node.id, ctx));
+    }
+    return ans;
+};
+const objectiveCriteria = (node, ctx) => {
+    const ans = node_1.ObjectiveCriteriaNode.SimpleValues.map(v => core_1.CompletionItem.create(v, node));
+    if (!node.children?.[0] || core_1.Range.contains(node.children[0], ctx.offset, true)) {
+        ans.push(...core_1.completer.resourceLocation(node.children?.[0] ?? core_1.ResourceLocationNode.mock(node, { category: 'stat_type', namespacePathSep: '.' }), ctx));
+    }
+    if (node.children?.[1] && core_1.Range.contains(node.children[1], ctx.offset, true)) {
+        ans.push(...core_1.completer.resourceLocation(node.children[1], ctx));
+    }
+    return ans;
+};
+const particle = (node, ctx) => {
+    const child = core_1.AstNode.findChild(node, ctx.offset, true);
+    if (child) {
+        return core_1.completer.dispatch(child, ctx);
+    }
+    const id = core_1.ResourceLocationNode.toString(node.id, 'short');
+    const map = {
+        block: [node_1.BlockNode.mock(ctx.offset, false)],
+        block_marker: [node_1.BlockNode.mock(ctx.offset, false)],
+        dust: [node_1.VectorNode.mock(ctx.offset, { dimension: 3 }), core_1.FloatNode.mock(ctx.offset)],
+        dust_color_transition: [node_1.VectorNode.mock(ctx.offset, { dimension: 3 }), core_1.FloatNode.mock(ctx.offset), node_1.VectorNode.mock(ctx.offset, { dimension: 3 })],
+        falling_dust: [node_1.BlockNode.mock(ctx.offset, false)],
+        item: [node_1.ItemNode.mock(ctx.offset, false)],
+        sculk_charge: [core_1.FloatNode.mock(ctx.offset)],
+        vibration: [node_1.VectorNode.mock(ctx.offset, { dimension: 3 }), node_1.VectorNode.mock(ctx.offset, { dimension: 3 }), core_1.IntegerNode.mock(ctx.offset)],
+    };
+    if (node_1.ParticleNode.isSpecialType(id)) {
+        const numParamsBefore = node.children?.slice(1).filter(n => n.range.end < ctx.offset).length ?? 0;
+        const mock = map[id][numParamsBefore];
+        if (mock) {
+            return core_1.completer.dispatch(mock, ctx);
+        }
+    }
+    return [];
+};
+const scoreHolder = (node, ctx) => {
+    let ans;
+    if (node.selector && core_1.Range.contains(node.selector, ctx.offset, true)) {
+        ans = selector(node.selector, ctx);
+        if (core_1.Range.contains(node.children[0], ctx.offset, true)) {
+            ans.push(...core_1.completer.symbol(core_1.SymbolNode.mock(node, { category: 'score_holder' }), ctx));
+        }
+    }
+    else {
+        ans = core_1.completer.symbol(node.fakeName ?? core_1.SymbolNode.mock(node, { category: 'score_holder' }), ctx);
+        ans.push(...selector(node_1.EntitySelectorNode.mock(node), ctx));
+    }
+    return ans;
+};
+const selector = (node, ctx) => {
+    if (core_1.Range.contains(node.children[0], ctx.offset, true)) {
+        return core_1.completer.literal(node.children[0], ctx);
+    }
+    if (node.arguments && core_1.Range.contains(core_1.Range.translate(node.arguments, 1, -1), ctx.offset, true)) {
+        return selectorArguments(node.arguments, ctx);
+    }
+    return [];
+};
+const selectorArguments = (node, ctx) => {
+    const selector = node.parent;
+    if (!node_1.EntitySelectorNode.is(selector)) {
+        return [];
+    }
+    return core_1.completer.record({
+        key: (record, pair, _ctx, range, insertValue, insertComma) => {
+            return [...node_1.EntitySelectorNode.ArgumentKeys]
+                .filter(k => node_1.EntitySelectorNode.canKeyExist(selector, record, k) === 0 /* Ok */)
+                .map(k => core_1.CompletionItem.create(k, range, {
+                kind: 10 /* Property */,
+                insertText: new core_1.InsertTextBuilder()
+                    .literal(k)
+                    .if(insertValue, b => b.literal('=').placeholder()) // TODO
+                    .if(insertComma, b => b.literal(','))
+                    .build(),
+            }));
+        },
+        value: (_record, pair, ctx) => {
+            if (pair.value) {
+                return core_1.completer.dispatch(pair.value, ctx);
+            }
+            return [];
+        },
+    })(node, ctx);
+};
+const intRange = (node, _ctx) => {
+    return [core_1.CompletionItem.create('-2147483648..2147483647', node, { kind: 21 /* Constant */ })];
+};
+const vector = (node, _ctx) => {
+    const createCompletion = (coordinate, sortText) => core_1.CompletionItem.create(new Array(node.options.dimension).fill(coordinate).join(' '), node, { sortText });
+    const ans = [];
+    ans.push(createCompletion('~', 'a'));
+    if (!node.options.noLocal) {
+        ans.push(createCompletion('^', 'b'));
+    }
+    ans.push(createCompletion('0.0', 'c'));
+    return ans;
+};
+function register(meta) {
+    meta.registerCompleter('mcfunction:block', block);
+    meta.registerCompleter('mcfunction:coordinate', coordinate);
+    meta.registerCompleter('mcfunction:entity_selector', selector);
+    meta.registerCompleter('mcfunction:entity_selector/arguments', selectorArguments);
+    meta.registerCompleter('mcfunction:int_range', intRange);
+    meta.registerCompleter('mcfunction:item', item);
+    meta.registerCompleter('mcfunction:objective_criteria', objectiveCriteria);
+    meta.registerCompleter('mcfunction:particle', particle);
+    meta.registerCompleter('mcfunction:score_holder', scoreHolder);
+    meta.registerCompleter('mcfunction:vector', vector);
+}
+exports.register = register;
+//# sourceMappingURL=argument.js.map

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

@@ -0,0 +1,2 @@
+export * from './argument';
+//# sourceMappingURL=index.d.ts.map