@spyglassmc/mcdoc 0.1.0

package/lib/node/index.d.ts

@@ -0,0 +1,326 @@
+import type { AstNode, ColorTokenType, FloatNode, IntegerNode, SymbolBaseNode } from '@spyglassmc/core';
+import { CommentNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+import type { McdocType } from '../type';
+export interface ModuleNode extends AstNode {
+    type: 'mcdoc:module';
+    children: TopLevelNode[];
+}
+export declare const ModuleNode: Readonly<{
+    is(node: AstNode | undefined): node is ModuleNode;
+}>;
+export declare type TopLevelNode = CommentNode | DispatchStatementNode | EnumNode | InjectionNode | StructNode | TypeAliasNode | UseStatementNode;
+export declare const TopLevelNode: Readonly<{
+    is(node: AstNode | undefined): node is TopLevelNode;
+}>;
+export interface DispatchStatementNode extends AstNode {
+    type: 'mcdoc:dispatch_statement';
+    children: (CommentNode | AttributeNode | LiteralNode | ResourceLocationNode | IndexBodyNode | TypeNode)[];
+}
+export declare const DispatchStatementNode: Readonly<{
+    is(node: AstNode | undefined): node is DispatchStatementNode;
+}>;
+export interface LiteralNode extends AstNode {
+    type: 'mcdoc:literal';
+    value: string;
+    colorTokenType?: ColorTokenType;
+}
+export declare const LiteralNode: Readonly<{
+    is(node: AstNode | undefined): node is LiteralNode;
+}>;
+export interface IndexBodyNode extends AstNode {
+    type: 'mcdoc:index_body';
+    children: (CommentNode | IndexNode)[];
+}
+export declare const IndexBodyNode: Readonly<{
+    is(node: AstNode | undefined): node is IndexBodyNode;
+}>;
+export declare type IndexNode = StaticIndexNode | DynamicIndexNode;
+export declare const IndexNode: Readonly<{
+    is(node: AstNode | undefined): node is IndexNode;
+}>;
+export declare type StaticIndexNode = LiteralNode | IdentifierNode | StringNode | ResourceLocationNode;
+export declare const StaticIndexNode: Readonly<{
+    is(node: AstNode | undefined): node is StaticIndexNode;
+}>;
+export interface IdentifierNode extends SymbolBaseNode {
+    type: 'mcdoc:identifier';
+}
+export declare const IdentifierNode: Readonly<{
+    is(node: AstNode | undefined): node is IdentifierNode;
+}>;
+export interface DynamicIndexNode extends AstNode {
+    type: 'mcdoc:dynamic_index';
+    children: (CommentNode | AccessorKeyNode)[];
+}
+export declare const DynamicIndexNode: Readonly<{
+    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 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 interface AttributeNode extends AstNode {
+    type: 'mcdoc:attribute';
+    children: (CommentNode | IdentifierNode | AttributeValueNode)[];
+    sep?: boolean;
+}
+export declare const AttributeNode: Readonly<{
+    is(node: AstNode | undefined): node is AttributeNode;
+}>;
+export declare type AttributeValueNode = TypeNode | AttributeTreeNode;
+export declare const AttributeValueNode: Readonly<{
+    is(node: AstNode | undefined): node is AttributeValueNode;
+}>;
+export interface AttributeTreeNode extends AstNode {
+    type: 'mcdoc:attribute/tree';
+    children: (CommentNode | AttributeTreePosValuesNode | AttributeTreeNamedValuesNode)[];
+    delim: '(' | '[' | '{';
+}
+export declare const AttributeTreeNode: Readonly<{
+    is(node: AstNode | undefined): node is AttributeTreeNode;
+}>;
+export interface AttributeTreePosValuesNode extends AstNode {
+    type: 'mcdoc:attribute/tree/pos';
+    children: (CommentNode | AttributeValueNode)[];
+}
+export declare const AttributeTreePosValuesNode: Readonly<{
+    is(node: AstNode | undefined): node is AttributeTreePosValuesNode;
+}>;
+export interface AttributeTreeNamedValuesNode extends AstNode {
+    type: 'mcdoc:attribute/tree/named';
+    children: (CommentNode | IdentifierNode | StringNode | AttributeValueNode)[];
+}
+export declare const AttributeTreeNamedValuesNode: Readonly<{
+    is(node: AstNode | undefined): node is AttributeTreeNamedValuesNode;
+}>;
+export interface AnyTypeNode extends TypeBaseNode<LiteralNode> {
+    type: 'mcdoc:type/any';
+}
+export declare const AnyTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is AnyTypeNode;
+}>;
+export interface BooleanTypeNode extends TypeBaseNode<LiteralNode> {
+    type: 'mcdoc:type/boolean';
+}
+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[];
+}
+export declare const IntRangeNode: Readonly<{
+    is(node: AstNode | undefined): node is IntRangeNode;
+}>;
+export interface LiteralTypeNode extends TypeBaseNode<LiteralNode | TypedNumberNode | StringNode> {
+    type: 'mcdoc:type/literal';
+}
+export declare const LiteralTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is LiteralTypeNode;
+}>;
+export interface TypedNumberNode extends AstNode {
+    type: 'mcdoc:typed_number';
+    children: (FloatNode | LiteralNode)[];
+}
+export declare const TypedNumberNode: Readonly<{
+    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<{
+    is(node: AstNode | undefined): node is NumericTypeNode;
+}>;
+export interface FloatRangeNode extends AstNode {
+    type: 'mcdoc:float_range';
+    children: FloatNode[];
+}
+export declare const FloatRangeNode: Readonly<{
+    is(node: AstNode | undefined): node is FloatRangeNode;
+}>;
+export interface PrimitiveArrayTypeNode extends TypeBaseNode<LiteralNode | IntRangeNode | FloatRangeNode> {
+    type: 'mcdoc:type/primitive_array';
+}
+export declare const PrimitiveArrayTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is PrimitiveArrayTypeNode;
+}>;
+export interface ListTypeNode extends TypeBaseNode<TypeNode | IntRangeNode> {
+    type: 'mcdoc:type/list';
+}
+export declare const ListTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is ListTypeNode;
+}>;
+export interface TupleTypeNode extends TypeBaseNode<TypeNode> {
+    type: 'mcdoc:type/tuple';
+}
+export declare const TupleTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is TupleTypeNode;
+}>;
+export interface EnumNode extends TypeBaseNode<DocCommentsNode | LiteralNode | IdentifierNode | EnumBlockNode> {
+    type: 'mcdoc:enum';
+}
+export declare const EnumNode: Readonly<{
+    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<{
+    is(node: AstNode | undefined): node is DocCommentsNode;
+}>;
+export interface EnumBlockNode extends AstNode {
+    type: 'mcdoc:enum/block';
+    children: (CommentNode | EnumFieldNode | PrelimNode)[];
+}
+export declare const EnumBlockNode: Readonly<{
+    is(node: AstNode | undefined): node is EnumBlockNode;
+}>;
+export interface EnumFieldNode extends AstNode {
+    type: 'mcdoc:enum/field';
+    children: (CommentNode | PrelimNode | IdentifierNode | EnumValueNode)[];
+}
+export declare const EnumFieldNode: Readonly<{
+    is(node: AstNode | undefined): node is EnumFieldNode;
+}>;
+export declare type EnumValueNode = TypedNumberNode | StringNode;
+export declare const EnumValueNode: Readonly<{
+    is(node: AstNode | undefined): node is EnumValueNode;
+}>;
+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> {
+    type: 'mcdoc:struct';
+}
+export declare const StructNode: Readonly<{
+    is(node: AstNode | undefined): node is StructNode;
+}>;
+export interface PathTypeNode extends TypeBaseNode<PathNode | TypeNode> {
+    type: 'mcdoc:type/path';
+}
+export interface TypeParamBlockNode extends AstNode {
+    type: 'mcdoc:type_param_block';
+    children: (CommentNode | TypeParamNode)[];
+}
+export declare const TypeParamBlockNode: Readonly<{
+    is(node: AstNode | undefined): node is TypeParamBlockNode;
+}>;
+export interface TypeParamNode extends AstNode {
+    type: 'mcdoc:type_param';
+    children: (CommentNode | IdentifierNode | LiteralNode | PathNode)[];
+}
+export declare const TypeParamNode: Readonly<{
+    is(node: AstNode | undefined): node is TypeParamNode;
+}>;
+export interface PathNode extends AstNode {
+    type: 'mcdoc:path';
+    children: (LiteralNode | IdentifierNode)[];
+    isAbsolute?: boolean;
+}
+export declare const PathNode: Readonly<{
+    is(node: AstNode | undefined): node is PathNode;
+}>;
+export interface StructBlockNode extends AstNode {
+    type: 'mcdoc:struct/block';
+    children: (CommentNode | StructFieldNode | PrelimNode)[];
+}
+export declare const StructBlockNode: Readonly<{
+    is(node: AstNode | undefined): node is StructBlockNode;
+}>;
+export declare type StructFieldNode = StructPairFieldNode | StructSpreadFieldNode;
+export declare const StructFieldNode: Readonly<{
+    is(node: AstNode | undefined): node is StructFieldNode;
+}>;
+export interface StructPairFieldNode extends AstNode {
+    type: 'mcdoc:struct/field/pair';
+    children: (CommentNode | PrelimNode | StructKeyNode | TypeNode)[];
+    isOptional?: boolean;
+}
+export declare const StructPairFieldNode: Readonly<{
+    is(node: AstNode | undefined): node is StructPairFieldNode;
+}>;
+export declare type StructKeyNode = StringNode | IdentifierNode | StructMapKeyNode;
+export declare const StructKeyNode: Readonly<{
+    is(node: AstNode | undefined): node is StructKeyNode;
+}>;
+export interface StructMapKeyNode extends AstNode {
+    type: 'mcdoc:struct/map_key';
+    children: (CommentNode | TypeNode)[];
+}
+export declare const StructMapKeyNode: Readonly<{
+    is(node: AstNode | undefined): node is StructMapKeyNode;
+}>;
+export interface StructSpreadFieldNode extends AstNode {
+    type: 'mcdoc:struct/field/spread';
+    children: (CommentNode | AttributeNode | TypeNode)[];
+}
+export declare const StructSpreadFieldNode: Readonly<{
+    is(node: AstNode | undefined): node is StructSpreadFieldNode;
+}>;
+export interface DispatcherTypeNode extends TypeBaseNode<ResourceLocationNode | IndexBodyNode> {
+    type: 'mcdoc:type/dispatcher';
+}
+export declare const DispatcherTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is DispatcherTypeNode;
+}>;
+export interface UnionTypeNode extends TypeBaseNode<TypeNode> {
+    type: 'mcdoc:type/union';
+}
+export declare const UnionTypeNode: Readonly<{
+    is(node: AstNode | undefined): node is UnionTypeNode;
+}>;
+export interface InjectionNode extends AstNode {
+    type: 'mcdoc:injection';
+    children: (CommentNode | LiteralNode | EnumInjectionNode | StructInjectionNode)[];
+}
+export declare const InjectionNode: Readonly<{
+    is(node: AstNode | undefined): node is InjectionNode;
+}>;
+export interface EnumInjectionNode extends AstNode {
+    type: 'mcdoc:injection/enum';
+    children: (CommentNode | LiteralNode | PathNode | EnumBlockNode)[];
+}
+export declare const EnumInjectionNode: Readonly<{
+    is(node: AstNode | undefined): node is EnumInjectionNode;
+}>;
+export interface StructInjectionNode extends AstNode {
+    type: 'mcdoc:injection/struct';
+    children: (CommentNode | LiteralNode | PathNode | TypeParamBlockNode | 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)[];
+}
+export declare const TypeAliasNode: Readonly<{
+    is(node: AstNode | undefined): node is TypeAliasNode;
+}>;
+export interface UseStatementNode extends AstNode {
+    type: 'mcdoc:use_statement';
+    children: (CommentNode | LiteralNode | PathNode | IdentifierNode)[];
+}
+export declare const UseStatementNode: Readonly<{
+    is(node: AstNode | undefined): node is UseStatementNode;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/lib/node/index.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseStatementNode = exports.TypeAliasNode = exports.StructInjectionNode = exports.EnumInjectionNode = exports.InjectionNode = exports.UnionTypeNode = exports.DispatcherTypeNode = exports.StructSpreadFieldNode = exports.StructMapKeyNode = exports.StructKeyNode = exports.StructPairFieldNode = exports.StructFieldNode = exports.StructBlockNode = exports.PathNode = exports.TypeParamNode = exports.TypeParamBlockNode = exports.StructNode = exports.PrelimNode = exports.EnumValueNode = exports.EnumFieldNode = exports.EnumBlockNode = exports.DocCommentsNode = exports.EnumNode = exports.TupleTypeNode = exports.ListTypeNode = exports.PrimitiveArrayTypeNode = exports.FloatRangeNode = exports.NumericTypeNode = exports.TypedNumberNode = exports.LiteralTypeNode = exports.IntRangeNode = exports.StringTypeNode = exports.BooleanTypeNode = exports.AnyTypeNode = exports.AttributeTreeNamedValuesNode = exports.AttributeTreePosValuesNode = exports.AttributeTreeNode = exports.AttributeValueNode = exports.AttributeNode = exports.TypeNode = exports.AccessorKeyNode = exports.DynamicIndexNode = exports.IdentifierNode = exports.StaticIndexNode = exports.IndexNode = exports.IndexBodyNode = exports.LiteralNode = exports.DispatchStatementNode = exports.TopLevelNode = exports.ModuleNode = void 0;
+const core_1 = require("@spyglassmc/core");
+exports.ModuleNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:module';
+    },
+});
+exports.TopLevelNode = Object.freeze({
+    is(node) {
+        return (core_1.CommentNode.is(node) ||
+            exports.DispatchStatementNode.is(node) ||
+            exports.EnumNode.is(node) ||
+            exports.InjectionNode.is(node) ||
+            exports.StructNode.is(node) ||
+            exports.TypeAliasNode.is(node) ||
+            exports.UseStatementNode.is(node));
+    },
+});
+exports.DispatchStatementNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:dispatch_statement';
+    },
+});
+exports.LiteralNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:literal';
+    },
+});
+exports.IndexBodyNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:index_body';
+    },
+});
+exports.IndexNode = Object.freeze({
+    is(node) {
+        return exports.StaticIndexNode.is(node) || exports.DynamicIndexNode.is(node);
+    },
+});
+exports.StaticIndexNode = Object.freeze({
+    is(node) {
+        return exports.LiteralNode.is(node) || exports.IdentifierNode.is(node) || core_1.StringNode.is(node) || core_1.ResourceLocationNode.is(node);
+    },
+});
+exports.IdentifierNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:identifier';
+    },
+});
+exports.DynamicIndexNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:dynamic_index';
+    },
+});
+exports.AccessorKeyNode = Object.freeze({
+    is(node) {
+        return exports.LiteralNode.is(node) || exports.IdentifierNode.is(node) || core_1.StringNode.is(node);
+    },
+});
+exports.TypeNode = Object.freeze({
+    is(node) {
+        return (exports.AnyTypeNode.is(node) ||
+            exports.BooleanTypeNode.is(node) ||
+            exports.StringTypeNode.is(node) ||
+            exports.LiteralTypeNode.is(node) ||
+            exports.NumericTypeNode.is(node) ||
+            exports.PrimitiveArrayTypeNode.is(node) ||
+            exports.ListTypeNode.is(node) ||
+            exports.TupleTypeNode.is(node) ||
+            exports.EnumNode.is(node) ||
+            exports.StructNode.is(node) ||
+            exports.PathNode.is(node) ||
+            exports.DispatcherTypeNode.is(node) ||
+            exports.UnionTypeNode.is(node));
+    },
+    asType(node) {
+        throw '// TODO';
+    },
+});
+exports.AttributeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:attribute';
+    },
+});
+exports.AttributeValueNode = Object.freeze({
+    is(node) {
+        return exports.TypeNode.is(node) || exports.AttributeTreeNode.is(node);
+    },
+});
+exports.AttributeTreeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:attribute/tree';
+    },
+});
+exports.AttributeTreePosValuesNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:attribute/tree/pos';
+    },
+});
+exports.AttributeTreeNamedValuesNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:attribute/tree/named';
+    },
+});
+exports.AnyTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/any';
+    },
+});
+exports.BooleanTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/boolean';
+    },
+});
+exports.StringTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/string';
+    },
+});
+exports.IntRangeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:int_range';
+    },
+});
+exports.LiteralTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/literal';
+    },
+});
+exports.TypedNumberNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:typed_number';
+    },
+});
+exports.NumericTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/numeric_type';
+    },
+});
+exports.FloatRangeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:float_range';
+    },
+});
+exports.PrimitiveArrayTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/primitive_array';
+    },
+});
+exports.ListTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/list';
+    },
+});
+exports.TupleTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/tuple';
+    },
+});
+exports.EnumNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:enum';
+    },
+    kinds: new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']),
+});
+exports.DocCommentsNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:doc_comments';
+    },
+});
+exports.EnumBlockNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:enum/block';
+    },
+});
+exports.EnumFieldNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:enum/field';
+    },
+});
+exports.EnumValueNode = Object.freeze({
+    is(node) {
+        return exports.TypedNumberNode.is(node) || core_1.StringNode.is(node);
+    },
+});
+exports.PrelimNode = Object.freeze({
+    is(node) {
+        return exports.AttributeNode.is(node) || exports.DocCommentsNode.is(node);
+    },
+});
+exports.StructNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:struct';
+    },
+});
+exports.TypeParamBlockNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type_param_block';
+    },
+});
+exports.TypeParamNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type_param';
+    },
+});
+exports.PathNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:path';
+    },
+});
+exports.StructBlockNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:struct/block';
+    },
+});
+exports.StructFieldNode = Object.freeze({
+    is(node) {
+        return exports.StructPairFieldNode.is(node) || exports.StructSpreadFieldNode.is(node);
+    },
+});
+exports.StructPairFieldNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:struct/field/pair';
+    },
+});
+exports.StructKeyNode = Object.freeze({
+    is(node) {
+        return core_1.StringNode.is(node) || exports.IdentifierNode.is(node) || exports.StructMapKeyNode.is(node);
+    },
+});
+exports.StructMapKeyNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:struct/map_key';
+    },
+});
+exports.StructSpreadFieldNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:struct/field/spread';
+    },
+});
+exports.DispatcherTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/dispatcher';
+    },
+});
+exports.UnionTypeNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type/union';
+    },
+});
+exports.InjectionNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:injection';
+    },
+});
+exports.EnumInjectionNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:injection/enum';
+    },
+});
+exports.StructInjectionNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:injection/struct';
+    },
+});
+exports.TypeAliasNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:type_alias';
+    },
+});
+exports.UseStatementNode = Object.freeze({
+    is(node) {
+        return node?.type === 'mcdoc:use_statement';
+    },
+});
+//# sourceMappingURL=index.js.map

package/lib/parser/index.d.ts

@@ -0,0 +1,44 @@
+import type { ColorTokenType, CommentNode, FloatNode, InfallibleParser, IntegerNode, Parser, ResourceLocationNode, ResourceLocationOptions, StringNode } from '@spyglassmc/core';
+import { Arrayable } from '@spyglassmc/core';
+import type { AnyTypeNode, AttributeNode, BooleanTypeNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, EnumNode, IdentifierNode, InjectionNode, ListTypeNode, LiteralNode, LiteralTypeNode, ModuleNode, NumericTypeNode, PathNode, PathTypeNode, PrimitiveArrayTypeNode, StringTypeNode, StructNode, TupleTypeNode, TypeAliasNode, TypedNumberNode, TypeNode, UnionTypeNode, UseStatementNode } from '../node';
+/**
+ * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
+ *
+ * `Failure` when there isn't a comment.
+ */
+export declare const comment: Parser<CommentNode>;
+export declare function literal(literal: Arrayable<string>, options?: {
+    allowedChars?: Set<string>;
+    specialChars?: Set<string>;
+    colorTokenType?: ColorTokenType;
+}): InfallibleParser<LiteralNode>;
+export declare function resLoc(options: ResourceLocationOptions): InfallibleParser<ResourceLocationNode>;
+export declare const string: InfallibleParser<StringNode>;
+export declare const identifier: InfallibleParser<IdentifierNode>;
+export declare const path: InfallibleParser<PathNode>;
+export declare const attribute: Parser<AttributeNode>;
+export declare const dispatchStatement: Parser<DispatchStatementNode>;
+export declare const docComment: Parser<CommentNode>;
+export declare const docComments: InfallibleParser<DocCommentsNode>;
+export declare const float: InfallibleParser<FloatNode>;
+export declare const typedNumber: InfallibleParser<TypedNumberNode>;
+export declare const enum_: Parser<EnumNode>;
+export declare const struct: Parser<StructNode>;
+export declare const injection: Parser<InjectionNode>;
+export declare const typeAlias: Parser<TypeAliasNode>;
+export declare const useStatement: Parser<UseStatementNode>;
+export declare const module_: Parser<ModuleNode>;
+export declare const anyType: Parser<AnyTypeNode>;
+export declare const booleanType: Parser<BooleanTypeNode>;
+export declare const integer: InfallibleParser<IntegerNode>;
+export declare const stringType: Parser<StringTypeNode>;
+export declare const literalType: Parser<LiteralTypeNode>;
+export declare const numericType: Parser<NumericTypeNode>;
+export declare const primitiveArrayType: Parser<PrimitiveArrayTypeNode>;
+export declare const listType: Parser<ListTypeNode>;
+export declare const tupleType: Parser<TupleTypeNode>;
+export declare const dispatcherType: Parser<DispatcherTypeNode>;
+export declare const unionType: Parser<UnionTypeNode>;
+export declare const pathType: InfallibleParser<PathTypeNode>;
+export declare const type: InfallibleParser<TypeNode>;
+//# sourceMappingURL=index.d.ts.map