@spyglassmc/mcdoc 0.1.0 → 0.3.0

package/lib/parser/index.js

@@ -1,40 +1,16 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.type = exports.pathType = exports.unionType = exports.dispatcherType = exports.tupleType = exports.listType = exports.primitiveArrayType = exports.numericType = exports.literalType = exports.stringType = exports.integer = exports.booleanType = exports.anyType = exports.module_ = exports.useStatement = exports.typeAlias = exports.injection = exports.struct = exports.enum_ = exports.typedNumber = exports.float = exports.docComments = exports.docComment = exports.dispatchStatement = exports.attribute = exports.path = exports.identifier = exports.string = exports.resLoc = exports.literal = exports.comment = void 0;
-const core = __importStar(require("@spyglassmc/core"));
-const core_1 = require("@spyglassmc/core");
-const locales_1 = require("@spyglassmc/locales");
+import * as core from '@spyglassmc/core';
+import { any, Arrayable, failOnEmpty, failOnError, Failure, map, optional, Range, repeat, ResourceLocation, select, sequence, setType, stopBefore, validate } from '@spyglassmc/core';
+import { arrayToMessage, localeQuote, localize } from '@spyglassmc/locales';
+import { RangeExclusiveChar } from '../node/index.js';
+import { LiteralNumberCaseInsensitiveSuffixes, NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords } from '../type/index.js';
 /**
  * @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.
  */
-exports.comment = (0, core_1.validate)(core.comment({
+export const comment = validate(core.comment({
     singleLinePrefixes: new Set(['//']),
-}), (res, src) => !src.slice(res).startsWith('///'), (0, locales_1.localize)('mcdoc.parser.syntax.doc-comment-unexpected'));
+}), (res, src) => !src.slice(res).startsWith('///'), localize('mcdoc.parser.syntax.doc-comment-unexpected'));
 /**
  * @returns A parser that parses the gap between **SYNTAX** rules, which may contains whitespace and regular comments.
  */
@@ -45,7 +21,7 @@ delegatesDocComments = false) {
         const ans = [];
         src.skipWhitespace();
         while (src.canRead() && src.peek(2) === '//' && (!delegatesDocComments || src.peek(3) !== '///')) {
-            const result = (0, exports.comment)(src, ctx);
+            const result = comment(src, ctx);
             ans.push(result);
             src.skipWhitespace();
         }
@@ -55,36 +31,35 @@ delegatesDocComments = false) {
 function syntax(parsers, delegatesDocComments = false) {
     return (src, ctx) => {
         src.skipWhitespace();
-        const ans = (0, core_1.sequence)(parsers, syntaxGap(delegatesDocComments))(src, ctx);
+        const ans = sequence(parsers, syntaxGap(delegatesDocComments))(src, ctx);
         src.skipWhitespace();
         return ans;
     };
 }
 function syntaxRepeat(parser, delegatesDocComments = false) {
-    return (0, core_1.repeat)(parser, syntaxGap(delegatesDocComments));
+    return repeat(parser, syntaxGap(delegatesDocComments));
 }
-function literal(literal, options) {
+export function literal(literal, options) {
     return (src, ctx) => {
         const ans = {
             type: 'mcdoc:literal',
-            range: core_1.Range.create(src),
+            range: Range.create(src),
             value: '',
             colorTokenType: options?.colorTokenType,
         };
         ans.value = src.readIf(c => options?.allowedChars?.has(c) ?? (options?.specialChars?.has(c) || /[a-z]/i.test(c)));
         ans.range.end = src.cursor;
-        if (core_1.Arrayable.toArray(literal).every(l => l !== ans.value)) {
-            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.arrayToMessage)(literal), (0, locales_1.localeQuote)(ans.value)), ans);
+        if (Arrayable.toArray(literal).every(l => l !== ans.value)) {
+            ctx.err.report(localize('expected-got', arrayToMessage(literal), localeQuote(ans.value)), ans);
         }
         return ans;
     };
 }
-exports.literal = literal;
 function keyword(keyword, options = { colorTokenType: 'keyword' }) {
     return (src, ctx) => {
         const result = literal(keyword, options)(src, ctx);
-        if (!core_1.Arrayable.toArray(keyword).includes(result.value)) {
-            return core_1.Failure;
+        if (!Arrayable.toArray(keyword).includes(result.value)) {
+            return Failure;
         }
         return result;
     };
@@ -93,7 +68,7 @@ function punctuation(punctuation) {
     return (src, ctx) => {
         src.skipWhitespace();
         if (!src.trySkip(punctuation)) {
-            ctx.err.report((0, locales_1.localize)('expected-got', (0, locales_1.localeQuote)(punctuation), (0, locales_1.localeQuote)(src.peek())), src);
+            ctx.err.report(localize('expected-got', localeQuote(punctuation), localeQuote(src.peek())), src);
         }
         return undefined;
     };
@@ -102,32 +77,31 @@ function marker(punctuation) {
     return (src, _ctx) => {
         src.skipWhitespace();
         if (!src.trySkip(punctuation)) {
-            return core_1.Failure;
+            return Failure;
         }
         return undefined;
     };
 }
-function resLoc(options) {
-    return (0, core_1.validate)(core.resourceLocation(options), res => res.namespace !== undefined, (0, locales_1.localize)('mcdoc.parser.resource-location.colon-expected', (0, locales_1.localeQuote)(core_1.ResourceLocation.NamespacePathSep)));
+export function resLoc(options) {
+    return validate(core.resourceLocation(options), res => res.namespace !== undefined, localize('mcdoc.parser.resource-location.colon-expected', localeQuote(ResourceLocation.NamespacePathSep)));
 }
-exports.resLoc = resLoc;
 const UnicodeControlCharacters = Object.freeze([
     '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06',
     '\x07', '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D',
     '\x0E', '\x0F', '\x7F',
 ]);
-exports.string = (0, core_1.stopBefore)(core.string({
+export const string = stopBefore(core.string({
     escapable: { characters: ['b', 'f', 'n', 'r', 't', '\\', '"'], unicode: true },
     quotes: ['"'],
 }), ...UnicodeControlCharacters);
-const identifier = (src, ctx) => {
+export const identifier = (src, ctx) => {
     // https://spyglassmc.com/user/mcdoc/#identifier
     const IdentifierStart = /^[\p{L}\p{Nl}]$/u;
     const IdentifierContinue = /^[\p{L}\p{Nl}\u200C\u200D\p{Mn}\p{Mc}\p{Nd}\p{Pc}]$/u;
     const ReservedWords = new Set(['any', 'boolean', 'byte', 'double', 'enum', 'false', 'float', 'int', 'long', 'short', 'string', 'struct', 'super', 'true']);
     const ans = {
         type: 'mcdoc:identifier',
-        range: core_1.Range.create(src),
+        range: Range.create(src),
         options: { category: 'mcdoc' },
         value: '',
     };
@@ -139,73 +113,74 @@ const identifier = (src, ctx) => {
         }
     }
     else {
-        ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('mcdoc.node.identifier')), src);
+        ctx.err.report(localize('expected', localize('mcdoc.node.identifier')), src);
     }
     ans.value = src.string.slice(start, src.innerCursor);
     ans.range.end = src.cursor;
     if (ReservedWords.has(ans.value)) {
-        ctx.err.report((0, locales_1.localize)('mcdoc.parser.identifier.reserved-word', (0, locales_1.localeQuote)(ans.value)), ans);
+        ctx.err.report(localize('mcdoc.parser.identifier.reserved-word', localeQuote(ans.value)), ans);
     }
     return ans;
 };
-exports.identifier = identifier;
 function indexBody(options) {
-    const accessorKey = (0, core_1.select)([
+    const accessorKey = select([
         {
             prefix: '%',
             parser: literal(['%key', '%parent'], { specialChars: new Set(['%']) }),
         },
         {
             prefix: '"',
-            parser: exports.string,
+            parser: string,
         },
         {
-            parser: exports.identifier,
+            parser: identifier,
         },
     ]);
-    const dynamicIndex = (0, core_1.setType)('mcdoc:dynamic_index', syntax([
+    const dynamicIndex = setType('mcdoc:dynamic_index', syntax([
         punctuation('['),
         accessorKey,
-        (0, core_1.repeat)((0, core_1.sequence)([marker('.'), accessorKey])),
+        repeat(sequence([marker('.'), accessorKey])),
         punctuation(']'),
     ]));
-    const index = (0, core_1.select)([
+    const index = select([
         {
             prefix: '%',
-            parser: literal(['%fallback', '%none', '%unknown'], { specialChars: new Set(['%']) }),
+            parser: literal(StaticIndexKeywords.map(v => `%${v}`), { specialChars: new Set(['%']) }),
         },
         {
             prefix: '"',
-            parser: exports.string,
+            parser: string,
         },
         {
             prefix: '[',
-            parser: dynamicIndex,
+            parser: options?.noDynamic
+                ? validate(dynamicIndex, () => false, localize('mcdoc.parser.index-body.dynamic-index-not-allowed'))
+                : dynamicIndex,
         },
         {
-            parser: (0, core_1.any)([resLoc({ category: 'mcdoc/dispatcher', accessType: options?.accessType }), exports.identifier]),
+            parser: any([resLoc({ category: 'mcdoc/dispatcher', accessType: options?.accessType }), identifier]),
         },
     ]);
-    return (0, core_1.setType)('mcdoc:index_body', syntax([
+    return setType('mcdoc:index_body', syntax([
         punctuation('['),
         index,
-        syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(index)])),
-        (0, core_1.optional)(marker(',')),
+        syntaxRepeat(syntax([marker(','), failOnEmpty(index)])),
+        optional(marker(',')),
         punctuation(']'),
     ]));
 }
-const pathSegment = (0, core_1.select)([
+const pathSegment = select([
     { prefix: 'super', parser: literal('super') },
-    { parser: exports.identifier },
+    { parser: identifier },
 ]);
-const path = (src, ctx) => {
+export const path = (src, ctx) => {
     let isAbsolute;
     if (src.trySkip('::')) {
         isAbsolute = true;
     }
-    return (0, core_1.map)((0, core_1.sequence)([
+    return map(sequence([
         pathSegment,
-        (0, core_1.repeat)((0, core_1.sequence)([marker('::'), pathSegment])),
+        repeat(sequence([marker('::'), pathSegment])),
     ]), res => {
         const ans = {
             type: 'mcdoc:path',
@@ -216,29 +191,28 @@ const path = (src, ctx) => {
         return ans;
     })(src, ctx);
 };
-exports.path = path;
-const attributeTreePosValues = (0, core_1.setType)('mcdoc:attribute/tree/pos', syntax([
+const attributeTreePosValues = setType('mcdoc:attribute/tree/pos', syntax([
     { get: () => attributeValue },
-    syntaxRepeat(syntax([marker(','), { get: () => (0, core_1.failOnEmpty)(attributeValue) }], true), true),
+    syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(attributeValue) }], true), true),
 ], true));
 const attributeNamedValue = syntax([
-    (0, core_1.select)([
-        { prefix: '"', parser: exports.string },
-        { parser: exports.identifier },
+    select([
+        { prefix: '"', parser: string },
+        { parser: identifier },
     ]),
-    (0, core_1.select)([
+    select([
         { prefix: '=', parser: syntax([punctuation('='), { get: () => attributeValue }], true) },
         { parser: { get: () => attributeTree } },
     ]),
 ], true);
-const attributeTreeNamedValues = (0, core_1.setType)('mcdoc:attribute/tree/named', syntax([
+const attributeTreeNamedValues = setType('mcdoc:attribute/tree/named', syntax([
     attributeNamedValue,
-    syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(attributeNamedValue)], true), true),
+    syntaxRepeat(syntax([marker(','), failOnEmpty(attributeNamedValue)], true), true),
 ], true));
-const treeBody = (0, core_1.any)([
-    syntax([attributeTreePosValues, (0, core_1.optional)(marker(','))]),
-    syntax([attributeTreeNamedValues, (0, core_1.optional)(marker(','))]),
-    syntax([attributeTreePosValues, punctuation(','), attributeTreeNamedValues, (0, core_1.optional)(marker(','))]),
+const treeBody = any([
+    syntax([attributeTreeNamedValues, optional(marker(','))]),
+    syntax([attributeTreePosValues, punctuation(','), attributeTreeNamedValues, optional(marker(','))]),
+    syntax([attributeTreePosValues, optional(marker(','))]),
 ]);
 const AttributeTreeClosure = Object.freeze({
     '(': ')',
@@ -246,7 +220,10 @@ const AttributeTreeClosure = Object.freeze({
     '{': '}',
 });
 const attributeTree = (src, ctx) => {
-    const delim = src.trySkip('(') ? '(' : (src.trySkip('[') ? '[' : '{');
+    const delim = src.trySkip('(') ? '(' : (src.trySkip('[') ? '[' : (src.trySkip('{') ? '{' : undefined));
+    if (!delim) {
+        return Failure;
+    }
     const res = treeBody(src, ctx);
     const ans = {
         type: 'mcdoc:attribute/tree',
@@ -257,38 +234,38 @@ const attributeTree = (src, ctx) => {
     src.trySkip(AttributeTreeClosure[delim]);
     return ans;
 };
-const attributeValue = (0, core_1.select)([
+const attributeValue = select([
     { predicate: src => ['(', '[', '{'].includes(src.peek()), parser: attributeTree },
-    { parser: { get: () => exports.type } },
+    { parser: { get: () => type } },
 ]);
-exports.attribute = (0, core_1.setType)('mcdoc:attribute', syntax([
+export const attribute = setType('mcdoc:attribute', syntax([
     marker('#['),
-    exports.identifier,
-    (0, core_1.select)([
+    identifier,
+    select([
         { prefix: '=', parser: syntax([punctuation('='), attributeValue, punctuation(']')], true) },
         { predicate: src => ['(', '[', '{'].includes(src.peek()), parser: syntax([attributeTree, punctuation(']')], true) },
         { parser: punctuation(']') },
     ]),
 ], true));
-const attributes = (0, core_1.repeat)(exports.attribute);
-exports.dispatchStatement = (0, core_1.setType)('mcdoc:dispatch_statement', syntax([
+const attributes = repeat(attribute);
+export const dispatchStatement = setType('mcdoc:dispatch_statement', syntax([
     attributes,
     keyword('dispatch'),
     resLoc({ category: 'mcdoc/dispatcher', accessType: 1 /* SymbolAccessType.Write */ }),
     indexBody({ noDynamic: true }),
     literal('to'),
-    { get: () => exports.type },
+    { get: () => type },
 ], true));
-exports.docComment = core.comment({
+export const docComment = core.comment({
     singleLinePrefixes: new Set(['///']),
     includesEol: true,
 });
-exports.docComments = (0, core_1.setType)('mcdoc:doc_comments', (0, core_1.repeat)(exports.docComment, src => {
+export const docComments = setType('mcdoc:doc_comments', repeat(docComment, src => {
     src.skipWhitespace();
     return [];
 }));
 const prelim = syntax([
-    (0, core_1.optional)((0, core_1.failOnEmpty)(exports.docComments)),
+    optional(failOnEmpty(docComments)),
     attributes,
 ]);
 const enumType = literal([
@@ -300,78 +277,55 @@ const enumType = literal([
     'float',
     'double',
 ], { colorTokenType: 'type' });
-exports.float = core.float({
+export const float = core.float({
     pattern: /^[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)?|[0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?)$/,
 });
-exports.typedNumber = (0, core_1.setType)('mcdoc:typed_number', (0, core_1.sequence)([
-    exports.float,
-    (0, core_1.optional)(keyword(['b', 'B', 'd', 'D', 'f', 'F', 'l', 'L', 's', 'S'], { colorTokenType: 'keyword' })),
+export const typedNumber = setType('mcdoc:typed_number', sequence([
+    float,
+    optional(keyword(LiteralNumberCaseInsensitiveSuffixes, { colorTokenType: 'keyword' })),
 ]));
-const enumValue = (0, core_1.select)([
-    { prefix: '"', parser: exports.string },
-    { parser: exports.typedNumber },
+const enumValue = select([
+    { prefix: '"', parser: string },
+    { parser: typedNumber },
 ]);
-const enumField = (0, core_1.setType)('mcdoc:enum/field', syntax([
+const enumField = setType('mcdoc:enum/field', syntax([
     prelim,
-    exports.identifier,
+    identifier,
     punctuation('='),
     enumValue,
 ], true));
-const enumBlock = (0, core_1.setType)('mcdoc:enum/block', syntax([
+const enumBlock = setType('mcdoc:enum/block', syntax([
     punctuation('{'),
-    (0, core_1.select)([
+    select([
         { prefix: '}', parser: punctuation('}') },
         {
             parser: syntax([
                 enumField,
-                syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(enumField)], true), true),
-                (0, core_1.optional)(marker(',')),
+                syntaxRepeat(syntax([marker(','), failOnEmpty(enumField)], true), true),
+                optional(marker(',')),
                 punctuation('}'),
             ], true),
         },
     ]),
 ], true));
-exports.enum_ = (0, core_1.setType)('mcdoc:enum', syntax([
+export const enum_ = setType('mcdoc:enum', syntax([
     prelim,
     keyword('enum'),
     punctuation('('),
     enumType,
     punctuation(')'),
-    (0, core_1.optional)((0, core_1.failOnError)(exports.identifier)),
+    optional(failOnError(identifier)),
     enumBlock,
 ], true));
-const typeParam = (0, core_1.setType)('mcdoc:type_param', syntax([
-    exports.identifier,
-    (0, core_1.optional)(syntax([(0, core_1.failOnError)(literal('extends')), exports.path])),
-]));
-const typeParamBlock = (0, core_1.setType)('mcdoc:type_param_block', syntax([
-    punctuation('<'),
-    (0, core_1.select)([
-        { prefix: '>', parser: punctuation('>') },
-        {
-            parser: syntax([
-                typeParam,
-                syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(typeParam)])),
-                (0, core_1.optional)(marker(',')),
-                punctuation('>'),
-            ]),
-        },
-    ]),
-]));
-const noop = () => undefined;
-const optionalTypeParamBlock = (0, core_1.select)([
-    { prefix: '<', parser: typeParamBlock },
-    { parser: noop },
-]);
-const structMapKey = (0, core_1.setType)('mcdoc:struct/map_key', syntax([
+const structMapKey = setType('mcdoc:struct/map_key', syntax([
     punctuation('['),
-    { get: () => exports.type },
+    { get: () => type },
     punctuation(']'),
 ], true));
-const structKey = (0, core_1.select)([
-    { prefix: '"', parser: exports.string },
+const structKey = select([
+    { prefix: '"', parser: string },
     { prefix: '[', parser: structMapKey },
-    { parser: exports.identifier },
+    { parser: identifier },
 ]);
 const structPairField = (src, ctx) => {
     let isOptional;
@@ -384,124 +338,154 @@ const structPairField = (src, ctx) => {
     }
     const result1 = syntax([
         punctuation(':'),
-        { get: () => exports.type },
+        { get: () => type },
     ], true)(src, ctx);
     const ans = {
         type: 'mcdoc:struct/field/pair',
         children: [...result0.children, ...result1.children],
-        range: core_1.Range.span(result0, result1),
+        range: Range.span(result0, result1),
         isOptional,
     };
     return ans;
 };
-const structSpreadField = (0, core_1.setType)('mcdoc:struct/field/spread', syntax([
+const structSpreadField = setType('mcdoc:struct/field/spread', syntax([
     attributes,
     marker('...'),
-    { get: () => exports.type },
+    { get: () => type },
 ], true));
-const structField = (0, core_1.any)([
+const structField = any([
     structSpreadField,
     structPairField,
 ]);
-const structBlock = (0, core_1.setType)('mcdoc:struct/block', syntax([
+const structBlock = setType('mcdoc:struct/block', syntax([
     punctuation('{'),
-    (0, core_1.select)([
+    select([
         { prefix: '}', parser: punctuation('}') },
         {
             parser: syntax([
                 structField,
-                syntaxRepeat(syntax([marker(','), (0, core_1.failOnEmpty)(structField)], true), true),
-                (0, core_1.optional)(marker(',')),
+                syntaxRepeat(syntax([marker(','), failOnEmpty(structField)], true), true),
+                optional(marker(',')),
                 punctuation('}'),
             ], true),
         },
     ]),
 ], true));
-exports.struct = (0, core_1.setType)('mcdoc:struct', syntax([
+export const struct = setType('mcdoc:struct', syntax([
     prelim,
     keyword('struct'),
-    (0, core_1.optional)((0, core_1.failOnEmpty)(exports.identifier)),
-    optionalTypeParamBlock,
+    optional(failOnEmpty(identifier)),
     structBlock,
 ], true));
-const enumInjection = (0, core_1.setType)('mcdoc:injection/enum', syntax([
+const enumInjection = setType('mcdoc:injection/enum', syntax([
     literal('enum'),
     punctuation('('),
     enumType,
     punctuation(')'),
-    exports.path,
+    path,
     enumBlock,
 ]));
-const structInjection = (0, core_1.setType)('mcdoc:injection/struct', syntax([
+const structInjection = setType('mcdoc:injection/struct', syntax([
     literal('struct'),
-    exports.path,
-    optionalTypeParamBlock,
+    path,
     structBlock,
 ]));
-exports.injection = (0, core_1.setType)('mcdoc:injection', syntax([
+export const injection = setType('mcdoc:injection', syntax([
     keyword('inject'),
-    (0, core_1.select)([
+    select([
         { prefix: 'enum', parser: enumInjection },
         { parser: structInjection },
     ]),
 ]));
-exports.typeAlias = (0, core_1.setType)('mcdoc:type_alias', syntax([
-    prelim,
+const typeParam = setType('mcdoc:type_param', syntax([
+    identifier,
+    // optional(syntax([failOnError(literal('extends')), { get: () => type }])),
+]));
+const typeParamBlock = setType('mcdoc:type_param_block', syntax([
+    punctuation('<'),
+    select([
+        { prefix: '>', parser: punctuation('>') },
+        {
+            parser: syntax([
+                typeParam,
+                syntaxRepeat(syntax([marker(','), failOnEmpty(typeParam)])),
+                optional(marker(',')),
+                punctuation('>'),
+            ]),
+        },
+    ]),
+]));
+const noop = () => undefined;
+const optionalTypeParamBlock = select([
+    { prefix: '<', parser: typeParamBlock },
+    { parser: noop },
+]);
+export const typeAlias = setType('mcdoc:type_alias', syntax([
+    docComments,
     keyword('type'),
-    exports.identifier,
+    identifier,
     optionalTypeParamBlock,
     punctuation('='),
-    { get: () => exports.type },
+    { get: () => type },
 ], true));
-exports.useStatement = (0, core_1.setType)('mcdoc:use_statement', syntax([
+export const useStatement = setType('mcdoc:use_statement', syntax([
     keyword('use'),
-    exports.path,
-    (0, core_1.select)([
-        { prefix: 'as', parser: syntax([literal('as'), exports.identifier]) },
+    path,
+    select([
+        { prefix: 'as', parser: syntax([literal('as'), identifier]) },
         { parser: noop },
     ]),
-]));
-const topLevel = (0, core_1.any)([
-    exports.comment,
-    exports.dispatchStatement,
-    exports.enum_,
-    exports.injection,
-    exports.struct,
-    exports.typeAlias,
-    exports.useStatement,
+], true));
+const topLevel = any([
+    comment,
+    dispatchStatement,
+    enum_,
+    injection,
+    struct,
+    typeAlias,
+    useStatement,
 ]);
-exports.module_ = (0, core_1.setType)('mcdoc:module', syntaxRepeat(topLevel, true));
+export const module_ = setType('mcdoc:module', syntaxRepeat(topLevel, true));
 /* eslint-enable @typescript-eslint/indent */
 function typeBase(type, parser) {
-    return (0, core_1.setType)(type, syntax([
+    return setType(type, syntax([
         attributes,
         parser,
-        syntaxRepeat((0, core_1.failOnError)(indexBody())),
+        syntaxRepeat(failOnError(indexBody())),
     ], true));
 }
-exports.anyType = typeBase('mcdoc:type/any', keyword('any', { colorTokenType: 'type' }));
-exports.booleanType = typeBase('mcdoc:type/boolean', keyword('boolean', { colorTokenType: 'type' }));
-exports.integer = core.integer({
+export const anyType = typeBase('mcdoc:type/any', keyword('any', { colorTokenType: 'type' }));
+export const booleanType = typeBase('mcdoc:type/boolean', keyword('boolean', { colorTokenType: 'type' }));
+export const integer = core.integer({
     pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
 });
 function range(type, number) {
-    return (0, core_1.setType)(type, (0, core_1.select)([
+    const delimiterPredicate = (src) => src.tryPeek('..') || src.tryPeek(`${RangeExclusiveChar}..`);
+    const delimiterParser = literal([
+        '..',
+        `..${RangeExclusiveChar}`,
+        `${RangeExclusiveChar}..`,
+        `${RangeExclusiveChar}..${RangeExclusiveChar}`,
+    ], {
+        allowedChars: new Set(['.', RangeExclusiveChar]),
+    });
+    return setType(type, select([
         {
-            prefix: '..',
-            parser: (0, core_1.sequence)([
-                literal('..', { allowedChars: new Set('.') }),
+            predicate: delimiterPredicate,
+            parser: sequence([
+                delimiterParser,
                 number,
             ]),
         },
         {
-            parser: (0, core_1.sequence)([
-                (0, core_1.stopBefore)(number, '..'),
-                (0, core_1.select)([
+            parser: sequence([
+                stopBefore(number, '..'),
+                select([
                     {
-                        prefix: '..',
-                        parser: (0, core_1.sequence)([
-                            literal('..', { allowedChars: new Set('.') }),
-                            (0, core_1.optional)((0, core_1.failOnEmpty)(number)),
+                        predicate: delimiterPredicate,
+                        parser: sequence([
+                            delimiterParser,
+                            optional(failOnEmpty(number)),
                         ]),
                     },
                     { parser: noop },
@@ -510,122 +494,122 @@ function range(type, number) {
         },
     ]));
 }
-const intRange = range('mcdoc:int_range', exports.integer);
-const atIntRange = (0, core_1.optional)((src, ctx) => {
+export const intRange = range('mcdoc:int_range', integer);
+const atIntRange = optional((src, ctx) => {
     if (!src.trySkip('@')) {
-        return core_1.Failure;
+        return Failure;
     }
     src.skipWhitespace();
     return intRange(src, ctx);
 });
-exports.stringType = typeBase('mcdoc:type/string', syntax([
+export const stringType = typeBase('mcdoc:type/string', syntax([
     keyword('string', { colorTokenType: 'type' }),
     atIntRange,
 ]));
-exports.literalType = typeBase('mcdoc:type/literal', (0, core_1.select)([
+export const literalType = typeBase('mcdoc:type/literal', select([
     { predicate: src => src.tryPeek('false') || src.tryPeek('true'), parser: keyword(['false', 'true'], { colorTokenType: 'type' }) },
-    { prefix: '"', parser: (0, core_1.failOnEmpty)(exports.string) },
-    { parser: (0, core_1.failOnError)(exports.typedNumber) },
+    { prefix: '"', parser: failOnEmpty(string) },
+    { parser: failOnError(typedNumber) },
 ]));
-const floatRange = range('mcdoc:float_range', exports.float);
-const atFloatRange = (0, core_1.optional)((src, ctx) => {
+export const floatRange = range('mcdoc:float_range', float);
+const atFloatRange = optional((src, ctx) => {
     if (!src.trySkip('@')) {
-        return core_1.Failure;
+        return Failure;
     }
     src.skipWhitespace();
     return floatRange(src, ctx);
 });
-exports.numericType = typeBase('mcdoc:type/numeric_type', (0, core_1.select)([
+export const numericType = typeBase('mcdoc:type/numeric_type', select([
     {
-        predicate: src => src.tryPeek('float') || src.tryPeek('double'),
+        predicate: src => NumericTypeFloatKinds.some(k => src.tryPeek(k)),
         parser: syntax([
-            keyword(['float', 'double'], { colorTokenType: 'type' }),
+            keyword(NumericTypeFloatKinds, { colorTokenType: 'type' }),
             atFloatRange,
         ]),
     },
     {
         parser: syntax([
-            keyword(['byte', 'short', 'int', 'long'], { colorTokenType: 'type' }),
+            keyword(NumericTypeIntKinds, { colorTokenType: 'type' }),
             atIntRange,
         ]),
     },
 ]));
-exports.primitiveArrayType = typeBase('mcdoc:type/primitive_array', syntax([
-    literal(['byte', 'int', 'long']),
+export const primitiveArrayType = typeBase('mcdoc:type/primitive_array', syntax([
+    literal(PrimitiveArrayValueKinds),
     atIntRange,
     keyword('[]', { allowedChars: new Set(['[', ']']), colorTokenType: 'type' }),
     atIntRange,
 ]));
-exports.listType = typeBase('mcdoc:type/list', syntax([
+export const listType = typeBase('mcdoc:type/list', syntax([
     marker('['),
-    { get: () => exports.type },
+    { get: () => type },
     punctuation(']'),
     atIntRange,
 ], true));
-exports.tupleType = typeBase('mcdoc:type/tuple', syntax([
+export const tupleType = typeBase('mcdoc:type/tuple', syntax([
     marker('['),
-    { get: () => exports.type },
+    { get: () => type },
     marker(','),
-    (0, core_1.select)([
+    select([
         { prefix: ']', parser: punctuation(']') },
         {
             parser: syntax([
-                { get: () => exports.type },
-                syntaxRepeat(syntax([marker(','), { get: () => (0, core_1.failOnEmpty)(exports.type) }], true), true),
-                (0, core_1.optional)(marker(',')),
+                { get: () => type },
+                syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(type) }], true), true),
+                optional(marker(',')),
                 punctuation(']'),
             ], true),
         },
     ]),
 ], true));
-exports.dispatcherType = typeBase('mcdoc:type/dispatcher', syntax([
-    (0, core_1.failOnError)(resLoc({ category: 'mcdoc/dispatcher' })),
+export const dispatcherType = typeBase('mcdoc:type/dispatcher', syntax([
+    failOnError(resLoc({ category: 'mcdoc/dispatcher' })),
     indexBody(),
 ]));
-exports.unionType = typeBase('mcdoc:type/union', syntax([
+export const unionType = typeBase('mcdoc:type/union', syntax([
     marker('('),
-    (0, core_1.select)([
+    select([
         { prefix: ')', parser: punctuation(')') },
         {
             parser: syntax([
-                { get: () => exports.type },
-                syntaxRepeat(syntax([marker('|'), { get: () => (0, core_1.failOnEmpty)(exports.type) }], true), true),
-                (0, core_1.optional)(marker('|')),
+                { get: () => type },
+                syntaxRepeat(syntax([marker('|'), { get: () => failOnEmpty(type) }], true), true),
+                optional(marker('|')),
                 punctuation(')'),
             ], true),
         },
     ]),
 ]));
-exports.pathType = typeBase('mcdoc:type/path', syntax([
-    exports.path,
-    (0, core_1.optional)(syntax([
+export const referenceType = typeBase('mcdoc:type/reference', syntax([
+    path,
+    optional(syntax([
         marker('<'),
-        (0, core_1.select)([
+        select([
             { prefix: '>', parser: punctuation('>') },
             {
                 parser: syntax([
-                    { get: () => exports.type },
-                    syntaxRepeat(syntax([marker(','), { get: () => (0, core_1.failOnEmpty)(exports.type) }], true), true),
-                    (0, core_1.optional)(marker(',')),
+                    { get: () => type },
+                    syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(type) }], true), true),
+                    optional(marker(',')),
                     punctuation('>'),
                 ], true),
             },
         ]),
     ])),
 ]));
-exports.type = (0, core_1.any)([
-    exports.anyType,
-    exports.booleanType,
-    exports.dispatcherType,
-    exports.enum_,
-    exports.listType,
-    exports.literalType,
-    exports.numericType,
-    exports.primitiveArrayType,
-    exports.stringType,
-    exports.struct,
-    exports.tupleType,
-    exports.unionType,
-    exports.pathType,
+export const type = any([
+    anyType,
+    booleanType,
+    dispatcherType,
+    enum_,
+    listType,
+    literalType,
+    numericType,
+    primitiveArrayType,
+    stringType,
+    struct,
+    tupleType,
+    unionType,
+    referenceType,
 ]);
 //# sourceMappingURL=index.js.map