@spyglassmc/mcdoc 0.3.3 → 0.3.4

package/lib/node/index.js

@@ -1,11 +1,14 @@
 import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
-export const ModuleNode = Object.freeze({
-    is(node) {
+export var ModuleNode;
+(function (ModuleNode) {
+    function is(node) {
         return node?.type === 'mcdoc:module';
-    },
-});
-export const TopLevelNode = Object.freeze({
-    is(node) {
+    }
+    ModuleNode.is = is;
+})(ModuleNode || (ModuleNode = {}));
+export var TopLevelNode;
+(function (TopLevelNode) {
+    function is(node) {
         return (CommentNode.is(node) ||
             DispatchStatementNode.is(node) ||
             EnumNode.is(node) ||
@@ -13,10 +16,12 @@ export const TopLevelNode = Object.freeze({
             StructNode.is(node) ||
             TypeAliasNode.is(node) ||
             UseStatementNode.is(node));
-    },
-});
-export const DispatchStatementNode = Object.freeze({
-    destruct(node) {
+    }
+    TopLevelNode.is = is;
+})(TopLevelNode || (TopLevelNode = {}));
+export var DispatchStatementNode;
+(function (DispatchStatementNode) {
+    function destruct(node) {
         return {
             attributes: node.children.filter(AttributeNode.is),
             location: node.children.find(ResourceLocationNode.is),
@@ -24,62 +29,81 @@ export const DispatchStatementNode = Object.freeze({
             target: node.children.find(TypeNode.is),
             typeParams: node.children.find(TypeParamBlockNode.is),
         };
-    },
-    is(node) {
+    }
+    DispatchStatementNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:dispatch_statement');
-    },
-});
-export const LiteralNode = Object.freeze({
-    is(node) {
+    }
+    DispatchStatementNode.is = is;
+})(DispatchStatementNode || (DispatchStatementNode = {}));
+export var LiteralNode;
+(function (LiteralNode) {
+    function is(node) {
         return node?.type === 'mcdoc:literal';
-    },
-});
-export const IndexBodyNode = Object.freeze({
-    destruct(node) {
+    }
+    LiteralNode.is = is;
+})(LiteralNode || (LiteralNode = {}));
+export var IndexBodyNode;
+(function (IndexBodyNode) {
+    function destruct(node) {
         return {
             parallelIndices: node.children.filter(IndexNode.is),
         };
-    },
-    is(node) {
+    }
+    IndexBodyNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:index_body';
-    },
-});
-export const IndexNode = Object.freeze({
-    is(node) {
+    }
+    IndexBodyNode.is = is;
+})(IndexBodyNode || (IndexBodyNode = {}));
+export var IndexNode;
+(function (IndexNode) {
+    function is(node) {
         return StaticIndexNode.is(node) || DynamicIndexNode.is(node);
-    },
-});
-export const StaticIndexNode = Object.freeze({
-    is(node) {
+    }
+    IndexNode.is = is;
+})(IndexNode || (IndexNode = {}));
+export var StaticIndexNode;
+(function (StaticIndexNode) {
+    function is(node) {
         return (LiteralNode.is(node) ||
             IdentifierNode.is(node) ||
             StringNode.is(node) ||
             ResourceLocationNode.is(node));
-    },
-});
-export const IdentifierNode = Object.freeze({
-    is(node) {
+    }
+    StaticIndexNode.is = is;
+})(StaticIndexNode || (StaticIndexNode = {}));
+export var IdentifierNode;
+(function (IdentifierNode) {
+    function is(node) {
         return node?.type === 'mcdoc:identifier';
-    },
-});
-export const DynamicIndexNode = Object.freeze({
-    destruct(node) {
+    }
+    IdentifierNode.is = is;
+})(IdentifierNode || (IdentifierNode = {}));
+export var DynamicIndexNode;
+(function (DynamicIndexNode) {
+    function destruct(node) {
         return {
             keys: node.children.filter(AccessorKeyNode.is),
         };
-    },
-    is(node) {
+    }
+    DynamicIndexNode.destruct = destruct;
+    function is(node) {
         return (node?.type === 'mcdoc:dynamic_index');
-    },
-});
-export const AccessorKeyNode = Object.freeze({
-    is(node) {
+    }
+    DynamicIndexNode.is = is;
+})(DynamicIndexNode || (DynamicIndexNode = {}));
+export var AccessorKeyNode;
+(function (AccessorKeyNode) {
+    function is(node) {
         return (LiteralNode.is(node) || IdentifierNode.is(node) || StringNode.is(node));
-    },
-});
-export const TypeNode = Object.freeze({
-    is(node) {
+    }
+    AccessorKeyNode.is = is;
+})(AccessorKeyNode || (AccessorKeyNode = {}));
+export var TypeNode;
+(function (TypeNode) {
+    function is(node) {
         return (AnyTypeNode.is(node) ||
             BooleanTypeNode.is(node) ||
             StringTypeNode.is(node) ||
@@ -93,57 +117,72 @@ export const TypeNode = Object.freeze({
             ReferenceTypeNode.is(node) ||
             DispatcherTypeNode.is(node) ||
             UnionTypeNode.is(node));
-    },
-});
-export const TypeBaseNode = Object.freeze({
-    destruct(node) {
+    }
+    TypeNode.is = is;
+})(TypeNode || (TypeNode = {}));
+export var TypeBaseNode;
+(function (TypeBaseNode) {
+    function destruct(node) {
         return {
             appendixes: node.children.filter((n) => IndexBodyNode.is(n) || TypeArgBlockNode.is(n)),
             attributes: node.children.filter(AttributeNode.is),
         };
-    },
-});
-export const AttributeNode = Object.freeze({
-    destruct(node) {
+    }
+    TypeBaseNode.destruct = destruct;
+})(TypeBaseNode || (TypeBaseNode = {}));
+export var AttributeNode;
+(function (AttributeNode) {
+    function destruct(node) {
         return {
             name: node.children.find(IdentifierNode.is),
             value: node.children.find(AttributeValueNode.is),
         };
-    },
-    is(node) {
+    }
+    AttributeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:attribute';
-    },
-});
-export const AttributeValueNode = Object.freeze({
-    is(node) {
+    }
+    AttributeNode.is = is;
+})(AttributeNode || (AttributeNode = {}));
+export var AttributeValueNode;
+(function (AttributeValueNode) {
+    function is(node) {
         return TypeNode.is(node) || AttributeTreeNode.is(node);
-    },
-});
-export const AttributeTreeNode = Object.freeze({
-    destruct(node) {
+    }
+    AttributeValueNode.is = is;
+})(AttributeValueNode || (AttributeValueNode = {}));
+export var AttributeTreeNode;
+(function (AttributeTreeNode) {
+    function destruct(node) {
         return {
             positional: node.children.find(AttributeTreePosValuesNode.is),
             named: node.children.find(AttributeTreeNamedValuesNode.is),
         };
-    },
-    is(node) {
+    }
+    AttributeTreeNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:attribute/tree');
-    },
-});
-export const AttributeTreePosValuesNode = Object.freeze({
-    destruct(node) {
+    }
+    AttributeTreeNode.is = is;
+})(AttributeTreeNode || (AttributeTreeNode = {}));
+export var AttributeTreePosValuesNode;
+(function (AttributeTreePosValuesNode) {
+    function destruct(node) {
         return {
             values: node.children.filter(AttributeValueNode.is),
         };
-    },
-    is(node) {
+    }
+    AttributeTreePosValuesNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:attribute/tree/pos');
-    },
-});
-export const AttributeTreeNamedValuesNode = Object.freeze({
-    destruct(node) {
+    }
+    AttributeTreePosValuesNode.is = is;
+})(AttributeTreePosValuesNode || (AttributeTreePosValuesNode = {}));
+export var AttributeTreeNamedValuesNode;
+(function (AttributeTreeNamedValuesNode) {
+    function destruct(node) {
         const ans = {
             values: [],
         };
@@ -161,82 +200,105 @@ export const AttributeTreeNamedValuesNode = Object.freeze({
             }
         }
         return ans;
-    },
-    is(node) {
+    }
+    AttributeTreeNamedValuesNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:attribute/tree/named');
-    },
-});
-export const TypeArgBlockNode = Object.freeze({
-    destruct(node) {
+    }
+    AttributeTreeNamedValuesNode.is = is;
+})(AttributeTreeNamedValuesNode || (AttributeTreeNamedValuesNode = {}));
+export var TypeArgBlockNode;
+(function (TypeArgBlockNode) {
+    function destruct(node) {
         return {
             args: node.children.filter(TypeNode.is),
         };
-    },
-    is(node) {
+    }
+    TypeArgBlockNode.destruct = destruct;
+    function is(node) {
         return (node?.type === 'mcdoc:type_arg_block');
-    },
-});
-export const AnyTypeNode = Object.freeze({
-    is(node) {
+    }
+    TypeArgBlockNode.is = is;
+})(TypeArgBlockNode || (TypeArgBlockNode = {}));
+export var AnyTypeNode;
+(function (AnyTypeNode) {
+    function is(node) {
         return node?.type === 'mcdoc:type/any';
-    },
-});
-export const BooleanTypeNode = Object.freeze({
-    is(node) {
+    }
+    AnyTypeNode.is = is;
+})(AnyTypeNode || (AnyTypeNode = {}));
+export var BooleanTypeNode;
+(function (BooleanTypeNode) {
+    function is(node) {
         return node?.type ===
             'mcdoc:type/boolean';
-    },
-});
-export const IntRangeNode = Object.freeze({
-    destruct(node) {
+    }
+    BooleanTypeNode.is = is;
+})(BooleanTypeNode || (BooleanTypeNode = {}));
+export var IntRangeNode;
+(function (IntRangeNode) {
+    function destruct(node) {
         return destructRangeNode(node);
-    },
-    is(node) {
+    }
+    IntRangeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:int_range';
-    },
-});
-export const LiteralTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    IntRangeNode.is = is;
+})(IntRangeNode || (IntRangeNode = {}));
+export var LiteralTypeNode;
+(function (LiteralTypeNode) {
+    function destruct(node) {
         return {
             value: node.children.find(LiteralTypeValueNode.is),
         };
-    },
-    is(node) {
+    }
+    LiteralTypeNode.destruct = destruct;
+    function is(node) {
         return node?.type ===
             'mcdoc:type/literal';
-    },
-});
-export const LiteralTypeValueNode = Object.freeze({
-    is(node) {
+    }
+    LiteralTypeNode.is = is;
+})(LiteralTypeNode || (LiteralTypeNode = {}));
+export var LiteralTypeValueNode;
+(function (LiteralTypeValueNode) {
+    function is(node) {
         return (LiteralNode.is(node) || TypedNumberNode.is(node) || StringNode.is(node));
-    },
-});
-export const TypedNumberNode = Object.freeze({
-    destruct(node) {
+    }
+    LiteralTypeValueNode.is = is;
+})(LiteralTypeValueNode || (LiteralTypeValueNode = {}));
+export var TypedNumberNode;
+(function (TypedNumberNode) {
+    function destruct(node) {
         return {
             value: node.children.find(FloatNode.is),
             suffix: node.children.find(LiteralNode.is),
         };
-    },
-    is(node) {
+    }
+    TypedNumberNode.destruct = destruct;
+    function is(node) {
         return node?.type ===
             'mcdoc:typed_number';
-    },
-});
-export const NumericTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    TypedNumberNode.is = is;
+})(TypedNumberNode || (TypedNumberNode = {}));
+export var NumericTypeNode;
+(function (NumericTypeNode) {
+    function destruct(node) {
         return {
             numericKind: node.children.find(LiteralNode.is),
             valueRange: node.children.find(FloatRangeNode.is) ||
                 node.children.find(IntRangeNode.is),
         };
-    },
-    is(node) {
+    }
+    NumericTypeNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:type/numeric_type');
-    },
-});
+    }
+    NumericTypeNode.is = is;
+})(NumericTypeNode || (NumericTypeNode = {}));
 export const RangeExclusiveChar = '<';
 export function getRangeDelimiter(kind) {
     const prefix = kind & 0b10 ? RangeExclusiveChar : '';
@@ -284,16 +346,20 @@ function destructRangeNode(node) {
         return ans;
     }
 }
-export const FloatRangeNode = Object.freeze({
-    destruct(node) {
+export var FloatRangeNode;
+(function (FloatRangeNode) {
+    function destruct(node) {
         return destructRangeNode(node);
-    },
-    is(node) {
+    }
+    FloatRangeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:float_range';
-    },
-});
-export const PrimitiveArrayTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    FloatRangeNode.is = is;
+})(FloatRangeNode || (FloatRangeNode = {}));
+export var PrimitiveArrayTypeNode;
+(function (PrimitiveArrayTypeNode) {
+    function destruct(node) {
         let lengthRange;
         let valueRange;
         let afterBrackets = false;
@@ -315,55 +381,66 @@ export const PrimitiveArrayTypeNode = Object.freeze({
             lengthRange,
             valueRange,
         };
-    },
-    is(node) {
+    }
+    PrimitiveArrayTypeNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:type/primitive_array');
-    },
-});
-export const ListTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    PrimitiveArrayTypeNode.is = is;
+})(PrimitiveArrayTypeNode || (PrimitiveArrayTypeNode = {}));
+export var ListTypeNode;
+(function (ListTypeNode) {
+    function destruct(node) {
         return {
             item: node.children.find(TypeNode.is),
             lengthRange: node.children.find(IntRangeNode.is),
         };
-    },
-    is(node) {
+    }
+    ListTypeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:type/list';
-    },
-});
-export const StringTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    ListTypeNode.is = is;
+})(ListTypeNode || (ListTypeNode = {}));
+export var StringTypeNode;
+(function (StringTypeNode) {
+    function destruct(node) {
         return {
             lengthRange: node.children.find(IntRangeNode.is),
         };
-    },
-    is(node) {
+    }
+    StringTypeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:type/string';
-    },
-});
-export const TupleTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    StringTypeNode.is = is;
+})(StringTypeNode || (StringTypeNode = {}));
+export var TupleTypeNode;
+(function (TupleTypeNode) {
+    function destruct(node) {
         return {
             items: node.children.filter(TypeNode.is),
         };
-    },
-    is(node) {
+    }
+    TupleTypeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:type/tuple';
-    },
-});
-const EnumKinds = new Set([
-    'byte',
-    'short',
-    'int',
-    'long',
-    'float',
-    'double',
-    'string',
-]);
-export const EnumNode = Object.freeze({
-    kinds: EnumKinds,
-    destruct(node) {
+    }
+    TupleTypeNode.is = is;
+})(TupleTypeNode || (TupleTypeNode = {}));
+export var EnumNode;
+(function (EnumNode) {
+    EnumNode.Kinds = new Set([
+        'byte',
+        'short',
+        'int',
+        'long',
+        'float',
+        'double',
+        'string',
+    ]);
+    function destruct(node) {
         return {
             block: node.children.find(EnumBlockNode.is),
             docComments: node.children.find(DocCommentsNode.is),
@@ -373,22 +450,25 @@ export const EnumNode = Object.freeze({
         };
         function getEnumKind(node) {
             for (const literal of node.children.filter(LiteralNode.is)) {
-                if (EnumKinds.has(literal.value)) {
+                if (EnumNode.Kinds.has(literal.value)) {
                     return literal.value;
                 }
             }
             return undefined;
         }
-    },
-    is(node) {
+    }
+    EnumNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:enum';
-    },
-});
-export const DocCommentsNode = Object.freeze({
+    }
+    EnumNode.is = is;
+})(EnumNode || (EnumNode = {}));
+export var DocCommentsNode;
+(function (DocCommentsNode) {
     /**
      * @returns The text content of this doc comment block.
      */
-    asText(node) {
+    function asText(node) {
         if (!node) {
             return undefined;
         }
@@ -402,213 +482,272 @@ export const DocCommentsNode = Object.freeze({
             comments = comments.map((s) => s.slice(1));
         }
         return comments.join('\n');
-    },
-    is(node) {
+    }
+    DocCommentsNode.asText = asText;
+    function is(node) {
         return node?.type ===
             'mcdoc:doc_comments';
-    },
-});
-export const EnumBlockNode = Object.freeze({
-    destruct(node) {
+    }
+    DocCommentsNode.is = is;
+})(DocCommentsNode || (DocCommentsNode = {}));
+export var EnumBlockNode;
+(function (EnumBlockNode) {
+    function destruct(node) {
         return {
             fields: node.children.filter(EnumFieldNode.is),
         };
-    },
-    is(node) {
+    }
+    EnumBlockNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:enum/block';
-    },
-});
-export const EnumFieldNode = Object.freeze({
-    destruct(node) {
+    }
+    EnumBlockNode.is = is;
+})(EnumBlockNode || (EnumBlockNode = {}));
+export var EnumFieldNode;
+(function (EnumFieldNode) {
+    function destruct(node) {
         return {
             attributes: node.children.filter(AttributeNode.is),
             identifier: node.children.find(IdentifierNode.is),
             value: node.children.find(EnumValueNode.is),
         };
-    },
-    is(node) {
+    }
+    EnumFieldNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:enum/field';
-    },
-});
-export const EnumValueNode = Object.freeze({
-    is(node) {
+    }
+    EnumFieldNode.is = is;
+})(EnumFieldNode || (EnumFieldNode = {}));
+export var EnumValueNode;
+(function (EnumValueNode) {
+    function is(node) {
         return TypedNumberNode.is(node) || StringNode.is(node);
-    },
-});
-export const PrelimNode = Object.freeze({
-    is(node) {
+    }
+    EnumValueNode.is = is;
+})(EnumValueNode || (EnumValueNode = {}));
+export var PrelimNode;
+(function (PrelimNode) {
+    function is(node) {
         return AttributeNode.is(node) || DocCommentsNode.is(node);
-    },
-});
-export const StructNode = Object.freeze({
-    destruct(node) {
+    }
+    PrelimNode.is = is;
+})(PrelimNode || (PrelimNode = {}));
+export var StructNode;
+(function (StructNode) {
+    function destruct(node) {
         return {
             block: node.children.find(StructBlockNode.is),
             docComments: node.children.find(DocCommentsNode.is),
             identifier: node.children.find(IdentifierNode.is),
             keyword: node.children.find(LiteralNode.is),
         };
-    },
-    is(node) {
+    }
+    StructNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:struct';
-    },
-});
-export const ReferenceTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    StructNode.is = is;
+})(StructNode || (StructNode = {}));
+export var ReferenceTypeNode;
+(function (ReferenceTypeNode) {
+    function destruct(node) {
         return {
             path: node.children.find(PathNode.is),
         };
-    },
-    is(node) {
+    }
+    ReferenceTypeNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:type/reference');
-    },
-});
-export const TypeParamBlockNode = Object.freeze({
-    destruct(node) {
+    }
+    ReferenceTypeNode.is = is;
+})(ReferenceTypeNode || (ReferenceTypeNode = {}));
+export var TypeParamBlockNode;
+(function (TypeParamBlockNode) {
+    function destruct(node) {
         return {
             params: node.children.filter(TypeParamNode.is),
         };
-    },
-    is(node) {
+    }
+    TypeParamBlockNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:type_param_block');
-    },
-});
-export const TypeParamNode = Object.freeze({
-    destruct(node) {
+    }
+    TypeParamBlockNode.is = is;
+})(TypeParamBlockNode || (TypeParamBlockNode = {}));
+export var TypeParamNode;
+(function (TypeParamNode) {
+    function destruct(node) {
         return {
             // constraint: node.children.find(TypeNode.is),
             identifier: node.children.find(IdentifierNode.is),
         };
-    },
-    is(node) {
+    }
+    TypeParamNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:type_param';
-    },
-});
-export const PathNode = Object.freeze({
-    destruct(node) {
+    }
+    TypeParamNode.is = is;
+})(TypeParamNode || (TypeParamNode = {}));
+export var PathNode;
+(function (PathNode) {
+    function destruct(node) {
         const lastChild = atArray(node?.children, -1);
         return {
             children: node?.children ?? [],
             isAbsolute: node?.isAbsolute,
             lastIdentifier: IdentifierNode.is(lastChild) ? lastChild : undefined,
         };
-    },
-    is(node) {
+    }
+    PathNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:path';
-    },
-});
-export const StructBlockNode = Object.freeze({
-    destruct(node) {
+    }
+    PathNode.is = is;
+})(PathNode || (PathNode = {}));
+export var StructBlockNode;
+(function (StructBlockNode) {
+    function destruct(node) {
         return {
             fields: node.children.filter(StructFieldNode.is),
         };
-    },
-    is(node) {
+    }
+    StructBlockNode.destruct = destruct;
+    function is(node) {
         return node?.type ===
             'mcdoc:struct/block';
-    },
-});
-export const StructFieldNode = Object.freeze({
-    is(node) {
+    }
+    StructBlockNode.is = is;
+})(StructBlockNode || (StructBlockNode = {}));
+export var StructFieldNode;
+(function (StructFieldNode) {
+    function is(node) {
         return StructPairFieldNode.is(node) || StructSpreadFieldNode.is(node);
-    },
-});
-export const StructPairFieldNode = Object.freeze({
-    destruct(node) {
+    }
+    StructFieldNode.is = is;
+})(StructFieldNode || (StructFieldNode = {}));
+export var StructPairFieldNode;
+(function (StructPairFieldNode) {
+    function destruct(node) {
         return {
             attributes: node.children.filter(AttributeNode.is),
             key: node.children.find(StructKeyNode.is),
             type: node.children.find(TypeNode.is),
             isOptional: node.isOptional,
         };
-    },
-    is(node) {
+    }
+    StructPairFieldNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:struct/field/pair');
-    },
-});
-export const StructKeyNode = Object.freeze({
-    is(node) {
+    }
+    StructPairFieldNode.is = is;
+})(StructPairFieldNode || (StructPairFieldNode = {}));
+export var StructKeyNode;
+(function (StructKeyNode) {
+    function is(node) {
         return (StringNode.is(node) ||
             IdentifierNode.is(node) ||
             StructMapKeyNode.is(node));
-    },
-});
-export const StructMapKeyNode = Object.freeze({
-    destruct(node) {
+    }
+    StructKeyNode.is = is;
+})(StructKeyNode || (StructKeyNode = {}));
+export var StructMapKeyNode;
+(function (StructMapKeyNode) {
+    function destruct(node) {
         return {
             type: node.children.find(TypeNode.is),
         };
-    },
-    is(node) {
+    }
+    StructMapKeyNode.destruct = destruct;
+    function is(node) {
         return (node?.type === 'mcdoc:struct/map_key');
-    },
-});
-export const StructSpreadFieldNode = Object.freeze({
-    destruct(node) {
+    }
+    StructMapKeyNode.is = is;
+})(StructMapKeyNode || (StructMapKeyNode = {}));
+export var StructSpreadFieldNode;
+(function (StructSpreadFieldNode) {
+    function destruct(node) {
         return {
             attributes: node.children.filter(AttributeNode.is),
             type: node.children.find(TypeNode.is),
         };
-    },
-    is(node) {
+    }
+    StructSpreadFieldNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:struct/field/spread');
-    },
-});
-export const DispatcherTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    StructSpreadFieldNode.is = is;
+})(StructSpreadFieldNode || (StructSpreadFieldNode = {}));
+export var DispatcherTypeNode;
+(function (DispatcherTypeNode) {
+    function destruct(node) {
         return {
             location: node.children.find(ResourceLocationNode.is),
             index: node.children.find(IndexBodyNode.is),
         };
-    },
-    is(node) {
+    }
+    DispatcherTypeNode.destruct = destruct;
+    function is(node) {
         return (node?.type ===
             'mcdoc:type/dispatcher');
-    },
-});
-export const UnionTypeNode = Object.freeze({
-    destruct(node) {
+    }
+    DispatcherTypeNode.is = is;
+})(DispatcherTypeNode || (DispatcherTypeNode = {}));
+export var UnionTypeNode;
+(function (UnionTypeNode) {
+    function destruct(node) {
         return {
             members: node.children.filter(TypeNode.is),
         };
-    },
-    is(node) {
+    }
+    UnionTypeNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:type/union';
-    },
-});
-export const InjectionNode = Object.freeze({
-    destruct(node) {
+    }
+    UnionTypeNode.is = is;
+})(UnionTypeNode || (UnionTypeNode = {}));
+export var InjectionNode;
+(function (InjectionNode) {
+    function destruct(node) {
         return {
             injection: node.children.find(InjectionContentNode.is),
         };
-    },
-    is(node) {
+    }
+    InjectionNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:injection';
-    },
-});
-export const InjectionContentNode = Object.freeze({
-    is(node) {
+    }
+    InjectionNode.is = is;
+})(InjectionNode || (InjectionNode = {}));
+export var InjectionContentNode;
+(function (InjectionContentNode) {
+    function is(node) {
         return EnumInjectionNode.is(node) || StructInjectionNode.is(node);
-    },
-});
-export const EnumInjectionNode = Object.freeze({
-    is(node) {
+    }
+    InjectionContentNode.is = is;
+})(InjectionContentNode || (InjectionContentNode = {}));
+export var EnumInjectionNode;
+(function (EnumInjectionNode) {
+    function is(node) {
         return (node?.type ===
             'mcdoc:injection/enum');
-    },
-});
-export const StructInjectionNode = Object.freeze({
-    is(node) {
+    }
+    EnumInjectionNode.is = is;
+})(EnumInjectionNode || (EnumInjectionNode = {}));
+export var StructInjectionNode;
+(function (StructInjectionNode) {
+    function is(node) {
         return (node?.type ===
             'mcdoc:injection/struct');
-    },
-});
-export const TypeAliasNode = Object.freeze({
-    destruct(node) {
+    }
+    StructInjectionNode.is = is;
+})(StructInjectionNode || (StructInjectionNode = {}));
+export var TypeAliasNode;
+(function (TypeAliasNode) {
+    function destruct(node) {
         return {
             attributes: node.children.filter(AttributeNode.is),
             docComments: node.children.find(DocCommentsNode.is),
@@ -617,20 +756,25 @@ export const TypeAliasNode = Object.freeze({
             typeParams: node.children.find(TypeParamBlockNode.is),
             rhs: node.children.find(TypeNode.is),
         };
-    },
-    is(node) {
+    }
+    TypeAliasNode.destruct = destruct;
+    function is(node) {
         return node?.type === 'mcdoc:type_alias';
-    },
-});
-export const UseStatementNode = Object.freeze({
-    destruct(node) {
+    }
+    TypeAliasNode.is = is;
+})(TypeAliasNode || (TypeAliasNode = {}));
+export var UseStatementNode;
+(function (UseStatementNode) {
+    function destruct(node) {
         return {
             binding: node.children.find(IdentifierNode.is),
             path: node.children.find(PathNode.is),
         };
-    },
-    is(node) {
+    }
+    UseStatementNode.destruct = destruct;
+    function is(node) {
         return (node?.type === 'mcdoc:use_statement');
-    },
-});
+    }
+    UseStatementNode.is = is;
+})(UseStatementNode || (UseStatementNode = {}));
 //# sourceMappingURL=index.js.map