@spyglassmc/mcdoc 0.3.7 → 0.3.9

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
+import { atArray, CommentNode, FloatNode, IntegerNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
 export var ModuleNode;
 (function (ModuleNode) {
     function is(node) {
@@ -9,13 +9,13 @@ export var ModuleNode;
 export var TopLevelNode;
 (function (TopLevelNode) {
     function is(node) {
-        return (CommentNode.is(node) ||
-            DispatchStatementNode.is(node) ||
-            EnumNode.is(node) ||
-            InjectionNode.is(node) ||
-            StructNode.is(node) ||
-            TypeAliasNode.is(node) ||
-            UseStatementNode.is(node));
+        return (CommentNode.is(node)
+            || DispatchStatementNode.is(node)
+            || EnumNode.is(node)
+            || InjectionNode.is(node)
+            || StructNode.is(node)
+            || TypeAliasNode.is(node)
+            || UseStatementNode.is(node));
     }
     TopLevelNode.is = is;
 })(TopLevelNode || (TopLevelNode = {}));
@@ -32,8 +32,7 @@ export var DispatchStatementNode;
     }
     DispatchStatementNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:dispatch_statement');
+        return (node?.type === 'mcdoc:dispatch_statement');
     }
     DispatchStatementNode.is = is;
 })(DispatchStatementNode || (DispatchStatementNode = {}));
@@ -47,9 +46,7 @@ export var LiteralNode;
 export var IndexBodyNode;
 (function (IndexBodyNode) {
     function destruct(node) {
-        return {
-            parallelIndices: node.children.filter(IndexNode.is),
-        };
+        return { parallelIndices: node.children.filter(IndexNode.is) };
     }
     IndexBodyNode.destruct = destruct;
     function is(node) {
@@ -67,10 +64,10 @@ export var IndexNode;
 export var StaticIndexNode;
 (function (StaticIndexNode) {
     function is(node) {
-        return (LiteralNode.is(node) ||
-            IdentifierNode.is(node) ||
-            StringNode.is(node) ||
-            ResourceLocationNode.is(node));
+        return (LiteralNode.is(node)
+            || IdentifierNode.is(node)
+            || StringNode.is(node)
+            || ResourceLocationNode.is(node));
     }
     StaticIndexNode.is = is;
 })(StaticIndexNode || (StaticIndexNode = {}));
@@ -84,9 +81,7 @@ export var IdentifierNode;
 export var DynamicIndexNode;
 (function (DynamicIndexNode) {
     function destruct(node) {
-        return {
-            keys: node.children.filter(AccessorKeyNode.is),
-        };
+        return { keys: node.children.filter(AccessorKeyNode.is) };
     }
     DynamicIndexNode.destruct = destruct;
     function is(node) {
@@ -104,19 +99,19 @@ export var AccessorKeyNode;
 export var TypeNode;
 (function (TypeNode) {
     function is(node) {
-        return (AnyTypeNode.is(node) ||
-            BooleanTypeNode.is(node) ||
-            StringTypeNode.is(node) ||
-            LiteralTypeNode.is(node) ||
-            NumericTypeNode.is(node) ||
-            PrimitiveArrayTypeNode.is(node) ||
-            ListTypeNode.is(node) ||
-            TupleTypeNode.is(node) ||
-            EnumNode.is(node) ||
-            StructNode.is(node) ||
-            ReferenceTypeNode.is(node) ||
-            DispatcherTypeNode.is(node) ||
-            UnionTypeNode.is(node));
+        return (AnyTypeNode.is(node)
+            || BooleanTypeNode.is(node)
+            || StringTypeNode.is(node)
+            || LiteralTypeNode.is(node)
+            || NumericTypeNode.is(node)
+            || PrimitiveArrayTypeNode.is(node)
+            || ListTypeNode.is(node)
+            || TupleTypeNode.is(node)
+            || EnumNode.is(node)
+            || StructNode.is(node)
+            || ReferenceTypeNode.is(node)
+            || DispatcherTypeNode.is(node)
+            || UnionTypeNode.is(node));
     }
     TypeNode.is = is;
 })(TypeNode || (TypeNode = {}));
@@ -161,31 +156,25 @@ export var AttributeTreeNode;
     }
     AttributeTreeNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:attribute/tree');
+        return (node?.type === 'mcdoc:attribute/tree');
     }
     AttributeTreeNode.is = is;
 })(AttributeTreeNode || (AttributeTreeNode = {}));
 export var AttributeTreePosValuesNode;
 (function (AttributeTreePosValuesNode) {
     function destruct(node) {
-        return {
-            values: node.children.filter(AttributeValueNode.is),
-        };
+        return { values: node.children.filter(AttributeValueNode.is) };
     }
     AttributeTreePosValuesNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:attribute/tree/pos');
+        return (node?.type === 'mcdoc:attribute/tree/pos');
     }
     AttributeTreePosValuesNode.is = is;
 })(AttributeTreePosValuesNode || (AttributeTreePosValuesNode = {}));
 export var AttributeTreeNamedValuesNode;
 (function (AttributeTreeNamedValuesNode) {
     function destruct(node) {
-        const ans = {
-            values: [],
-        };
+        const ans = { values: [] };
         let key;
         for (const child of node.children) {
             if (CommentNode.is(child)) {
@@ -203,17 +192,15 @@ export var AttributeTreeNamedValuesNode;
     }
     AttributeTreeNamedValuesNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:attribute/tree/named');
+        return (node?.type
+            === 'mcdoc:attribute/tree/named');
     }
     AttributeTreeNamedValuesNode.is = is;
 })(AttributeTreeNamedValuesNode || (AttributeTreeNamedValuesNode = {}));
 export var TypeArgBlockNode;
 (function (TypeArgBlockNode) {
     function destruct(node) {
-        return {
-            args: node.children.filter(TypeNode.is),
-        };
+        return { args: node.children.filter(TypeNode.is) };
     }
     TypeArgBlockNode.destruct = destruct;
     function is(node) {
@@ -231,8 +218,7 @@ export var AnyTypeNode;
 export var BooleanTypeNode;
 (function (BooleanTypeNode) {
     function is(node) {
-        return node?.type ===
-            'mcdoc:type/boolean';
+        return node?.type === 'mcdoc:type/boolean';
     }
     BooleanTypeNode.is = is;
 })(BooleanTypeNode || (BooleanTypeNode = {}));
@@ -250,14 +236,11 @@ export var IntRangeNode;
 export var LiteralTypeNode;
 (function (LiteralTypeNode) {
     function destruct(node) {
-        return {
-            value: node.children.find(LiteralTypeValueNode.is),
-        };
+        return { value: node.children.find(LiteralTypeValueNode.is) };
     }
     LiteralTypeNode.destruct = destruct;
     function is(node) {
-        return node?.type ===
-            'mcdoc:type/literal';
+        return node?.type === 'mcdoc:type/literal';
     }
     LiteralTypeNode.is = is;
 })(LiteralTypeNode || (LiteralTypeNode = {}));
@@ -272,14 +255,13 @@ export var TypedNumberNode;
 (function (TypedNumberNode) {
     function destruct(node) {
         return {
-            value: node.children.find(FloatNode.is),
+            value: node.children.find(FloatNode.is) ?? node.children.find(IntegerNode.is),
             suffix: node.children.find(LiteralNode.is),
         };
     }
     TypedNumberNode.destruct = destruct;
     function is(node) {
-        return node?.type ===
-            'mcdoc:typed_number';
+        return node?.type === 'mcdoc:typed_number';
     }
     TypedNumberNode.is = is;
 })(TypedNumberNode || (TypedNumberNode = {}));
@@ -288,18 +270,27 @@ export var NumericTypeNode;
     function destruct(node) {
         return {
             numericKind: node.children.find(LiteralNode.is),
-            valueRange: node.children.find(FloatRangeNode.is) ||
-                node.children.find(IntRangeNode.is),
+            valueRange: node.children.find(FloatRangeNode.is) || node.children.find(IntRangeNode.is),
         };
     }
     NumericTypeNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:type/numeric_type');
+        return (node?.type === 'mcdoc:type/numeric_type');
     }
     NumericTypeNode.is = is;
 })(NumericTypeNode || (NumericTypeNode = {}));
 export const RangeExclusiveChar = '<';
+export var RangeKind;
+(function (RangeKind) {
+    function isLeftExclusive(rangeKind) {
+        return (rangeKind & 0b10) !== 0;
+    }
+    RangeKind.isLeftExclusive = isLeftExclusive;
+    function isRightExclusive(rangeKind) {
+        return (rangeKind & 0b01) !== 0;
+    }
+    RangeKind.isRightExclusive = isRightExclusive;
+})(RangeKind || (RangeKind = {}));
 export function getRangeDelimiter(kind) {
     const prefix = kind & 0b10 ? RangeExclusiveChar : '';
     const suffix = kind & 0b01 ? RangeExclusiveChar : '';
@@ -330,11 +321,7 @@ function destructRangeNode(node) {
         kind = getKind(node.children[1]);
         min = node.children[0];
     }
-    return {
-        kind,
-        min,
-        max,
-    };
+    return { kind, min, max };
     function getKind(delimiter) {
         let ans = 0b00;
         if (delimiter.value.startsWith(RangeExclusiveChar)) {
@@ -376,16 +363,11 @@ export var PrimitiveArrayTypeNode;
                 }
             }
         }
-        return {
-            arrayKind: node.children.find(LiteralNode.is),
-            lengthRange,
-            valueRange,
-        };
+        return { arrayKind: node.children.find(LiteralNode.is), lengthRange, valueRange };
     }
     PrimitiveArrayTypeNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:type/primitive_array');
+        return (node?.type === 'mcdoc:type/primitive_array');
     }
     PrimitiveArrayTypeNode.is = is;
 })(PrimitiveArrayTypeNode || (PrimitiveArrayTypeNode = {}));
@@ -406,9 +388,7 @@ export var ListTypeNode;
 export var StringTypeNode;
 (function (StringTypeNode) {
     function destruct(node) {
-        return {
-            lengthRange: node.children.find(IntRangeNode.is),
-        };
+        return { lengthRange: node.children.find(IntRangeNode.is) };
     }
     StringTypeNode.destruct = destruct;
     function is(node) {
@@ -419,9 +399,7 @@ export var StringTypeNode;
 export var TupleTypeNode;
 (function (TupleTypeNode) {
     function destruct(node) {
-        return {
-            items: node.children.filter(TypeNode.is),
-        };
+        return { items: node.children.filter(TypeNode.is) };
     }
     TupleTypeNode.destruct = destruct;
     function is(node) {
@@ -431,15 +409,7 @@ export var TupleTypeNode;
 })(TupleTypeNode || (TupleTypeNode = {}));
 export var EnumNode;
 (function (EnumNode) {
-    EnumNode.Kinds = new Set([
-        'byte',
-        'short',
-        'int',
-        'long',
-        'float',
-        'double',
-        'string',
-    ]);
+    EnumNode.Kinds = new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']);
     function destruct(node) {
         return {
             block: node.children.find(EnumBlockNode.is),
@@ -485,17 +455,14 @@ export var DocCommentsNode;
     }
     DocCommentsNode.asText = asText;
     function is(node) {
-        return node?.type ===
-            'mcdoc:doc_comments';
+        return node?.type === 'mcdoc:doc_comments';
     }
     DocCommentsNode.is = is;
 })(DocCommentsNode || (DocCommentsNode = {}));
 export var EnumBlockNode;
 (function (EnumBlockNode) {
     function destruct(node) {
-        return {
-            fields: node.children.filter(EnumFieldNode.is),
-        };
+        return { fields: node.children.filter(EnumFieldNode.is) };
     }
     EnumBlockNode.destruct = destruct;
     function is(node) {
@@ -551,28 +518,22 @@ export var StructNode;
 export var ReferenceTypeNode;
 (function (ReferenceTypeNode) {
     function destruct(node) {
-        return {
-            path: node.children.find(PathNode.is),
-        };
+        return { path: node.children.find(PathNode.is) };
     }
     ReferenceTypeNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:type/reference');
+        return (node?.type === 'mcdoc:type/reference');
     }
     ReferenceTypeNode.is = is;
 })(ReferenceTypeNode || (ReferenceTypeNode = {}));
 export var TypeParamBlockNode;
 (function (TypeParamBlockNode) {
     function destruct(node) {
-        return {
-            params: node.children.filter(TypeParamNode.is),
-        };
+        return { params: node.children.filter(TypeParamNode.is) };
     }
     TypeParamBlockNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:type_param_block');
+        return (node?.type === 'mcdoc:type_param_block');
     }
     TypeParamBlockNode.is = is;
 })(TypeParamBlockNode || (TypeParamBlockNode = {}));
@@ -609,14 +570,11 @@ export var PathNode;
 export var StructBlockNode;
 (function (StructBlockNode) {
     function destruct(node) {
-        return {
-            fields: node.children.filter(StructFieldNode.is),
-        };
+        return { fields: node.children.filter(StructFieldNode.is) };
     }
     StructBlockNode.destruct = destruct;
     function is(node) {
-        return node?.type ===
-            'mcdoc:struct/block';
+        return node?.type === 'mcdoc:struct/block';
     }
     StructBlockNode.is = is;
 })(StructBlockNode || (StructBlockNode = {}));
@@ -632,6 +590,7 @@ export var StructPairFieldNode;
     function destruct(node) {
         return {
             attributes: node.children.filter(AttributeNode.is),
+            docComments: node.children.find(DocCommentsNode.is),
             key: node.children.find(StructKeyNode.is),
             type: node.children.find(TypeNode.is),
             isOptional: node.isOptional,
@@ -639,26 +598,21 @@ export var StructPairFieldNode;
     }
     StructPairFieldNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:struct/field/pair');
+        return (node?.type === 'mcdoc:struct/field/pair');
     }
     StructPairFieldNode.is = is;
 })(StructPairFieldNode || (StructPairFieldNode = {}));
 export var StructKeyNode;
 (function (StructKeyNode) {
     function is(node) {
-        return (StringNode.is(node) ||
-            IdentifierNode.is(node) ||
-            StructMapKeyNode.is(node));
+        return (StringNode.is(node) || IdentifierNode.is(node) || StructMapKeyNode.is(node));
     }
     StructKeyNode.is = is;
 })(StructKeyNode || (StructKeyNode = {}));
 export var StructMapKeyNode;
 (function (StructMapKeyNode) {
     function destruct(node) {
-        return {
-            type: node.children.find(TypeNode.is),
-        };
+        return { type: node.children.find(TypeNode.is) };
     }
     StructMapKeyNode.destruct = destruct;
     function is(node) {
@@ -676,8 +630,7 @@ export var StructSpreadFieldNode;
     }
     StructSpreadFieldNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:struct/field/spread');
+        return (node?.type === 'mcdoc:struct/field/spread');
     }
     StructSpreadFieldNode.is = is;
 })(StructSpreadFieldNode || (StructSpreadFieldNode = {}));
@@ -691,17 +644,14 @@ export var DispatcherTypeNode;
     }
     DispatcherTypeNode.destruct = destruct;
     function is(node) {
-        return (node?.type ===
-            'mcdoc:type/dispatcher');
+        return (node?.type === 'mcdoc:type/dispatcher');
     }
     DispatcherTypeNode.is = is;
 })(DispatcherTypeNode || (DispatcherTypeNode = {}));
 export var UnionTypeNode;
 (function (UnionTypeNode) {
     function destruct(node) {
-        return {
-            members: node.children.filter(TypeNode.is),
-        };
+        return { members: node.children.filter(TypeNode.is) };
     }
     UnionTypeNode.destruct = destruct;
     function is(node) {
@@ -712,9 +662,7 @@ export var UnionTypeNode;
 export var InjectionNode;
 (function (InjectionNode) {
     function destruct(node) {
-        return {
-            injection: node.children.find(InjectionContentNode.is),
-        };
+        return { injection: node.children.find(InjectionContentNode.is) };
     }
     InjectionNode.destruct = destruct;
     function is(node) {
@@ -732,16 +680,14 @@ export var InjectionContentNode;
 export var EnumInjectionNode;
 (function (EnumInjectionNode) {
     function is(node) {
-        return (node?.type ===
-            'mcdoc:injection/enum');
+        return (node?.type === 'mcdoc:injection/enum');
     }
     EnumInjectionNode.is = is;
 })(EnumInjectionNode || (EnumInjectionNode = {}));
 export var StructInjectionNode;
 (function (StructInjectionNode) {
     function is(node) {
-        return (node?.type ===
-            'mcdoc:injection/struct');
+        return (node?.type === 'mcdoc:injection/struct');
     }
     StructInjectionNode.is = is;
 })(StructInjectionNode || (StructInjectionNode = {}));

package/lib/parser/index.d.ts

@@ -21,6 +21,19 @@ export declare const docComment: Parser<CommentNode>;
 export declare const docComments: InfallibleParser<DocCommentsNode>;
 export declare const dispatchStatement: Parser<DispatchStatementNode>;
 export declare const float: InfallibleParser<FloatNode>;
+export declare const integer: InfallibleParser<IntegerNode>;
+export declare const LiteralIntSuffixes: readonly ["b", "s", "l"];
+export type LiteralIntSuffix = (typeof LiteralIntSuffixes)[number];
+export declare const LiteralIntCaseInsensitiveSuffixes: readonly ["b", "s", "l", "B", "S", "L"];
+export type LiteralIntCaseInsensitiveSuffix = (typeof LiteralIntCaseInsensitiveSuffixes)[number];
+export declare const LiteralFloatSuffixes: readonly ["f", "d"];
+export type LiteralFloatSuffix = (typeof LiteralFloatSuffixes)[number];
+export declare const LiteralFloatCaseInsensitiveSuffixes: readonly ["f", "d", "F", "D"];
+export type LiteralFloatCaseInsensitiveSuffix = (typeof LiteralFloatCaseInsensitiveSuffixes)[number];
+export declare const LiteralNumberSuffixes: readonly ["b", "s", "l", "f", "d"];
+export type LiteralNumberSuffix = (typeof LiteralNumberSuffixes)[number];
+export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "b", "s", "l", "B", "S", "L", "f", "d", "F", "D"];
+export type LiteralNumberCaseInsensitiveSuffix = (typeof LiteralNumberCaseInsensitiveSuffixes)[number];
 export declare const typedNumber: InfallibleParser<TypedNumberNode>;
 export declare const enum_: Parser<EnumNode>;
 export declare const struct: Parser<StructNode>;
@@ -30,7 +43,6 @@ 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 intRange: InfallibleParser<IntRangeNode>;
 export declare const stringType: Parser<StringTypeNode>;
 export declare const literalType: Parser<LiteralTypeNode>;