@spyglassmc/mcdoc 0.1.1 → 0.3.1

package/lib/colorizer/index.d.ts

@@ -1,5 +1,5 @@
 import type { Colorizer, MetaRegistry } from '@spyglassmc/core';
-import type { IdentifierNode, LiteralNode } from '../node';
+import type { IdentifierNode, LiteralNode } from '../node/index.js';
 export declare const identifier: Colorizer<IdentifierNode>;
 export declare const literal: Colorizer<LiteralNode>;
 export declare function registerMcdocColorizer(meta: MetaRegistry): void;

package/lib/colorizer/index.js

@@ -1,18 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerMcdocColorizer = exports.literal = exports.identifier = void 0;
-const core_1 = require("@spyglassmc/core");
-const identifier = node => {
-    return [core_1.ColorToken.create(node, 'variable')];
+import { ColorToken } from '@spyglassmc/core';
+export const identifier = node => {
+    return [ColorToken.create(node, 'variable')];
 };
-exports.identifier = identifier;
-const literal = node => {
-    return [core_1.ColorToken.create(node, node.colorTokenType ?? 'literal')];
+export const literal = node => {
+    return [ColorToken.create(node, node.colorTokenType ?? 'literal')];
 };
-exports.literal = literal;
-function registerMcdocColorizer(meta) {
-    meta.registerColorizer('mcdoc:literal', exports.literal);
-    meta.registerColorizer('mcdoc:identifier', exports.identifier);
+export function registerMcdocColorizer(meta) {
+    meta.registerColorizer('mcdoc:literal', literal);
+    meta.registerColorizer('mcdoc:identifier', identifier);
 }
-exports.registerMcdocColorizer = registerMcdocColorizer;
 //# sourceMappingURL=index.js.map

package/lib/{binder/util.d.ts → common.d.ts}

@@ -1,4 +1,7 @@
 export declare type Segments = readonly string[];
 export declare function identifierToSeg(identifier: string): Segments;
 export declare function segToIdentifier(seg: Segments): string;
-//# sourceMappingURL=util.d.ts.map
+export interface AdditionalContext {
+    moduleIdentifier: string;
+}
+//# sourceMappingURL=common.d.ts.map

package/lib/common.js

@@ -0,0 +1,11 @@
+export function identifierToSeg(identifier) {
+    const ans = identifier.slice(2).split('::');
+    if (ans.length === 1 && ans[0] === '') {
+        return [];
+    }
+    return ans;
+}
+export function segToIdentifier(seg) {
+    return `::${seg.join('::')}`;
+}
+//# sourceMappingURL=common.js.map

package/lib/index.d.ts

@@ -1,8 +1,11 @@
 import type * as core from '@spyglassmc/core';
-export * as checker from './checker';
-export * as colorizer from './colorizer';
-export * from './node';
-export * from './parser';
-export * from './type';
-export declare const initialize: core.ProjectInitializer;
+export * as binder from './binder/index.js';
+export * as colorizer from './colorizer/index.js';
+export * from './node/index.js';
+export * from './parser/index.js';
+export * from './type/index.js';
+export * from './uri_processors.js';
+export declare const initialize: ({ meta }: {
+    meta: core.MetaRegistry;
+}) => void;
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,50 +1,22 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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.colorizer = exports.checker = void 0;
-const binder = __importStar(require("./binder"));
-const checker = __importStar(require("./checker"));
-const colorizer = __importStar(require("./colorizer"));
-const parser = __importStar(require("./parser"));
-exports.checker = __importStar(require("./checker"));
-exports.colorizer = __importStar(require("./colorizer"));
-__exportStar(require("./node"), exports);
-__exportStar(require("./parser"), exports);
-__exportStar(require("./type"), exports);
+import * as binder from './binder/index.js';
+import * as colorizer from './colorizer/index.js';
+import * as parser from './parser/index.js';
+import * as uri_professors from './uri_processors.js';
+export * as binder from './binder/index.js';
+export * as colorizer from './colorizer/index.js';
+export * from './node/index.js';
+export * from './parser/index.js';
+export * from './type/index.js';
+export * from './uri_processors.js';
 /* istanbul ignore next */
-const initialize = ({ meta }) => {
+export const initialize = ({ meta }) => {
     meta.registerLanguage('mcdoc', {
         extensions: ['.mcdoc'],
         parser: parser.module_,
     });
-    meta.registerChecker('mcdoc:module', checker.module_);
-    meta.registerUriBinder(binder.uriBinder);
+    meta.registerUriBinder(uri_professors.uriBinder);
+    meta.setUriSorter(uri_professors.uriSorter);
+    binder.registerMcdocBinders(meta);
     colorizer.registerMcdocColorizer(meta);
 };
-exports.initialize = initialize;
 //# sourceMappingURL=index.js.map

package/lib/node/index.d.ts

@@ -1,6 +1,5 @@
-import type { AstNode, ColorTokenType, FloatNode, IntegerNode, SymbolBaseNode } from '@spyglassmc/core';
-import { CommentNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
-import type { McdocType } from '../type';
+import type { AstNode, ColorTokenType, IntegerNode, SymbolBaseNode } from '@spyglassmc/core';
+import { CommentNode, FloatNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
 export interface ModuleNode extends AstNode {
     type: 'mcdoc:module';
     children: TopLevelNode[];
@@ -17,6 +16,12 @@ export interface DispatchStatementNode extends AstNode {
     children: (CommentNode | AttributeNode | LiteralNode | ResourceLocationNode | IndexBodyNode | TypeNode)[];
 }
 export declare const DispatchStatementNode: Readonly<{
+    destruct(node: DispatchStatementNode): {
+        attributes: AttributeNode[];
+        location?: ResourceLocationNode;
+        index?: IndexBodyNode;
+        target?: TypeNode;
+    };
     is(node: AstNode | undefined): node is DispatchStatementNode;
 }>;
 export interface LiteralNode extends AstNode {
@@ -32,6 +37,9 @@ export interface IndexBodyNode extends AstNode {
     children: (CommentNode | IndexNode)[];
 }
 export declare const IndexBodyNode: Readonly<{
+    destruct(node: IndexBodyNode): {
+        parallelIndices: IndexNode[];
+    };
     is(node: AstNode | undefined): node is IndexBodyNode;
 }>;
 export declare type IndexNode = StaticIndexNode | DynamicIndexNode;
@@ -53,27 +61,38 @@ export interface DynamicIndexNode extends AstNode {
     children: (CommentNode | AccessorKeyNode)[];
 }
 export declare const DynamicIndexNode: Readonly<{
+    destruct(node: DynamicIndexNode): {
+        keys: AccessorKeyNode[];
+    };
     is(node: AstNode | undefined): node is DynamicIndexNode;
 }>;
 export declare type AccessorKeyNode = LiteralNode | IdentifierNode | StringNode;
 export declare const AccessorKeyNode: Readonly<{
     is(node: AstNode | undefined): node is AccessorKeyNode;
 }>;
-export declare type TypeNode = AnyTypeNode | BooleanTypeNode | StringTypeNode | LiteralTypeNode | NumericTypeNode | PrimitiveArrayTypeNode | ListTypeNode | TupleTypeNode | EnumNode | StructNode | PathTypeNode | DispatcherTypeNode | UnionTypeNode;
+export declare type TypeNode = AnyTypeNode | BooleanTypeNode | StringTypeNode | LiteralTypeNode | NumericTypeNode | PrimitiveArrayTypeNode | ListTypeNode | TupleTypeNode | EnumNode | StructNode | ReferenceTypeNode | DispatcherTypeNode | UnionTypeNode;
 export declare const TypeNode: Readonly<{
     is(node: AstNode | undefined): node is TypeNode;
-    asType(node: TypeNode): McdocType;
 }>;
 export interface TypeBaseNode<CN extends AstNode> extends AstNode {
     type: `mcdoc:${string}`;
     children: (CommentNode | AttributeNode | IndexBodyNode | CN)[];
 }
+export declare const TypeBaseNode: Readonly<{
+    destruct(node: TypeBaseNode<any>): {
+        attributes: AttributeNode[];
+        indices: IndexBodyNode[];
+    };
+}>;
 export interface AttributeNode extends AstNode {
     type: 'mcdoc:attribute';
     children: (CommentNode | IdentifierNode | AttributeValueNode)[];
-    sep?: boolean;
 }
 export declare const AttributeNode: Readonly<{
+    destruct(node: AttributeNode): {
+        name: IdentifierNode;
+        value: AttributeValueNode | undefined;
+    };
     is(node: AstNode | undefined): node is AttributeNode;
 }>;
 export declare type AttributeValueNode = TypeNode | AttributeTreeNode;
@@ -86,6 +105,10 @@ export interface AttributeTreeNode extends AstNode {
     delim: '(' | '[' | '{';
 }
 export declare const AttributeTreeNode: Readonly<{
+    destruct(node: AttributeTreeNode): {
+        positional?: AttributeTreePosValuesNode;
+        named?: AttributeTreeNamedValuesNode;
+    };
     is(node: AstNode | undefined): node is AttributeTreeNode;
 }>;
 export interface AttributeTreePosValuesNode extends AstNode {
@@ -93,6 +116,9 @@ export interface AttributeTreePosValuesNode extends AstNode {
     children: (CommentNode | AttributeValueNode)[];
 }
 export declare const AttributeTreePosValuesNode: Readonly<{
+    destruct(node: AttributeTreePosValuesNode): {
+        values: AttributeValueNode[];
+    };
     is(node: AstNode | undefined): node is AttributeTreePosValuesNode;
 }>;
 export interface AttributeTreeNamedValuesNode extends AstNode {
@@ -100,8 +126,15 @@ export interface AttributeTreeNamedValuesNode extends AstNode {
     children: (CommentNode | IdentifierNode | StringNode | AttributeValueNode)[];
 }
 export declare const AttributeTreeNamedValuesNode: Readonly<{
+    destruct(node: AttributeTreeNamedValuesNode): {
+        values: AttributeTreeNamedKeyValuePair[];
+    };
     is(node: AstNode | undefined): node is AttributeTreeNamedValuesNode;
 }>;
+export interface AttributeTreeNamedKeyValuePair {
+    key: IdentifierNode | StringNode;
+    value: AttributeValueNode;
+}
 export interface AnyTypeNode extends TypeBaseNode<LiteralNode> {
     type: 'mcdoc:type/any';
 }
@@ -114,83 +147,146 @@ export interface BooleanTypeNode extends TypeBaseNode<LiteralNode> {
 export declare const BooleanTypeNode: Readonly<{
     is(node: AstNode | undefined): node is BooleanTypeNode;
 }>;
-export interface StringTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode> {
-    type: 'mcdoc:type/string';
-}
-export declare const StringTypeNode: Readonly<{
-    is(node: AstNode | undefined): node is StringTypeNode;
-}>;
 export interface IntRangeNode extends AstNode {
     type: 'mcdoc:int_range';
-    children: IntegerNode[];
+    children: (IntegerNode | LiteralNode)[];
 }
 export declare const IntRangeNode: Readonly<{
+    destruct(node: IntRangeNode): {
+        kind: RangeKind;
+        min?: IntegerNode;
+        max?: IntegerNode;
+    };
     is(node: AstNode | undefined): node is IntRangeNode;
 }>;
-export interface LiteralTypeNode extends TypeBaseNode<LiteralNode | TypedNumberNode | StringNode> {
+export interface LiteralTypeNode extends TypeBaseNode<LiteralTypeValueNode> {
     type: 'mcdoc:type/literal';
 }
 export declare const LiteralTypeNode: Readonly<{
+    destruct(node: LiteralTypeNode): {
+        value: LiteralTypeValueNode;
+    };
     is(node: AstNode | undefined): node is LiteralTypeNode;
 }>;
+export declare type LiteralTypeValueNode = LiteralNode | TypedNumberNode | StringNode;
+export declare const LiteralTypeValueNode: Readonly<{
+    is(node: AstNode | undefined): node is LiteralTypeValueNode;
+}>;
 export interface TypedNumberNode extends AstNode {
     type: 'mcdoc:typed_number';
     children: (FloatNode | LiteralNode)[];
 }
 export declare const TypedNumberNode: Readonly<{
+    destruct(node: TypedNumberNode): {
+        value: FloatNode;
+        suffix?: LiteralNode;
+    };
     is(node: AstNode | undefined): node is TypedNumberNode;
 }>;
 export interface NumericTypeNode extends TypeBaseNode<LiteralNode | FloatRangeNode | IntRangeNode> {
     type: 'mcdoc:type/numeric_type';
 }
 export declare const NumericTypeNode: Readonly<{
+    destruct(node: NumericTypeNode): {
+        numericKind: LiteralNode;
+        valueRange?: FloatRangeNode | IntRangeNode;
+    };
     is(node: AstNode | undefined): node is NumericTypeNode;
 }>;
+export declare const RangeExclusiveChar = "<";
+/**
+ * A 2-bit binary number is used to represent the kind of range.
+ * The first bit from the left represents the start, the second bit from the left represents the end.
+ * The bit is turned on if the range is exclusive on that end.
+ */
+export declare type RangeKind = 0b00 | 0b01 | 0b10 | 0b11;
+export declare function getRangeDelimiter(kind: RangeKind): string;
 export interface FloatRangeNode extends AstNode {
     type: 'mcdoc:float_range';
-    children: FloatNode[];
+    children: (FloatNode | LiteralNode)[];
 }
 export declare const FloatRangeNode: Readonly<{
+    destruct(node: FloatRangeNode): {
+        kind: RangeKind;
+        min?: FloatNode;
+        max?: FloatNode;
+    };
     is(node: AstNode | undefined): node is FloatRangeNode;
 }>;
-export interface PrimitiveArrayTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode | FloatRangeNode> {
+export interface PrimitiveArrayTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode> {
     type: 'mcdoc:type/primitive_array';
 }
 export declare const PrimitiveArrayTypeNode: Readonly<{
+    destruct(node: PrimitiveArrayTypeNode): {
+        arrayKind: LiteralNode;
+        lengthRange?: IntRangeNode | undefined;
+        valueRange?: IntRangeNode | undefined;
+    };
     is(node: AstNode | undefined): node is PrimitiveArrayTypeNode;
 }>;
 export interface ListTypeNode extends TypeBaseNode<TypeNode | IntRangeNode> {
     type: 'mcdoc:type/list';
 }
 export declare const ListTypeNode: Readonly<{
+    destruct(node: ListTypeNode): {
+        item: TypeNode;
+        lengthRange?: IntRangeNode;
+    };
     is(node: AstNode | undefined): node is ListTypeNode;
 }>;
+export interface StringTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode> {
+    type: 'mcdoc:type/string';
+}
+export declare const StringTypeNode: Readonly<{
+    destruct(node: StringTypeNode): {
+        lengthRange?: IntRangeNode;
+    };
+    is(node: AstNode | undefined): node is StringTypeNode;
+}>;
 export interface TupleTypeNode extends TypeBaseNode<TypeNode> {
     type: 'mcdoc:type/tuple';
 }
 export declare const TupleTypeNode: Readonly<{
+    destruct(node: TupleTypeNode): {
+        items: TypeNode[];
+    };
     is(node: AstNode | undefined): node is TupleTypeNode;
 }>;
 export interface EnumNode extends TypeBaseNode<DocCommentsNode | LiteralNode | IdentifierNode | EnumBlockNode> {
     type: 'mcdoc:enum';
 }
+declare const EnumKinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
+export declare type EnumKind = typeof EnumKinds extends Set<infer V> ? V : never;
 export declare const EnumNode: Readonly<{
+    kinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
+    destruct(node: EnumNode): {
+        block: EnumBlockNode;
+        docComments?: DocCommentsNode;
+        enumKind?: EnumKind;
+        identifier?: IdentifierNode;
+        keyword: LiteralNode;
+    };
     is(node: AstNode | undefined): node is EnumNode;
-    kinds: Set<"string" | "float" | "long" | "short" | "double" | "byte" | "int">;
 }>;
-export declare type EnumKind = typeof EnumNode['kinds'] extends Set<infer V> ? V : never;
 export interface DocCommentsNode extends AstNode {
     type: 'mcdoc:doc_comments';
     children: CommentNode[];
 }
 export declare const DocCommentsNode: Readonly<{
+    /**
+     * @returns The text content of this doc comment block.
+     */
+    asText(node: DocCommentsNode | undefined): string | undefined;
     is(node: AstNode | undefined): node is DocCommentsNode;
 }>;
 export interface EnumBlockNode extends AstNode {
     type: 'mcdoc:enum/block';
-    children: (CommentNode | EnumFieldNode | PrelimNode)[];
+    children: (CommentNode | EnumFieldNode)[];
 }
 export declare const EnumBlockNode: Readonly<{
+    destruct(node: EnumBlockNode): {
+        fields: EnumFieldNode[];
+    };
     is(node: AstNode | undefined): node is EnumBlockNode;
 }>;
 export interface EnumFieldNode extends AstNode {
@@ -198,6 +294,11 @@ export interface EnumFieldNode extends AstNode {
     children: (CommentNode | PrelimNode | IdentifierNode | EnumValueNode)[];
 }
 export declare const EnumFieldNode: Readonly<{
+    destruct(node: EnumFieldNode): {
+        attributes: AttributeNode[];
+        identifier: IdentifierNode;
+        value: EnumValueNode;
+    };
     is(node: AstNode | undefined): node is EnumFieldNode;
 }>;
 export declare type EnumValueNode = TypedNumberNode | StringNode;
@@ -208,27 +309,46 @@ export declare type PrelimNode = AttributeNode | DocCommentsNode;
 export declare const PrelimNode: Readonly<{
     is(node: AstNode | undefined): node is PrelimNode;
 }>;
-export interface StructNode extends TypeBaseNode<DocCommentsNode | LiteralNode | IdentifierNode | TypeParamBlockNode | StructBlockNode> {
+export interface StructNode extends TypeBaseNode<DocCommentsNode | LiteralNode | IdentifierNode | StructBlockNode> {
     type: 'mcdoc:struct';
 }
 export declare const StructNode: Readonly<{
+    destruct(node: StructNode): {
+        block: StructBlockNode;
+        docComments?: DocCommentsNode;
+        identifier?: IdentifierNode;
+        keyword: LiteralNode;
+    };
     is(node: AstNode | undefined): node is StructNode;
 }>;
-export interface PathTypeNode extends TypeBaseNode<PathNode | TypeNode> {
-    type: 'mcdoc:type/path';
+export interface ReferenceTypeNode extends TypeBaseNode<PathNode | TypeNode> {
+    type: 'mcdoc:type/reference';
 }
+export declare const ReferenceTypeNode: Readonly<{
+    destruct(node: ReferenceTypeNode): {
+        path: PathNode;
+        typeParameters: TypeNode[];
+    };
+    is(node: AstNode | undefined): node is ReferenceTypeNode;
+}>;
 export interface TypeParamBlockNode extends AstNode {
     type: 'mcdoc:type_param_block';
     children: (CommentNode | TypeParamNode)[];
 }
 export declare const TypeParamBlockNode: Readonly<{
+    destruct(node: TypeParamBlockNode): {
+        params: TypeParamNode[];
+    };
     is(node: AstNode | undefined): node is TypeParamBlockNode;
 }>;
 export interface TypeParamNode extends AstNode {
     type: 'mcdoc:type_param';
-    children: (CommentNode | IdentifierNode | LiteralNode | PathNode)[];
+    children: (CommentNode | IdentifierNode | LiteralNode)[];
 }
 export declare const TypeParamNode: Readonly<{
+    destruct(node: TypeParamNode): {
+        identifier: IdentifierNode;
+    };
     is(node: AstNode | undefined): node is TypeParamNode;
 }>;
 export interface PathNode extends AstNode {
@@ -237,13 +357,21 @@ export interface PathNode extends AstNode {
     isAbsolute?: boolean;
 }
 export declare const PathNode: Readonly<{
+    destruct(node: PathNode | undefined): {
+        children: (LiteralNode | IdentifierNode)[];
+        isAbsolute?: boolean;
+        lastIdentifier?: IdentifierNode;
+    };
     is(node: AstNode | undefined): node is PathNode;
 }>;
 export interface StructBlockNode extends AstNode {
     type: 'mcdoc:struct/block';
-    children: (CommentNode | StructFieldNode | PrelimNode)[];
+    children: (CommentNode | StructFieldNode)[];
 }
 export declare const StructBlockNode: Readonly<{
+    destruct(node: StructBlockNode): {
+        fields: StructFieldNode[];
+    };
     is(node: AstNode | undefined): node is StructBlockNode;
 }>;
 export declare type StructFieldNode = StructPairFieldNode | StructSpreadFieldNode;
@@ -256,6 +384,12 @@ export interface StructPairFieldNode extends AstNode {
     isOptional?: boolean;
 }
 export declare const StructPairFieldNode: Readonly<{
+    destruct(node: StructPairFieldNode): {
+        attributes: AttributeNode[];
+        key: StructKeyNode;
+        type: TypeNode;
+        isOptional?: boolean;
+    };
     is(node: AstNode | undefined): node is StructPairFieldNode;
 }>;
 export declare type StructKeyNode = StringNode | IdentifierNode | StructMapKeyNode;
@@ -267,6 +401,9 @@ export interface StructMapKeyNode extends AstNode {
     children: (CommentNode | TypeNode)[];
 }
 export declare const StructMapKeyNode: Readonly<{
+    destruct(node: StructMapKeyNode): {
+        type: TypeNode;
+    };
     is(node: AstNode | undefined): node is StructMapKeyNode;
 }>;
 export interface StructSpreadFieldNode extends AstNode {
@@ -274,27 +411,45 @@ export interface StructSpreadFieldNode extends AstNode {
     children: (CommentNode | AttributeNode | TypeNode)[];
 }
 export declare const StructSpreadFieldNode: Readonly<{
+    destruct(node: StructSpreadFieldNode): {
+        attributes: AttributeNode[];
+        type: TypeNode;
+    };
     is(node: AstNode | undefined): node is StructSpreadFieldNode;
 }>;
 export interface DispatcherTypeNode extends TypeBaseNode<ResourceLocationNode | IndexBodyNode> {
     type: 'mcdoc:type/dispatcher';
 }
 export declare const DispatcherTypeNode: Readonly<{
+    destruct(node: DispatcherTypeNode): {
+        location: ResourceLocationNode;
+        index: IndexBodyNode;
+    };
     is(node: AstNode | undefined): node is DispatcherTypeNode;
 }>;
 export interface UnionTypeNode extends TypeBaseNode<TypeNode> {
     type: 'mcdoc:type/union';
 }
 export declare const UnionTypeNode: Readonly<{
+    destruct(node: UnionTypeNode): {
+        members: TypeNode[];
+    };
     is(node: AstNode | undefined): node is UnionTypeNode;
 }>;
 export interface InjectionNode extends AstNode {
     type: 'mcdoc:injection';
-    children: (CommentNode | LiteralNode | EnumInjectionNode | StructInjectionNode)[];
+    children: (CommentNode | LiteralNode | InjectionContentNode)[];
 }
 export declare const InjectionNode: Readonly<{
+    destruct(node: InjectionNode): {
+        injection: InjectionContentNode;
+    };
     is(node: AstNode | undefined): node is InjectionNode;
 }>;
+export declare type InjectionContentNode = EnumInjectionNode | StructInjectionNode;
+export declare const InjectionContentNode: Readonly<{
+    is(node: AstNode | undefined): node is InjectionContentNode;
+}>;
 export interface EnumInjectionNode extends AstNode {
     type: 'mcdoc:injection/enum';
     children: (CommentNode | LiteralNode | PathNode | EnumBlockNode)[];
@@ -304,16 +459,23 @@ export declare const EnumInjectionNode: Readonly<{
 }>;
 export interface StructInjectionNode extends AstNode {
     type: 'mcdoc:injection/struct';
-    children: (CommentNode | LiteralNode | PathNode | TypeParamBlockNode | StructBlockNode)[];
+    children: (CommentNode | LiteralNode | PathNode | StructBlockNode)[];
 }
 export declare const StructInjectionNode: Readonly<{
     is(node: AstNode | undefined): node is StructInjectionNode;
 }>;
 export interface TypeAliasNode extends AstNode {
     type: 'mcdoc:type_alias';
-    children: (CommentNode | PrelimNode | LiteralNode | IdentifierNode | TypeParamBlockNode | TypeNode)[];
+    children: (CommentNode | DocCommentsNode | LiteralNode | IdentifierNode | TypeParamBlockNode | TypeNode)[];
 }
 export declare const TypeAliasNode: Readonly<{
+    destruct(node: TypeAliasNode): {
+        docComments?: DocCommentsNode;
+        identifier?: IdentifierNode;
+        keyword: LiteralNode;
+        typeParams?: TypeParamBlockNode;
+        rhs?: TypeNode;
+    };
     is(node: AstNode | undefined): node is TypeAliasNode;
 }>;
 export interface UseStatementNode extends AstNode {
@@ -321,6 +483,11 @@ export interface UseStatementNode extends AstNode {
     children: (CommentNode | LiteralNode | PathNode | IdentifierNode)[];
 }
 export declare const UseStatementNode: Readonly<{
+    destruct(node: UseStatementNode): {
+        binding?: IdentifierNode;
+        path?: PathNode;
+    };
     is(node: AstNode | undefined): node is UseStatementNode;
 }>;
+export {};
 //# sourceMappingURL=index.d.ts.map