@spyglassmc/mcfunction 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# `@spyglassmc/mcfunction`
+
+![banner](https://raw.githubusercontent.com/SpyglassMC/logo/main/banner.png)
+
+[![npm](https://img.shields.io/npm/v/@spyglassmc/mcfunction.svg?logo=npm&style=flat-square)](https://npmjs.com/package/@spyglassmc/mcfunction)
+
+This package contains parsers and processors for [mcfunction][mcfunction].
+
+# Usage
+
+```typescript
+import * as mcf from '@spyglassmc/mcfunction'
+
+// Register the command tree for a specific version.
+mcf.CommandTreeRegistry.instance.register('1.15', vanillaCommandTreeFor1_15, customCommandTreePatchFor1_15)
+
+// Define a function that returns the corresponding parser for the provided argument tree node.
+const argument: mcf.parser.ArgumentParserGetter = (treeNode: mcf.ArgumentTreeNode) => {
+	switch (treeNode.parser) {
+		case 'brigadier:double':
+			return parser1
+		case 'brigadier:int':
+			return parser2
+		// ...
+		default:
+			// Unsupported parser.
+			// Just return `undefined`.
+			return undefined
+	}
+}
+
+// Get the command parser.
+const commandParser = mcf.parser.command('1.15', argument)
+
+// Or the mcfunction parser.
+const mcfunctionParser = mcf.parser.entry('1.15', argument)
+```
+
+# Contributions
+
+## Languages
+
+- `mcfunction` language that is associated with the `.mcfunction` file extension.
+
+## AST Nodes
+
+## Processors
+
+[mcfunction]: https://minecraft.fandom.com/Function_(Java_Edition)

package/lib/colorizer/index.d.ts

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

package/lib/colorizer/index.js

@@ -0,0 +1,29 @@
+"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 = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+function register(meta) {
+    meta.registerColorizer('mcfunction:command_child/literal', core.colorizer.literal);
+    meta.registerColorizer('mcfunction:command_child/trailing', core.colorizer.error);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map

package/lib/completer/command.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=command.d.ts.map

package/lib/completer/command.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=command.js.map

package/lib/completer/index.d.ts

@@ -0,0 +1,12 @@
+import * as core from '@spyglassmc/core';
+import type { McfunctionNode } from '../node';
+import { CommandNode } from '../node';
+import type { ArgumentTreeNode, RootTreeNode } from '../tree';
+export declare type MockNodesGetter = (treeNode: ArgumentTreeNode, range: core.RangeLike) => core.Arrayable<core.AstNode>;
+/**
+ * @param getMockNodes A function that returns a mock AST Node from given {@link ArgumentTreeNode}. These mock nodes
+ * will be used for completing the argument.
+ */
+export declare function entry(commandTreeName: string, getMockNodes: MockNodesGetter): core.Completer<McfunctionNode>;
+export declare function command(tree: RootTreeNode, getMockNodes: MockNodesGetter): core.Completer<CommandNode>;
+//# sourceMappingURL=index.d.ts.map

package/lib/completer/index.js

@@ -0,0 +1,70 @@
+"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.command = exports.entry = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const node_1 = require("../node");
+const tree_1 = require("../tree");
+/**
+ * @param getMockNodes A function that returns a mock AST Node from given {@link ArgumentTreeNode}. These mock nodes
+ * will be used for completing the argument.
+ */
+function entry(commandTreeName, getMockNodes) {
+    return (node, ctx) => {
+        const tree = tree_1.CommandTreeRegistry.instance.get(commandTreeName);
+        const childNode = core.AstNode.findChild(node, ctx.offset, true);
+        if (core.CommentNode.is(childNode)) {
+            return [];
+        }
+        else {
+            return command(tree, getMockNodes)(childNode ?? node_1.CommandNode.mock(ctx.offset), ctx);
+        }
+    };
+}
+exports.entry = entry;
+function command(tree, getMockNodes) {
+    return (node, ctx) => {
+        const index = core.AstNode.findChildIndex(node, ctx.offset, true);
+        const selectedChildNode = node.children[index]?.children[0];
+        if (selectedChildNode) {
+            return core.completer.dispatch(selectedChildNode, ctx);
+        }
+        const lastChildNode = core.AstNode.findLastChild(node, ctx.offset);
+        if (!lastChildNode) {
+            return Object
+                .keys(tree.children ?? {})
+                .map(v => core.CompletionItem.create(v, ctx.offset, { kind: 14 /* Keyword */ }));
+        }
+        const treePath = lastChildNode.path;
+        const { treeNode: parentTreeNode } = (0, tree_1.resolveParentTreeNode)((0, tree_1.redirect)(tree, treePath), tree);
+        if (!parentTreeNode?.children) {
+            return [];
+        }
+        const { literalTreeNodes, argumentTreeNodes } = (0, tree_1.categorizeTreeChildren)(parentTreeNode.children);
+        return [
+            ...literalTreeNodes.map(([name]) => core.CompletionItem.create(name, ctx.offset, { kind: 14 /* Keyword */ })),
+            ...argumentTreeNodes.flatMap(([_name, treeNode]) => core.Arrayable.toArray(getMockNodes(treeNode, ctx.offset))
+                .flatMap(n => core.completer.dispatch(n, ctx))),
+        ];
+    };
+}
+exports.command = command;
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import * as core from '@spyglassmc/core';
+export * as colorizer from './colorizer';
+export * as completer from './completer';
+export * from './node';
+export * from './parser';
+export * from './tree';
+export declare const initialize: core.ProjectInitializer;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,39 @@
+"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;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = exports.completer = exports.colorizer = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const colorizer = __importStar(require("./colorizer"));
+exports.colorizer = __importStar(require("./colorizer"));
+exports.completer = __importStar(require("./completer"));
+__exportStar(require("./node"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./tree"), exports);
+/* istanbul ignore next */
+const initialize = ({ meta }) => {
+    colorizer.register(meta);
+    meta.registerCompleter('mcfunction:command_child/literal', core.completer.literal);
+};
+exports.initialize = initialize;
+//# sourceMappingURL=index.js.map

package/lib/node/argument.d.ts

@@ -0,0 +1,11 @@
+import type { ChildBaseNode } from './command';
+export interface SpyglassmcTrailingArgumentNode extends ChildBaseNode {
+    type: 'mcfunction:argument/spyglassmc:trailing';
+    value: string;
+}
+export interface SpyglassmcUnknownArgumentNode extends ChildBaseNode {
+    type: 'mcfunction:argument/spyglassmc:unknown';
+    value: string;
+}
+export declare type SpecialArgumentNode = SpyglassmcTrailingArgumentNode | SpyglassmcUnknownArgumentNode;
+//# sourceMappingURL=argument.d.ts.map

package/lib/node/argument.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=argument.js.map

package/lib/node/command.d.ts

@@ -0,0 +1,35 @@
+import * as core from '@spyglassmc/core';
+export interface CommandNode extends core.SequenceNode<CommandChildNode> {
+    type: 'mcfunction:command';
+    slash?: core.Range;
+}
+export declare namespace CommandNode {
+    function is(node: core.AstNode): node is CommandNode;
+    function mock(range: core.RangeLike): CommandNode;
+}
+export interface CommandChildNode extends core.AstNode {
+    type: 'mcfunction:command_child';
+    /**
+     * The path of this node in the command tree. Empty if the current node does not correspond to an actual tree node.
+     */
+    path: string[];
+    children: [core.AstNode];
+}
+export declare namespace CommandChildNode {
+    function is(node: core.AstNode): node is CommandChildNode;
+}
+export interface TrailingCommandChildNode extends core.AstNode {
+    type: 'mcfunction:command_child/trailing';
+    value: string;
+}
+export interface UnknownCommandChildNode extends core.AstNode {
+    type: 'mcfunction:command_child/unknown';
+    value: string;
+}
+export interface LiteralCommandChildNode extends core.LiteralBaseNode {
+    type: 'mcfunction:command_child/literal';
+}
+export declare namespace LiteralCommandChildNode {
+    function is(node: core.AstNode | undefined): node is LiteralCommandChildNode;
+}
+//# sourceMappingURL=command.d.ts.map

package/lib/node/command.js

@@ -0,0 +1,54 @@
+"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.LiteralCommandChildNode = exports.CommandChildNode = exports.CommandNode = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+var CommandNode;
+(function (CommandNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:command';
+    }
+    CommandNode.is = is;
+    function mock(range) {
+        return {
+            type: 'mcfunction:command',
+            range: core.Range.get(range),
+            children: [],
+        };
+    }
+    CommandNode.mock = mock;
+})(CommandNode = exports.CommandNode || (exports.CommandNode = {}));
+var CommandChildNode;
+(function (CommandChildNode) {
+    function is(node) {
+        return node.type === 'mcfunction:command_child';
+    }
+    CommandChildNode.is = is;
+})(CommandChildNode = exports.CommandChildNode || (exports.CommandChildNode = {}));
+var LiteralCommandChildNode;
+(function (LiteralCommandChildNode) {
+    function is(node) {
+        return node?.type === 'mcfunction:command_child/literal';
+    }
+    LiteralCommandChildNode.is = is;
+})(LiteralCommandChildNode = exports.LiteralCommandChildNode || (exports.LiteralCommandChildNode = {}));
+//# sourceMappingURL=command.js.map

package/lib/node/entry.d.ts

@@ -0,0 +1,9 @@
+import type * as core from '@spyglassmc/core';
+import type { CommandNode } from './command';
+export interface McfunctionNode extends core.SequenceNode<CommandNode | core.CommentNode> {
+    type: 'mcfunction:entry';
+}
+export declare namespace McfunctionNode {
+    function is(node: core.AstNode | undefined): node is McfunctionNode;
+}
+//# sourceMappingURL=entry.d.ts.map

package/lib/node/entry.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McfunctionNode = void 0;
+var McfunctionNode;
+(function (McfunctionNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node?.type === 'mcfunction:entry';
+    }
+    McfunctionNode.is = is;
+})(McfunctionNode = exports.McfunctionNode || (exports.McfunctionNode = {}));
+//# sourceMappingURL=entry.js.map

package/lib/node/index.d.ts

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

package/lib/node/index.js

@@ -0,0 +1,15 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./command"), exports);
+__exportStar(require("./entry"), exports);
+//# sourceMappingURL=index.js.map

package/lib/node/literal.d.ts

@@ -0,0 +1,9 @@
+import type * as core from '@spyglassmc/core';
+import type { ChildBaseNode } from './command';
+export interface LiteralNode extends core.LiteralBaseNode, ChildBaseNode {
+    type: 'mcfunction:literal';
+}
+export declare namespace LiteralNode {
+    function is(node: core.AstNode): node is LiteralNode;
+}
+//# sourceMappingURL=literal.d.ts.map

package/lib/node/literal.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralNode = void 0;
+var LiteralNode;
+(function (LiteralNode) {
+    /* istanbul ignore next */
+    function is(node) {
+        return node.type === 'mcfunction:literal';
+    }
+    LiteralNode.is = is;
+})(LiteralNode = exports.LiteralNode || (exports.LiteralNode = {}));
+//# sourceMappingURL=literal.js.map

package/lib/parser/argument.d.ts

@@ -0,0 +1,12 @@
+import type * as core from '@spyglassmc/core';
+import type { ArgumentTreeNode } from '../tree';
+/**
+ * A function that returns a parser for the provided tree node.
+ *
+ * @param treeNode The argument tree node.
+ *
+ * @returns The parser corresponding to that tree node, or `undefined` if such parser doesn't exist.
+ */
+export declare type ArgumentParserGetter = (treeNode: ArgumentTreeNode) => core.Parser | undefined;
+export declare function argumentTreeNodeToString(name: string, treeNode: ArgumentTreeNode): string;
+//# sourceMappingURL=argument.d.ts.map

package/lib/parser/argument.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argumentTreeNodeToString = void 0;
+function argumentTreeNodeToString(name, treeNode) {
+    const parserName = treeNode.parser.slice(treeNode.parser.indexOf(':') + 1);
+    return `<${name}: ${parserName}>`;
+}
+exports.argumentTreeNodeToString = argumentTreeNodeToString;
+//# sourceMappingURL=argument.js.map

package/lib/parser/command.d.ts

@@ -0,0 +1,12 @@
+import * as core from '@spyglassmc/core';
+import type { CommandNode } from '../node';
+import type { RootTreeNode, TreeNode } from '../tree/type';
+import type { ArgumentParserGetter } from './argument';
+/**
+ * @returns A parser that always takes a whole line (excluding line turn characters) and tries to parse it as a command.
+ */
+export declare function command(tree: RootTreeNode, argument: ArgumentParserGetter): core.InfallibleParser<CommandNode>;
+export declare function treeNodeChildrenToStringArray(children: Exclude<TreeNode['children'], undefined>, executable?: boolean): string[];
+export declare function treeNodeChildrenToString(children: Exclude<TreeNode['children'], undefined>): string;
+export declare function treeNodeToString(name: string, treeNode: TreeNode): string;
+//# sourceMappingURL=command.d.ts.map

package/lib/parser/command.js

@@ -0,0 +1,181 @@
+"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.treeNodeToString = exports.treeNodeChildrenToString = exports.treeNodeChildrenToStringArray = exports.command = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const locales_1 = require("@spyglassmc/locales");
+const tree_1 = require("../tree");
+const argument_1 = require("./argument");
+const common_1 = require("./common");
+const literal_1 = require("./literal");
+/**
+ * @returns A parser that always takes a whole line (excluding line turn characters) and tries to parse it as a command.
+ */
+function command(tree, argument) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'mcfunction:command',
+            range: core.Range.create(src),
+            children: [],
+        };
+        const start = src.cursor;
+        if (src.trySkip('/')) {
+            ans.slash = core.Range.create(start, src.cursor);
+        }
+        dispatch(ans.children, src, ctx, [], tree, tree, argument);
+        if (src.canReadInLine()) {
+            // There is trailing string after the command.
+            const node = trailing(src, ctx);
+            ans.children.push({
+                type: 'mcfunction:command_child',
+                range: node.range,
+                children: [node],
+                path: [],
+            });
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.command = command;
+/**
+ * Dispatch and parse based on the specified command tree node's children.
+ *
+ * @param ans An array where child nodes will be pushed into.
+ */
+function dispatch(ans, src, ctx, path, rootTreeNode, parentTreeNode, argument) {
+    // Convention: suffix `Node` is for AST nodes; `TreeNode` is for command tree nodes.
+    function _dispatch(path, parentTreeNode) {
+        const { treeNode: parent, path: resolvedPath } = (0, tree_1.resolveParentTreeNode)(parentTreeNode, rootTreeNode, path);
+        path = resolvedPath;
+        const children = parent?.children;
+        if (!children) {
+            return false;
+        }
+        const { literalTreeNodes, argumentTreeNodes } = (0, tree_1.categorizeTreeChildren)(children);
+        const argumentParsers = argumentTreeNodes.map(([name, treeNode]) => ({
+            name,
+            parser: argument(treeNode) ?? unknown(treeNode),
+        }));
+        const literalParser = literalTreeNodes.length
+            ? (0, literal_1.literal)(literalTreeNodes.map(([name, _treeNode]) => name), parent.type === 'root')
+            : undefined;
+        const parsers = [
+            ...literalParser ? [literalParser] : [],
+            ...argumentParsers.map(v => v.parser),
+        ];
+        const out = { index: 0 };
+        const parser = parsers.length > 1 ? core.any(parsers, out) : parsers[0];
+        const result = parser(src, ctx);
+        if (result !== core.Failure) {
+            const takenName = argumentParsers[out.index]?.name ?? result.value;
+            const childPath = [...path, takenName];
+            ans.push({
+                type: 'mcfunction:command_child',
+                range: result.range,
+                children: [result],
+                path: childPath,
+            });
+            const childTreeNode = children[takenName];
+            if (!childTreeNode) {
+                return false;
+            }
+            const requiredPermissionLevel = childTreeNode.permission ?? 2;
+            if (ctx.config.env.permissionLevel < requiredPermissionLevel) {
+                ctx.err.report((0, locales_1.localize)('mcfunction.parser.no-permission', requiredPermissionLevel, ctx.config.env.permissionLevel), result);
+            }
+            if (result.type === 'mcfunction:command_child/unknown') {
+                // Encountered an unsupported parser. Stop parsing this command.
+                return false;
+            }
+            if (src.canReadInLine()) {
+                // Skip command argument separation (a space).
+                (0, common_1.sep)(src, ctx);
+                return { childPath, childTreeNode };
+            }
+            else {
+                // End-of-command.
+                if (!childTreeNode.executable) {
+                    ctx.err.report((0, locales_1.localize)('mcfunction.parser.eoc-unexpected'), src);
+                }
+            }
+        }
+        else {
+            // Failed to parse as any arguments.
+            ctx.err.report((0, locales_1.localize)('expected', treeNodeChildrenToString(children)), core.Range.create(src));
+        }
+        return false;
+    }
+    let result = _dispatch(path, parentTreeNode);
+    while (result) {
+        result = _dispatch(result.childPath, result.childTreeNode);
+    }
+}
+function unknown(treeNode) {
+    return (src, ctx) => {
+        const start = src.cursor;
+        const value = src.readUntilLineEnd();
+        const range = core.Range.create(start, src);
+        ctx.err.report((0, locales_1.localize)('mcfunction.parser.unknown-parser', (0, locales_1.localeQuote)(treeNode.parser)), range, 0 /* Hint */);
+        return {
+            type: 'mcfunction:command_child/unknown',
+            range,
+            value,
+        };
+    };
+}
+const trailing = (src, ctx) => {
+    const start = src.cursor;
+    const value = src.readUntilLineEnd();
+    const range = core.Range.create(start, src);
+    ctx.err.report((0, locales_1.localize)('mcfunction.parser.trailing', (0, locales_1.localeQuote)(value)), range);
+    return {
+        type: 'mcfunction:command_child/trailing',
+        range,
+        value,
+    };
+};
+function wrapWithBrackets(syntax, executable) {
+    return executable ? `[${syntax}]` : syntax;
+}
+function treeNodeChildrenToStringArray(children, executable = false) {
+    const entries = Object.entries(children)
+        .map(([name, treeNode]) => wrapWithBrackets(treeNodeToString(name, treeNode), executable));
+    return entries;
+}
+exports.treeNodeChildrenToStringArray = treeNodeChildrenToStringArray;
+function treeNodeChildrenToString(children) {
+    const entries = treeNodeChildrenToStringArray(children);
+    return entries.length > 5
+        ? `${entries.slice(0, 3).join('|')}|...|${entries.slice(-2).join('|')}`
+        : entries.join('|');
+}
+exports.treeNodeChildrenToString = treeNodeChildrenToString;
+function treeNodeToString(name, treeNode) {
+    if (treeNode.type === 'argument') {
+        return (0, argument_1.argumentTreeNodeToString)(name, treeNode);
+    }
+    else {
+        return name;
+    }
+}
+exports.treeNodeToString = treeNodeToString;
+//# sourceMappingURL=command.js.map

package/lib/parser/common.d.ts

@@ -0,0 +1,8 @@
+import * as core from '@spyglassmc/core';
+/**
+ * A parser that takes a continuous sequence of spaces and tabs, and marks an error if it is not a single space.
+ *
+ * @returns The accepted spaces and tabs.
+ */
+export declare const sep: core.InfallibleParser<string>;
+//# sourceMappingURL=common.d.ts.map

package/lib/parser/common.js

@@ -0,0 +1,39 @@
+"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.sep = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const locales_1 = require("@spyglassmc/locales");
+/**
+ * A parser that takes a continuous sequence of spaces and tabs, and marks an error if it is not a single space.
+ *
+ * @returns The accepted spaces and tabs.
+ */
+const sep = (src, ctx) => {
+    const start = src.cursor;
+    const ans = src.readSpace();
+    if (ans !== ' ') {
+        ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('mcfunction.parser.sep', (0, locales_1.localeQuote)(' '))), core.Range.create(start, src));
+    }
+    return ans;
+};
+exports.sep = sep;
+//# sourceMappingURL=common.js.map

package/lib/parser/entry.d.ts

@@ -0,0 +1,8 @@
+import * as core from '@spyglassmc/core';
+import type { McfunctionNode } from '../node';
+import type { ArgumentParserGetter } from './argument';
+/**
+ * @throws When there's no command tree associated with `commandTreeName`.
+ */
+export declare function entry(commandTreeName: string, argument: ArgumentParserGetter): core.Parser<McfunctionNode>;
+//# sourceMappingURL=entry.d.ts.map

package/lib/parser/entry.js

@@ -0,0 +1,55 @@
+"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.entry = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const tree_1 = require("../tree");
+const command_1 = require("./command");
+/**
+ * @throws When there's no command tree associated with `commandTreeName`.
+ */
+function entry(commandTreeName, argument) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'mcfunction:entry',
+            range: core.Range.create(src),
+            children: [],
+        };
+        while (src.skipWhitespace().canReadInLine()) {
+            let result;
+            if (src.peek() === '#') {
+                result = comment(src, ctx);
+            }
+            else {
+                result = (0, command_1.command)(tree_1.CommandTreeRegistry.instance.get(commandTreeName), argument)(src, ctx);
+            }
+            ans.children.push(result);
+            src.nextLine();
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.entry = entry;
+const comment = core.comment({
+    singleLinePrefixes: new Set(['#']),
+});
+//# sourceMappingURL=entry.js.map

package/lib/parser/index.d.ts

@@ -0,0 +1,6 @@
+export * from './argument';
+export * from './command';
+export * from './common';
+export * from './entry';
+export * from './literal';
+//# sourceMappingURL=index.d.ts.map

package/lib/parser/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./argument"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./entry"), exports);
+__exportStar(require("./literal"), exports);
+//# sourceMappingURL=index.js.map

package/lib/parser/literal.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import type { LiteralCommandChildNode } from '../node';
+export declare function literal(names: string[], isRoot?: boolean): core.Parser<LiteralCommandChildNode>;
+//# sourceMappingURL=literal.d.ts.map

package/lib/parser/literal.js

@@ -0,0 +1,49 @@
+"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.literal = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const locales_1 = require("@spyglassmc/locales");
+function literal(names, isRoot = false) {
+    const options = {
+        pool: names,
+        colorTokenType: isRoot ? 'keyword' : 'literal',
+    };
+    return (src, ctx) => {
+        const start = src.cursor;
+        const value = src.readUntil(' ', '\r', '\n');
+        if (!value.length) {
+            return core.Failure;
+        }
+        const ans = {
+            type: 'mcfunction:command_child/literal',
+            range: core.Range.create(start, src),
+            options,
+            value,
+        };
+        if (!names.includes(value)) {
+            ctx.err.report((0, locales_1.localize)('expected', names), ans);
+        }
+        return ans;
+    };
+}
+exports.literal = literal;
+//# sourceMappingURL=literal.js.map

package/lib/tree/index.d.ts

@@ -0,0 +1,4 @@
+export * from './registry';
+export * from './type';
+export * from './util';
+//# sourceMappingURL=index.d.ts.map

package/lib/tree/index.js

@@ -0,0 +1,16 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./registry"), exports);
+__exportStar(require("./type"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=index.js.map

package/lib/tree/registry.d.ts

@@ -0,0 +1,27 @@
+import type { PartialRootTreeNode, RootTreeNode } from './type';
+/**
+ * The registry for mcfunction command trees.
+ * This is a singleton; use the `instance` static property to get an instance.
+ */
+export declare class CommandTreeRegistry {
+    #private;
+    /**
+     * Register command tree for an arbitrary version.
+     *
+     * @param version The game version. e.g. `1.15-tdn`.
+     * @param tree The command tree for this version.
+     * @param treePatch A custom command tree patch that will be merged onto `tree`.
+     */
+    register(version: string, tree: RootTreeNode, treePatch?: PartialRootTreeNode): void;
+    /**
+     * @throws When there's no command tree associated with the version.
+     */
+    get(version: string): RootTreeNode;
+    /**
+     * An instance of `CommandTreeRegistry`.
+     */
+    static get instance(): CommandTreeRegistry;
+    private constructor();
+    private static _instance;
+}
+//# sourceMappingURL=registry.d.ts.map

package/lib/tree/registry.js

@@ -0,0 +1,60 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CommandTreeRegistry_trees;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandTreeRegistry = void 0;
+const core_1 = require("@spyglassmc/core");
+/* istanbul ignore next */
+/**
+ * The registry for mcfunction command trees.
+ * This is a singleton; use the `instance` static property to get an instance.
+ */
+class CommandTreeRegistry {
+    constructor() {
+        _CommandTreeRegistry_trees.set(this, new Map()
+        /**
+         * Register command tree for an arbitrary version.
+         *
+         * @param version The game version. e.g. `1.15-tdn`.
+         * @param tree The command tree for this version.
+         * @param treePatch A custom command tree patch that will be merged onto `tree`.
+         */
+        );
+        if (CommandTreeRegistry._instance) {
+            throw new Error('Use the `instance` static property to get an instance.');
+        }
+    }
+    /**
+     * Register command tree for an arbitrary version.
+     *
+     * @param version The game version. e.g. `1.15-tdn`.
+     * @param tree The command tree for this version.
+     * @param treePatch A custom command tree patch that will be merged onto `tree`.
+     */
+    register(version, tree, treePatch) {
+        __classPrivateFieldGet(this, _CommandTreeRegistry_trees, "f").set(version, treePatch ? (0, core_1.merge)(tree, treePatch) : tree);
+    }
+    /**
+     * @throws When there's no command tree associated with the version.
+     */
+    get(version) {
+        const ans = __classPrivateFieldGet(this, _CommandTreeRegistry_trees, "f").get(version);
+        if (!ans) {
+            throw new Error(`No command tree exist for version “${version}”`);
+        }
+        return ans;
+    }
+    /**
+     * An instance of `CommandTreeRegistry`.
+     */
+    static get instance() {
+        return this._instance ?? (this._instance = new CommandTreeRegistry());
+    }
+}
+exports.CommandTreeRegistry = CommandTreeRegistry;
+_CommandTreeRegistry_trees = new WeakMap();
+//# sourceMappingURL=registry.js.map

package/lib/tree/type.d.ts

@@ -0,0 +1,32 @@
+interface BaseTreeNode {
+    type: string;
+    children?: {
+        [name: string]: TreeNode;
+    };
+    executable?: boolean;
+    redirect?: readonly string[];
+    /**
+     * The permission level required to use this node.
+     * @default 2
+     */
+    permission?: 0 | 1 | 2 | 3 | 4;
+}
+export interface ArgumentTreeNode extends BaseTreeNode {
+    type: 'argument';
+    parser: string;
+    properties?: Record<string, unknown>;
+}
+export interface LiteralTreeNode extends BaseTreeNode {
+    type: 'literal';
+}
+export interface RootTreeNode extends BaseTreeNode {
+    type: 'root';
+}
+export declare type TreeNode = ArgumentTreeNode | LiteralTreeNode | RootTreeNode;
+declare type RecursivePartial<T> = T extends object ? {
+    [K in keyof T]?: RecursivePartial<T[K]>;
+} : T;
+export declare type PartialTreeNode = RecursivePartial<TreeNode>;
+export declare type PartialRootTreeNode = RecursivePartial<RootTreeNode>;
+export {};
+//# sourceMappingURL=type.d.ts.map

package/lib/tree/type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=type.js.map

package/lib/tree/util.d.ts

@@ -0,0 +1,21 @@
+import type { ArgumentTreeNode, LiteralTreeNode, RootTreeNode, TreeNode } from './type';
+export declare function redirect(rootTreeNode: TreeNode, path: readonly string[]): TreeNode | undefined;
+/**
+ * @returns A `TreeNode` whose `children` property, if exists, contains its subsequent `TreeNode`s.
+ */
+export declare function resolveParentTreeNode(parentTreeNode: TreeNode | undefined, rootTreeNode: RootTreeNode): {
+    treeNode: TreeNode | undefined;
+    path: undefined;
+};
+export declare function resolveParentTreeNode(parentTreeNode: TreeNode | undefined, rootTreeNode: RootTreeNode, parentPath: string[]): {
+    treeNode: TreeNode | undefined;
+    path: string[];
+};
+/**
+ * Categorize command tree children to literal entries and argument entries.
+ */
+export declare function categorizeTreeChildren(children: Exclude<TreeNode['children'], undefined>): {
+    literalTreeNodes: [string, LiteralTreeNode][];
+    argumentTreeNodes: [string, ArgumentTreeNode][];
+};
+//# sourceMappingURL=util.d.ts.map

package/lib/tree/util.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorizeTreeChildren = exports.resolveParentTreeNode = exports.redirect = void 0;
+function redirect(rootTreeNode, path) {
+    return path.reduce((p, c) => p?.children?.[c], rootTreeNode);
+}
+exports.redirect = redirect;
+function resolveParentTreeNode(parentTreeNode, rootTreeNode, parentPath) {
+    if (parentTreeNode?.redirect) {
+        return { treeNode: redirect(rootTreeNode, parentTreeNode.redirect), path: [...parentTreeNode.redirect] };
+    }
+    else if (parentTreeNode && !parentTreeNode.children && !parentTreeNode.executable) {
+        // The `execute.run` literal tree node doesn't have any property.
+        // We should use children from the root tree node in this case.
+        return { treeNode: rootTreeNode, path: [] };
+    }
+    else {
+        return { treeNode: parentTreeNode, path: parentPath };
+    }
+}
+exports.resolveParentTreeNode = resolveParentTreeNode;
+/**
+ * Categorize command tree children to literal entries and argument entries.
+ */
+function categorizeTreeChildren(children) {
+    const ans = {
+        literalTreeNodes: [],
+        argumentTreeNodes: [],
+    };
+    for (const e of Object.entries(children)) {
+        /* istanbul ignore else */
+        if (e[1].type === 'literal') {
+            ans.literalTreeNodes.push(e);
+        }
+        else if (e[1].type === 'argument') {
+            ans.argumentTreeNodes.push(e);
+        }
+    }
+    return ans;
+}
+exports.categorizeTreeChildren = categorizeTreeChildren;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@spyglassmc/mcfunction",
+  "version": "0.1.0",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "author": "SPGoding",
+  "license": "MIT",
+  "directories": {
+    "test": "test/"
+  },
+  "scripts": {
+    "release": "npm publish",
+    "release:dry": "npm publish --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SpyglassMC/Spyglass.git"
+  },
+  "homepage": "https://spyglassmc.com",
+  "bugs": {
+    "url": "https://github.com/SpyglassMC/Spyglass/issues"
+  },
+  "dependencies": {
+    "@spyglassmc/core": "0.1.0",
+    "@spyglassmc/locales": "0.1.0"
+  }
+}