@spyglassmc/mcfunction 0.2.6 → 0.2.8

package/lib/colorizer/index.d.ts

@@ -1,5 +1,3 @@
 import * as core from '@spyglassmc/core';
-import type { CommandMacroNode } from '../node/index.js';
 export declare function register(meta: core.MetaRegistry): void;
-export declare const macro: core.Colorizer<CommandMacroNode>;
 //# sourceMappingURL=index.d.ts.map

package/lib/colorizer/index.js

@@ -1,10 +1,8 @@
 import * as core from '@spyglassmc/core';
+import { macro } from './macro.js';
 export function register(meta) {
-    meta.registerColorizer('mcfunction:command_macro', macro);
     meta.registerColorizer('mcfunction:command_child/literal', core.colorizer.literal);
     meta.registerColorizer('mcfunction:command_child/trailing', core.colorizer.error);
+    meta.registerColorizer('mcfunction:macro', macro);
 }
-export const macro = (node, ctx) => {
-    return [core.ColorToken.create(node, 'string')];
-};
 //# sourceMappingURL=index.js.map

package/lib/colorizer/macro.d.ts

@@ -0,0 +1,4 @@
+import * as core from '@spyglassmc/core';
+import type { MacroNode } from '../node/macro';
+export declare const macro: core.Colorizer<MacroNode>;
+//# sourceMappingURL=macro.d.ts.map

package/lib/colorizer/macro.js

@@ -0,0 +1,21 @@
+import * as core from '@spyglassmc/core';
+export const macro = (node, ctx) => {
+    const tokens = [];
+    tokens.push(core.ColorToken.create(core.Range.create(node.range.start, node.range.start + 1), 'literal')); // Dollar Sign
+    for (const child of node.children) {
+        if (child.type === 'mcfunction:macro/other') {
+            tokens.push(core.ColorToken.create(child.range, 'string'));
+        }
+        else {
+            const { start, end } = child.range;
+            // $(
+            tokens.push(core.ColorToken.create(core.Range.create(start, start + 2), 'literal'));
+            // Key
+            tokens.push(core.ColorToken.create(core.Range.create(start + 2, end - 1), 'property'));
+            // )
+            tokens.push(core.ColorToken.create(core.Range.create(end - 1, end), 'literal'));
+        }
+    }
+    return tokens;
+};
+//# sourceMappingURL=macro.js.map

package/lib/completer/index.d.ts

@@ -2,11 +2,11 @@ import * as core from '@spyglassmc/core';
 import type { McfunctionNode } from '../node/index.js';
 import { CommandNode } from '../node/index.js';
 import type { ArgumentTreeNode, RootTreeNode } from '../tree/index.js';
-export type MockNodesGetter = (treeNode: ArgumentTreeNode, range: core.RangeLike) => core.Arrayable<core.AstNode>;
+export type MockNodesGetter = (treeNode: ArgumentTreeNode, range: core.CompleterContext) => 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 entry(tree: RootTreeNode, 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

@@ -1,16 +1,14 @@
 import * as core from '@spyglassmc/core';
-import { CommandMacroNode } from '../node/index.js';
-import { CommandNode } from '../node/index.js';
-import { categorizeTreeChildren, CommandTreeRegistry, redirect, resolveParentTreeNode, } from '../tree/index.js';
+import { CommandNode, MacroNode } from '../node/index.js';
+import { categorizeTreeChildren, redirect, resolveParentTreeNode } from '../tree/index.js';
 /**
  * @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 function entry(commandTreeName, getMockNodes) {
+export function entry(tree, getMockNodes) {
     return (node, ctx) => {
-        const tree = CommandTreeRegistry.instance.get(commandTreeName);
         const childNode = core.AstNode.findChild(node, ctx.offset, true);
-        if (core.CommentNode.is(childNode) || CommandMacroNode.is(childNode)) {
+        if (core.CommentNode.is(childNode) || MacroNode.is(childNode)) {
             return [];
         }
         else {
@@ -21,15 +19,14 @@ export function entry(commandTreeName, getMockNodes) {
 export function command(tree, getMockNodes) {
     return (node, ctx) => {
         const index = core.AstNode.findChildIndex(node, ctx.offset, true);
-        const selectedChildNode = node.children[index]?.children[0];
+        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 /* core.CompletionKind.Keyword */,
-            }));
+            return Object.keys(tree.children ?? {}).map((v) => core.CompletionItem.create(v, ctx.offset, { kind: 14 /* core.CompletionKind.Keyword */ }));
         }
         const treePath = lastChildNode.path;
         const { treeNode: parentTreeNode } = resolveParentTreeNode(redirect(tree, treePath), tree);
@@ -38,10 +35,8 @@ export function command(tree, getMockNodes) {
         }
         const { literalTreeNodes, argumentTreeNodes } = categorizeTreeChildren(parentTreeNode.children);
         return [
-            ...literalTreeNodes.map(([name]) => core.CompletionItem.create(name, ctx.offset, {
-                kind: 14 /* core.CompletionKind.Keyword */,
-            })),
-            ...argumentTreeNodes.flatMap(([_name, treeNode]) => core.Arrayable.toArray(getMockNodes(treeNode, ctx.offset)).flatMap((n) => core.completer.dispatch(n, ctx))),
+            ...literalTreeNodes.map(([name]) => core.CompletionItem.create(name, ctx.offset, { kind: 14 /* core.CompletionKind.Keyword */ })),
+            ...argumentTreeNodes.flatMap(([_name, treeNode]) => core.Arrayable.toArray(getMockNodes(treeNode, ctx)).flatMap((n) => core.completer.dispatch(n, ctx))),
         ];
     };
 }

package/lib/node/command.d.ts

@@ -4,15 +4,9 @@ export interface CommandNode extends core.SequenceNode<CommandChildNode> {
     slash?: core.Range;
 }
 export declare namespace CommandNode {
-    function is(node: core.AstNode): node is CommandNode;
+    function is<T extends core.DeepReadonly<core.AstNode> | undefined>(node: T): node is core.InheritReadonly<CommandNode, T>;
     function mock(range: core.RangeLike): CommandNode;
 }
-export interface CommandMacroNode extends core.AstNode {
-    type: 'mcfunction:command_macro';
-}
-export declare namespace CommandMacroNode {
-    function is<T extends core.DeepReadonly<core.AstNode> | undefined>(obj: T): obj is core.InheritReadonly<CommandMacroNode, T>;
-}
 export interface CommandChildNode extends core.AstNode {
     type: 'mcfunction:command_child';
     /**

package/lib/node/command.js

@@ -3,26 +3,14 @@ export var CommandNode;
 (function (CommandNode) {
     /* istanbul ignore next */
     function is(node) {
-        return node.type === 'mcfunction:command';
+        return node?.type === 'mcfunction:command';
     }
     CommandNode.is = is;
     function mock(range) {
-        return {
-            type: 'mcfunction:command',
-            range: core.Range.get(range),
-            children: [],
-        };
+        return { type: 'mcfunction:command', range: core.Range.get(range), children: [] };
     }
     CommandNode.mock = mock;
 })(CommandNode || (CommandNode = {}));
-export var CommandMacroNode;
-(function (CommandMacroNode) {
-    function is(obj) {
-        return obj?.type ===
-            'mcfunction:command_macro';
-    }
-    CommandMacroNode.is = is;
-})(CommandMacroNode || (CommandMacroNode = {}));
 export var CommandChildNode;
 (function (CommandChildNode) {
     function is(node) {
@@ -33,8 +21,8 @@ export var CommandChildNode;
 export var LiteralCommandChildNode;
 (function (LiteralCommandChildNode) {
     function is(node) {
-        return (node?.type ===
-            'mcfunction:command_child/literal');
+        return (node?.type
+            === 'mcfunction:command_child/literal');
     }
     LiteralCommandChildNode.is = is;
 })(LiteralCommandChildNode || (LiteralCommandChildNode = {}));

package/lib/node/entry.d.ts

@@ -1,6 +1,7 @@
 import type * as core from '@spyglassmc/core';
-import type { CommandMacroNode, CommandNode } from './command.js';
-export interface McfunctionNode extends core.SequenceNode<CommandNode | CommandMacroNode | core.CommentNode> {
+import type { CommandNode } from './command.js';
+import type { MacroNode } from './macro.js';
+export interface McfunctionNode extends core.SequenceNode<CommandNode | MacroNode | core.CommentNode> {
     type: 'mcfunction:entry';
 }
 export declare namespace McfunctionNode {

package/lib/node/index.d.ts

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

package/lib/node/index.js

@@ -1,3 +1,4 @@
 export * from './command.js';
 export * from './entry.js';
+export * from './macro.js';
 //# sourceMappingURL=index.js.map

package/lib/node/macro.d.ts

@@ -0,0 +1,18 @@
+import * as core from '@spyglassmc/core';
+export interface MacroNode extends core.SequenceNode<MacroOtherNode | MacroArgumentNode> {
+    type: 'mcfunction:macro';
+    children: (MacroOtherNode | MacroArgumentNode)[];
+}
+export declare namespace MacroNode {
+    function is<T extends core.DeepReadonly<core.AstNode> | undefined>(obj: T): obj is core.InheritReadonly<MacroNode, T>;
+    function mock(range: core.RangeLike): MacroNode;
+}
+export interface MacroOtherNode extends core.AstNode {
+    type: 'mcfunction:macro/other';
+    value?: string;
+}
+export interface MacroArgumentNode extends core.AstNode {
+    type: 'mcfunction:macro/argument';
+    value?: string;
+}
+//# sourceMappingURL=macro.d.ts.map

package/lib/node/macro.js

@@ -0,0 +1,14 @@
+import * as core from '@spyglassmc/core';
+export var MacroNode;
+(function (MacroNode) {
+    /* istanbul ignore next */
+    function is(obj) {
+        return obj?.type === 'mcfunction:macro';
+    }
+    MacroNode.is = is;
+    function mock(range) {
+        return { type: 'mcfunction:macro', range: core.Range.get(range), children: [] };
+    }
+    MacroNode.mock = mock;
+})(MacroNode || (MacroNode = {}));
+//# sourceMappingURL=macro.js.map

package/lib/parser/command.js

@@ -48,10 +48,7 @@ function dispatch(ans, src, ctx, path, rootTreeNode, parentTreeNode, argument) {
             return false;
         }
         const { literalTreeNodes, argumentTreeNodes } = categorizeTreeChildren(children);
-        const argumentParsers = argumentTreeNodes.map(([name, treeNode]) => ({
-            name,
-            parser: argument(treeNode) ?? unknown(treeNode),
-        }));
+        const argumentParsers = argumentTreeNodes.map(([name, treeNode]) => ({ name, parser: argument(treeNode) ?? unknown(treeNode) }));
         const literalParser = literalTreeNodes.length
             ? literal(literalTreeNodes.map(([name, _treeNode]) => name), parent.type === 'root')
             : undefined;
@@ -60,11 +57,14 @@ function dispatch(ans, src, ctx, path, rootTreeNode, parentTreeNode, argument) {
             ...argumentParsers.map((v) => v.parser),
         ];
         const out = { index: 0 };
+        if (parsers.length === 0) {
+            return false;
+        }
         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 - (literalParser ? 1 : 0)]?.name ??
-                result.value;
+            const takenName = argumentParsers[out.index - (literalParser ? 1 : 0)]?.name
+                ?? result.value;
             const childPath = [...path, takenName];
             ans.push({
                 type: 'mcfunction:command_child',
@@ -80,8 +80,7 @@ function dispatch(ans, src, ctx, path, rootTreeNode, parentTreeNode, argument) {
             if (ctx.config.env.permissionLevel < requiredPermissionLevel) {
                 ctx.err.report(localize('mcfunction.parser.no-permission', requiredPermissionLevel, ctx.config.env.permissionLevel), result);
             }
-            if (result.type ===
-                'mcfunction:command_child/unknown') {
+            if (result.type === 'mcfunction:command_child/unknown') {
                 // Encountered an unsupported parser. Stop parsing this command.
                 return false;
             }
@@ -114,11 +113,7 @@ function unknown(treeNode) {
         const value = src.readUntilLineEnd();
         const range = core.Range.create(start, src);
         ctx.err.report(localize('mcfunction.parser.unknown-parser', localeQuote(treeNode.parser)), range, 0 /* core.ErrorSeverity.Hint */);
-        return {
-            type: 'mcfunction:command_child/unknown',
-            range,
-            value,
-        };
+        return { type: 'mcfunction:command_child/unknown', range, value };
     };
 }
 const trailing = (src, ctx) => {
@@ -126,11 +121,7 @@ const trailing = (src, ctx) => {
     const value = src.readUntilLineEnd();
     const range = core.Range.create(start, src);
     ctx.err.report(localize('mcfunction.parser.trailing', localeQuote(value)), range);
-    return {
-        type: 'mcfunction:command_child/trailing',
-        range,
-        value,
-    };
+    return { type: 'mcfunction:command_child/trailing', range, value };
 };
 function wrapWithBrackets(syntax, executable) {
     return executable ? `[${syntax}]` : syntax;

package/lib/parser/entry.d.ts

@@ -1,8 +1,14 @@
 import * as core from '@spyglassmc/core';
 import type { McfunctionNode } from '../node/index.js';
+import type { RootTreeNode } from '../tree/index.js';
 import type { ArgumentParserGetter } from './argument.js';
 /**
- * @throws When there's no command tree associated with `commandTreeName`.
+ * @param supportsBackslashContinuation Whether or not to concatenate lines together on trailing backslashes.
+ * @param supportsMacros Whether or not to parse macro lines as an error.
+ * Disabled by default.
  */
-export declare function entry(commandTreeName: string, argument: ArgumentParserGetter): core.Parser<McfunctionNode>;
+export declare const entry: (commandTree: RootTreeNode, argument: ArgumentParserGetter, { supportsBackslashContinuation, supportsMacros }?: {
+    supportsBackslashContinuation?: boolean | undefined;
+    supportsMacros?: boolean | undefined;
+}) => core.Parser<McfunctionNode>;
 //# sourceMappingURL=entry.d.ts.map

package/lib/parser/entry.js

@@ -1,10 +1,7 @@
 import * as core from '@spyglassmc/core';
-import { CommandTreeRegistry } from '../tree/index.js';
 import { command } from './command.js';
-/**
- * @throws When there's no command tree associated with `commandTreeName`.
- */
-export function entry(commandTreeName, argument) {
+import { macro } from './macro.js';
+function mcfunction(commandTree, argument, { supportsMacros }) {
     return (src, ctx) => {
         const ans = {
             type: 'mcfunction:entry',
@@ -17,15 +14,10 @@ export function entry(commandTreeName, argument) {
                 result = comment(src, ctx);
             }
             else if (src.peek() === '$') {
-                const start = src.cursor;
-                src.skipLine();
-                result = {
-                    type: 'mcfunction:command_macro',
-                    range: core.Range.create(start, src),
-                };
+                result = macro(supportsMacros)(src, ctx);
             }
             else {
-                result = command(CommandTreeRegistry.instance.get(commandTreeName), argument)(src, ctx);
+                result = command(commandTree, argument)(src, ctx);
             }
             ans.children.push(result);
             src.nextLine();
@@ -34,7 +26,14 @@ export function entry(commandTreeName, argument) {
         return ans;
     };
 }
-const comment = core.comment({
-    singleLinePrefixes: new Set(['#']),
-});
+const comment = core.comment({ singleLinePrefixes: new Set(['#']) });
+/**
+ * @param supportsBackslashContinuation Whether or not to concatenate lines together on trailing backslashes.
+ * @param supportsMacros Whether or not to parse macro lines as an error.
+ * Disabled by default.
+ */
+export const entry = (commandTree, argument, { supportsBackslashContinuation = false, supportsMacros = false } = {}) => {
+    const parser = mcfunction(commandTree, argument, { supportsMacros });
+    return supportsBackslashContinuation ? core.concatOnTrailingBackslash(parser) : parser;
+};
 //# sourceMappingURL=entry.js.map

package/lib/parser/index.d.ts

@@ -3,4 +3,5 @@ export * from './command.js';
 export * from './common.js';
 export * from './entry.js';
 export * from './literal.js';
+export * from './macro.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/parser/index.js

@@ -3,4 +3,5 @@ export * from './command.js';
 export * from './common.js';
 export * from './entry.js';
 export * from './literal.js';
+export * from './macro.js';
 //# sourceMappingURL=index.js.map

package/lib/parser/macro.d.ts

@@ -0,0 +1,9 @@
+import * as core from '@spyglassmc/core';
+import type { MacroNode } from '../node/index.js';
+/**
+ * Parse a macro line.
+ * @param supportsMacros When false, reports the entire line as an error (due to
+ * the Minecraft version not supporting macros).
+ */
+export declare function macro(supportsMacros?: boolean): core.Parser<MacroNode | core.ErrorNode>;
+//# sourceMappingURL=macro.d.ts.map

package/lib/parser/macro.js

@@ -0,0 +1,93 @@
+import * as core from '@spyglassmc/core';
+import { localeQuote, localize } from '@spyglassmc/locales';
+/**
+ * Parse a macro line.
+ * @param supportsMacros When false, reports the entire line as an error (due to
+ * the Minecraft version not supporting macros).
+ */
+export function macro(supportsMacros = true) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'mcfunction:macro',
+            range: core.Range.create(src.cursor),
+            children: [],
+        };
+        if (!supportsMacros) {
+            src.skipLine();
+            ans.range.end = src.cursor;
+            ctx.err.report(localize('mcfunction.parser.macro.disallowed'), ans.range);
+            return { ...ans, type: 'error' };
+        }
+        // Skip the starting '$'
+        src.skip();
+        let start = src.cursor;
+        let hasMacroArgs = false;
+        while (src.canReadInLine()) {
+            src.skipUntilOrEnd(core.LF, core.CR, '$');
+            if (src.peek(2) === '$(') {
+                hasMacroArgs = true;
+                // Add the other stuff before this macro key
+                const other = src.sliceToCursor(start);
+                if (other.length > 0) {
+                    ans.children.push({
+                        type: 'mcfunction:macro/other',
+                        range: core.Range.create(start, src.cursor),
+                        value: other,
+                    });
+                    start = src.cursor;
+                }
+                // Parse the macro key
+                const key = validateMacroArgument(src, ctx, start);
+                ans.children.push({
+                    type: 'mcfunction:macro/argument',
+                    range: core.Range.create(start, src.cursor),
+                    value: key,
+                });
+                start = src.cursor;
+            }
+            else {
+                if (src.peek() === '$') {
+                    src.skip();
+                }
+                if (!src.canReadInLine()) {
+                    // No more macro arguments, add the remaining other stuff
+                    ans.children.push({
+                        type: 'mcfunction:macro/other',
+                        range: core.Range.create(start, src.cursor),
+                        value: src.sliceToCursor(start),
+                    });
+                }
+            }
+        }
+        // A line with no macro arguments is invalid
+        if (!hasMacroArgs) {
+            ctx.err.report(localize('expected', localize('mcfunction.parser.macro.at-least-one')), core.Range.create(start, src.cursor));
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+/**
+ * Error checking for a macro argument/key.
+ */
+function validateMacroArgument(src, ctx, start) {
+    src.skip(2);
+    const keyStart = src.cursor;
+    src.skipUntilOrEnd(core.LF, core.CR, ')');
+    if (src.peek() != ')') {
+        // Macro key was not closed
+        ctx.err.report(localize('expected', localeQuote(')')), core.Range.create(keyStart, src.cursor));
+    }
+    else if (src.cursor <= keyStart) {
+        // Encountered $()
+        ctx.err.report(localize('expected', localize('mcfunction.parser.macro.key')), core.Range.create(start, src.cursor + 1));
+    }
+    const key = src.sliceToCursor(keyStart);
+    const matchedInvalid = key.replace(/[a-zA-Z0-9_]*/, '');
+    if (matchedInvalid.length > 0) {
+        ctx.err.report(localize('mcfunction.parser.macro.illegal-key', matchedInvalid.charAt(0)), core.Range.create(keyStart, src.cursor));
+    }
+    src.skip();
+    return key;
+}
+//# sourceMappingURL=macro.js.map

package/lib/tree/index.d.ts

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

package/lib/tree/index.js

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

package/lib/tree/util.js

@@ -8,9 +8,7 @@ export function resolveParentTreeNode(parentTreeNode, rootTreeNode, parentPath)
             path: [...parentTreeNode.redirect],
         };
     }
-    else if (parentTreeNode &&
-        !parentTreeNode.children &&
-        !parentTreeNode.executable) {
+    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: [] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcfunction",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.4",
-    "@spyglassmc/locales": "0.3.4"
+    "@spyglassmc/core": "0.4.6",
+    "@spyglassmc/locales": "0.3.6"
   }
 }

package/lib/tree/registry.d.ts

@@ -1,27 +0,0 @@
-import type { PartialRootTreeNode, RootTreeNode } from './type.js';
-/**
- * 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

@@ -1,42 +0,0 @@
-import { merge } from '@spyglassmc/core';
-/* istanbul ignore next */
-/**
- * The registry for mcfunction command trees.
- * This is a singleton; use the `instance` static property to get an instance.
- */
-export class CommandTreeRegistry {
-    #trees = 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`.
-     */
-    register(version, tree, treePatch) {
-        this.#trees.set(version, treePatch ? merge(tree, treePatch) : tree);
-    }
-    /**
-     * @throws When there's no command tree associated with the version.
-     */
-    get(version) {
-        const ans = this.#trees.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());
-    }
-    constructor() {
-        if (CommandTreeRegistry._instance) {
-            throw new Error('Use the `instance` static property to get an instance.');
-        }
-    }
-    static _instance;
-}
-//# sourceMappingURL=registry.js.map