@manifest-configuration-language/language 0.0.0-stage → 0.1.2

package/README.md

@@ -1,3 +1,16 @@
-# Temporary Holding Version
+# @manifest-configuration-language/language
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@manifest-configuration-language/language` contains the MCL TextMate grammar and a Lezer-backed CodeMirror `LanguageSupport` export with standard bracket completion.
+
+```js
+import { mclLanguageSupport } from "@manifest-configuration-language/language";
+import mclTextMateGrammar from "@manifest-configuration-language/language/textmate" with { type: "json" };
+
+const support = mclLanguageSupport();
+```
+
+The Lezer parser provides incremental syntax trees and CodeMirror highlighting for declarations, generic and schema-backed types, expressions, indentation-sensitive map/list blocks, block-level `if`/`else` and `for` expressions, dynamic `key(...)` map keys, node declarations, `with`/`without` overlays, typed functions, and validation rules. Descendant validation supports a type selector, `where = fn(...) => ...`, and `select = bySchema(Type)`; each selector may include the optional integer `minMatches` argument. The grammar recognizes source structure and does not validate evaluation semantics.
+
+`npm run check:parity` checks that TextMate and Lezer expose the same keywords, tokenizes representative MCL constructs with the VS Code TextMate tokenizer and checks their scopes, parses package-owned fixtures and every `.mcl` example under `cmd/mcl-wasm/testdata/examples` with both Lezer and the Go formatter, and verifies one malformed declaration is rejected by both parsers. The tokenization check covers comments, strings, keywords, identifiers, function calls, and operators. The fixtures cover descendant selector variants, dynamic map keys, schema-backed types, qualified rule references, nested application manifests, and final `if`/`else` expressions. The parity check uses the Go CLI as the syntax reference. `src/mcl.tmLanguage.json` is the package-owned TextMate grammar source; sibling VS Code and Website copies still need migration to this package.
+
+Build generation runs during `prepack` with the pinned `@lezer/generator` dependency. CodeMirror packages, including `@codemirror/autocomplete` for bracket completion, are peers so applications can share their existing editor runtime. The parity check also constructs the support in a Node `EditorState` to catch package integration errors.

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@manifest-configuration-language/language",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "MCL TextMate grammar and CodeMirror language support.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/manifest-configuration-language/mcl.git",
+    "directory": "packages/language"
+  },
+  "type": "module",
+  "license": "Apache-2.0",
+  "files": ["src", "README.md"],
+  "exports": {
+    ".": { "types": "./src/index.d.ts", "import": "./src/index.js" },
+    "./textmate": "./src/mcl.tmLanguage.json"
+  },
+  "scripts": {
+    "build": "lezer-generator src/mcl.grammar -o src/parser.js",
+    "check:parity": "npm run build && node scripts/check-parity.mjs && node scripts/check-textmate.mjs && node scripts/smoke-language-support.mjs",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@lezer/highlight": "1.2.5",
+    "@lezer/lr": "1.4.11"
+  },
+  "devDependencies": {
+    "@lezer/generator": "1.8.1",
+    "vscode-oniguruma": "2.0.1",
+    "vscode-textmate": "9.3.2"
+  },
+  "peerDependencies": {
+    "@codemirror/autocomplete": ">=6 <7",
+    "@codemirror/language": ">=6 <7",
+    "@codemirror/state": ">=6 <7",
+    "@codemirror/view": ">=6 <7"
+  },
+  "publishConfig": { "access": "public" }
+}

package/src/index.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageSupport } from "@codemirror/language";
+import type { LRParser } from "@lezer/lr";
+
+export declare const parser: LRParser;
+export declare function mclLanguageSupport(): LanguageSupport;

package/src/index.js

@@ -0,0 +1,57 @@
+import { LanguageSupport, LRLanguage, continuedIndent, foldService, indentNodeProp, syntaxTree } from "@codemirror/language";
+import { closeBrackets } from "@codemirror/autocomplete";
+import { styleTags, tags } from "@lezer/highlight";
+import { parser as generatedParser } from "./parser.js";
+
+export const parser = generatedParser.configure({
+  props: [
+    styleTags({
+      "import as export type let fn rule emit validate require message using for in if else each descendants where select bySchema minMatches requireEach requireDescendants and or not is with without output schema key": tags.keyword,
+      "Any Null Bool Int Decimal String List Map Function Node Schema": tags.typeName,
+      "true false null": tags.bool,
+      Identifier: tags.variableName,
+      QuotedString: tags.string,
+      Number: tags.number,
+      Comment: tags.comment,
+      Operator: tags.operator,
+    }),
+    indentNodeProp.add({
+      LetBlockDeclaration: continuedIndent(),
+      Block: continuedIndent({ except: /^\s*else\b/ }),
+      IfExpression: continuedIndent({ except: /^\s*else\b/ }),
+      ForExpression: continuedIndent(),
+      TypeRecordBlock: continuedIndent(),
+      RuleBlock: continuedIndent(),
+    }),
+  ],
+});
+
+const language = LRLanguage.define({
+  name: "mcl",
+  parser,
+  languageData: { commentTokens: { line: "#" } },
+});
+
+export function mclLanguageSupport() {
+  return new LanguageSupport(language, [closeBrackets(), foldService.of(foldMclBlock)]);
+}
+
+function foldMclBlock(state, lineStart, lineEnd) {
+  const tree = syntaxTree(state);
+  const text = state.doc.sliceString(lineStart, lineEnd).trim();
+  const isElseHeader = /^else\s*:/.test(text);
+  for (let node = tree.resolveInner(lineEnd, -1); node; node = node.parent) {
+    if (isElseHeader ? node.name !== "IfExpression" : node.from < lineStart || node.from > lineEnd) continue;
+
+    let candidate;
+    for (let child = node.firstChild; child; child = child.nextSibling) {
+      if (child.name === "Block" && child.from >= lineEnd) {
+        candidate = child;
+        if (!isElseHeader) break;
+      }
+    }
+    if (candidate && candidate.to > lineEnd) return { from: lineEnd, to: candidate.to };
+    if (isElseHeader) return null;
+  }
+  return null;
+}

package/src/layout.js

@@ -0,0 +1,45 @@
+import { ContextTracker, ExternalTokenizer } from "@lezer/lr";
+import { blankLineStart, dedent, indent } from "./parser.terms.js";
+
+class IndentLevel {
+  constructor(parent, depth) {
+    this.parent = parent;
+    this.depth = depth;
+    this.hash = (parent ? (parent.hash + parent.hash) << 8 : 0) + depth + (depth << 4);
+  }
+}
+
+export const trackIndent = new ContextTracker({
+  start: new IndentLevel(null, 0),
+  shift(context, term, stack, input) {
+    if (term === indent) return new IndentLevel(context, stack.pos - input.pos);
+    if (term === dedent) return context.parent;
+    return context;
+  },
+  hash: (context) => context.hash,
+});
+
+const newline = 10;
+const carriageReturn = 13;
+const space = 32;
+const tab = 9;
+const hash = 35;
+
+export const indentation = new ExternalTokenizer((input, stack) => {
+  const previous = input.peek(-1);
+  if (previous !== -1 && previous !== newline && previous !== carriageReturn) return;
+
+  let spaces = 0;
+  while (input.next === space || input.next === tab) {
+    input.advance();
+    spaces += 1;
+  }
+
+  if ((input.next === newline || input.next === carriageReturn || input.next === hash) && stack.canShift(blankLineStart)) {
+    input.acceptToken(blankLineStart, -spaces);
+  } else if (spaces > stack.context.depth) {
+    input.acceptToken(indent);
+  } else if (spaces < stack.context.depth) {
+    input.acceptToken(dedent, -spaces);
+  }
+}, { contextual: true });

package/src/mcl.grammar

@@ -0,0 +1,137 @@
+@top MCL { (BlockStatement | FunctionDeclaration | Statement lineEnd)* }
+
+Statement {
+  ImportDeclaration |
+  TypeDeclaration |
+  LetDeclaration |
+  EmitStatement |
+  ValidateStatement |
+  ExpressionStatement
+}
+
+BlockStatement { TypeRecordDeclaration | LetBlockDeclaration | LetNodeDeclaration | LetOverlayDeclaration | LetRemovalDeclaration | RuleDeclaration }
+
+ImportDeclaration { Export? kw<"import"> QuotedString kw<"as"> Identifier }
+Export { kw<"export"> }
+TypeDeclaration { Export? kw<"type"> Identifier TypeParameterList? "=" TypeExpression }
+TypeRecordDeclaration { Export? kw<"type"> Identifier TypeParameterList? "=" lineEnd TypeRecordBlock }
+LetDeclaration { Export? kw<"let"> Identifier TypeAnnotation? "=" Expression }
+LetBlockDeclaration { Export? kw<"let"> Identifier TypeAnnotation? "=" lineEnd Block }
+LetNodeDeclaration { Export? kw<"let"> Identifier TypeAnnotation? "=" NodeExpression }
+LetOverlayDeclaration { Export? kw<"let"> Identifier TypeAnnotation? "=" OverlayExpression }
+LetRemovalDeclaration { Export? kw<"let"> Identifier TypeAnnotation? "=" RemovalExpression }
+TypeAnnotation { ":" TypeExpression }
+FunctionDeclaration { Export? kw<"fn"> Identifier "(" ParameterList? ")" (("->" | ":") TypeExpression)? "=" FunctionBody }
+FunctionBody { Expression lineEnd | lineEnd Block }
+TypeParameterList { "<" Identifier ("," Identifier)* ","? ">" }
+ParameterList { Parameter ("," Parameter)* ","? }
+Parameter { Identifier TypeAnnotation? }
+RuleDeclaration { Export? kw<"rule"> Identifier "(" TypedParameter ")" ":" lineEnd RuleBlock }
+TypedParameter { Identifier ":" TypeExpression }
+RuleBlock { indent RequireStatement+ (dedent | eof) }
+RequireStatement { kw<"require"> Expression (kw<"message"> QuotedString)? lineEnd }
+EmitStatement { kw<"emit"> kw<"each">? Expression }
+ValidateStatement { kw<"validate"> (kw<"each"> DescendantsQuery | Expression) kw<"using"> RuleReference }
+RuleReference { Identifier ("." Identifier)* }
+DescendantsQuery { kw<"descendants"> "(" kw<"output"> "," (TypeExpression | NamedQuerySelector) ("," kw<"minMatches"> "=" Number)? ")" }
+NamedQuerySelector { kw<"where"> "=" LambdaExpression | kw<"select"> "=" BySchemaSelector }
+BySchemaSelector { kw<"bySchema"> "(" TypeExpression ")" }
+ExpressionStatement { Expression }
+
+Block { indent BlockLine+ (dedent | eof) }
+BlockLine { MapEntry | SequenceItem | RequireStatement | IfExpression | ForExpression | Expression lineEnd }
+MapEntry { MapEntryKey ":" (Expression lineEnd | lineEnd Block | lineEnd) }
+MapEntryKey { DynamicMapKey | MapKey }
+DynamicMapKey { kw<"key"> "(" Expression ")" }
+MapKey { Identifier | MapKeyword | QuotedString | Number }
+SequenceItem { ListMarker ((MapEntryKey ":" Expression) | Expression)? (lineEnd Block | lineEnd) }
+TypeRecordBlock { indent TypeField+ (dedent | eof) }
+TypeField { MapKey "?"? ":" TypeExpression lineEnd }
+
+TypeExpression { TypeAtom ("|" TypeAtom)* }
+TypeAtom {
+  PrimitiveType TypeArguments? |
+  kw<"schema"> "(" QuotedString ")" |
+  QuotedString |
+  TypeReference |
+  "{" TypeFieldInline ("," TypeFieldInline)* ","? "}" |
+  "(" TypeExpression ")"
+}
+TypeReference { Identifier ("." Identifier)* TypeArguments? }
+TypeArguments { "<" TypeExpression ("," TypeExpression)* ","? ">" }
+TypeFieldInline { MapKey "?"? ":" TypeExpression }
+PrimitiveType { kw<"Any"> | kw<"Null"> | kw<"Bool"> | kw<"Int"> | kw<"Decimal"> | kw<"String"> | kw<"List"> | kw<"Map"> | kw<"Function"> | kw<"Node"> | kw<"Schema"> }
+
+Expression { UnaryExpression (BinaryOperator UnaryExpression)* }
+UnaryExpression { kw<"not"> PostfixExpression | NegativeNumber | PostfixExpression }
+PostfixExpression { PrimaryExpression Postfix* }
+OverlayExpression { PrimaryExpression Postfix* Overlay }
+Overlay { kw<"with"> ":" lineEnd Block }
+RemovalExpression { PrimaryExpression Postfix* Removal }
+Removal { kw<"without"> ":" lineEnd Block }
+Postfix {
+  CallArguments |
+  "." MapKey |
+  "?." MapKey |
+  "[" Expression "]"
+}
+PrimaryExpression {
+  Number | QuotedString | MultiString | kw<"true"> | kw<"false"> | kw<"null"> |
+  Identifier | PrimitiveType |
+  "." Identifier |
+  "(" Expression ")" |
+  ListExpression |
+  InlineMap
+}
+NodeExpression { kw<"node"> ":" lineEnd Block }
+IfExpression { kw<"if"> Expression ":" lineEnd Block (kw<"else"> ":" lineEnd Block)? }
+ForExpression { kw<"for"> Identifier kw<"in"> Expression ":" lineEnd Block }
+LambdaExpression { kw<"fn"> "(" ParameterList? ")" "=>" Expression }
+ListExpression { "[" (Expression ("," Expression)* ","?)? "]" }
+InlineMap { "{" (InlineMapEntry ("," InlineMapEntry)* ","?)? "}" }
+InlineMapEntry { MapEntryKey ":" Expression }
+CallArguments { "(" (CallArgument ("," CallArgument)* ","? | lineEnd indent CallArgument ("," lineEnd? CallArgument)* ","? lineEnd dedent)? ")" }
+CallArgument { ((Identifier | kw<"key">) "=" )? (LambdaExpression | Expression) }
+BinaryOperator { Operator | Minus | kw<"and"> | kw<"or"> | kw<"in"> }
+
+@context trackIndent from "./layout.js"
+@external tokens indentation from "./layout.js" {
+  indent
+  dedent
+  blankLineStart
+}
+
+@tokens {
+  @precedence { NegativeNumber, Minus }
+  Identifier { $[A-Za-z_] $[A-Za-z0-9_]* }
+  ListMarker { "-" $[ \t]+ }
+  NegativeNumber { "-" $[0-9]+ ("." $[0-9]+)? ($[eE] $[+-]? $[0-9]+)? }
+  Number { $[0-9]+ ("." $[0-9]+)? ($[eE] $[+-]? $[0-9]+)? }
+  QuotedString { "\"" ("\\" _ | !["\\\n\r])* "\"" }
+  MultiString { "\"\"\"" (!["] | "\"" !["] | "\"\"" !["])* "\"\"\"" }
+  Comment { "#" ![\n\r]* }
+  Operator { "==" | "!=" | "<=" | ">=" | "??" | "=>" | "->" | "+" | "*" | "/" | "%" | "|" | "<" | ">" }
+  Minus { "-" }
+  newline { "\r"? "\n" | "\r" }
+  eof { @eof }
+  spaces { $[ \t]+ }
+}
+
+@skip {
+  spaces |
+  Comment |
+  blankLineStart (spaces | Comment)* lineEnd
+}
+
+lineEnd { newline | eof }
+
+kw<term> { @specialize[@name={term}]<Identifier, term> }
+
+MapKeyword {
+  kw<"import"> | kw<"as"> | kw<"export"> | kw<"type"> | kw<"let"> | kw<"fn"> | kw<"rule"> | kw<"emit"> |
+  kw<"validate"> | kw<"require"> | kw<"message"> | kw<"using"> | kw<"in"> | kw<"each"> | kw<"descendants"> |
+  kw<"where"> | kw<"select"> | kw<"bySchema"> | kw<"minMatches"> | kw<"requireEach"> | kw<"requireDescendants"> |
+  kw<"and"> | kw<"or"> | kw<"not"> | kw<"with"> | kw<"without"> | kw<"output"> | kw<"Any"> |
+  kw<"Null"> | kw<"Bool"> | kw<"Int"> | kw<"Decimal"> | kw<"String"> | kw<"List"> | kw<"Map"> | kw<"schema"> |
+  kw<"Function"> | kw<"Node"> | kw<"Schema"> | kw<"true"> | kw<"false"> | kw<"null">
+}

package/src/mcl.tmLanguage.json

@@ -0,0 +1,162 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "MCL",
+  "scopeName": "source.mcl",
+  "patterns": [
+    {
+      "include": "#comments"
+    },
+    {
+      "include": "#multiline-strings"
+    },
+    {
+      "include": "#strings"
+    },
+    {
+      "include": "#keywords"
+    },
+    {
+      "include": "#constants"
+    },
+    {
+      "include": "#types"
+    },
+    {
+      "include": "#function-calls"
+    },
+    {
+      "include": "#identifiers"
+    },
+    {
+      "include": "#numbers"
+    },
+    {
+      "include": "#operators"
+    },
+    {
+      "include": "#punctuation"
+    }
+  ],
+  "repository": {
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.line.number-sign.mcl",
+          "match": "(?<= )#.*$|^#.*$"
+        }
+      ]
+    },
+    "strings": {
+      "name": "string.quoted.double.mcl",
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.mcl"
+        }
+      },
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.mcl"
+        }
+      },
+      "patterns": [
+        {
+          "name": "constant.character.escape.mcl",
+          "match": "\\\\."
+        }
+      ]
+    },
+    "multiline-strings": {
+      "name": "string.quoted.multi.double.mcl",
+      "begin": "\"\"\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.mcl"
+        }
+      },
+      "end": "\"\"\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.mcl"
+        }
+      }
+    },
+    "keywords": {
+      "patterns": [
+        {
+          "name": "keyword.control.mcl",
+          "match": "\\b(?:import|as|export|let|type|fn|rule|emit|validate|require|message|using|for|in|if|else|each|descendants|where|select|bySchema|minMatches|requireEach|requireDescendants|node|with|without|schema|key)\\b"
+        },
+        {
+          "name": "keyword.operator.mcl",
+          "match": "\\b(?:and|or|not)\\b"
+        }
+      ]
+    },
+    "constants": {
+      "patterns": [
+        {
+          "name": "constant.language.mcl",
+          "match": "\\b(?:true|false|null|output)\\b"
+        }
+      ]
+    },
+    "types": {
+      "patterns": [
+        {
+          "name": "storage.type.mcl",
+          "match": "\\b(?:Any|Null|Bool|Int|Decimal|String|List|Map|Function|Node|Schema)\\b"
+        }
+      ]
+    },
+    "function-calls": {
+      "patterns": [
+        {
+          "name": "entity.name.function.mcl",
+          "match": "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\s*\\()"
+        }
+      ]
+    },
+    "identifiers": {
+      "patterns": [
+        {
+          "name": "variable.other.mcl",
+          "match": "\\b[A-Za-z_][A-Za-z0-9_]*\\b"
+        }
+      ]
+    },
+    "numbers": {
+      "patterns": [
+        {
+          "name": "constant.numeric.mcl",
+          "match": "\\b\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?\\b"
+        }
+      ]
+    },
+    "operators": {
+      "patterns": [
+        {
+          "name": "keyword.operator.mcl",
+          "match": "(?:==|!=|<=|>=|\\?\\?|=>|->|\\+|-|\\*|/|%|=|\\||<|>)"
+        }
+      ]
+    },
+    "punctuation": {
+      "patterns": [
+        {
+          "name": "punctuation.separator.key-value.mcl",
+          "match": ":"
+        },
+        {
+          "name": "punctuation.separator.comma.mcl",
+          "match": ","
+        },
+        {
+          "name": "punctuation.accessor.mcl",
+          "match": "\\.|\\?"
+        }
+      ]
+    }
+  }
+}

package/src/parser.js

@@ -0,0 +1,20 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+import {LRParser} from "@lezer/lr"
+import {indentation, trackIndent} from "./layout.js"
+const spec_Identifier = {__proto__:null,export:14, type:16, import:28, as:30, let:32, fn:34, rule:36, emit:38, validate:40, require:42, message:44, using:46, in:48, each:50, descendants:52, where:54, select:56, bySchema:58, minMatches:60, requireEach:62, requireDescendants:64, and:66, or:68, not:70, with:72, without:74, output:76, Any:78, Null:80, Bool:82, Int:84, Decimal:86, String:88, List:90, Map:92, schema:94, Function:96, Node:98, Schema:100, true:102, false:104, null:106, key:138, if:184, else:186, for:190, node:196}
+export const parser = LRParser.deserialize({
+  version: 14,
+  states: "!)nQ]QROOP#cOPOOO%UQRO'#DyO(_QRO'#DzOOQP'#Dw'#DwO(fQRO'#DwO#hQRO'#DwO)`QRO'#DvOOQP'#Du'#DuO*[QRO'#DtOOQP'#C_'#C_OOQP'#Ex'#ExOOQP'#En'#EnOOQP'#Ez'#EzO*{QRO'#EzQ]QROOOOQP'#Ca'#CaOOQP'#Dh'#DhO+TQRO'#EpO+YQRO'#E`O+kQRO'#DuO-RQRO'#E`O-WQRO'#EiO-]QRO'#ElO-bQRO'#EoO-gQRO'#ErO-nQRO'#EsP-uOQO)CAUOOQP,5:e,5:eO.TQRO,5:eOOQP'#Ch'#ChO.]QRO'#D{OOQP,5:f,5:fO.bQRO,5:fOOQP'#Dq'#DqOOQP'#Ci'#CiO.jQRO'#DrOOQP,5:c,5:cO.oQRO,5:cO0nQRO'#D}OOQP'#D|'#D|O0uQRO'#D|O#hQRO'#D|OOQP'#FU'#FUO4iQRO,5:bOOQP'#ET'#ETO#hQRO'#FYO5SQRO,5:`OOQP'#Fb'#FbOOQP,5;f,5;fOOQP-E8x-E8xO5sQTO,5;[O5{QRO,5;[O6QQRO,5:zO6VQRO,5;TO6[QRO,5;WO6aQRO,5;ZOOQP,5:a,5:aO6fQRO,5:zO6nQRO,5;TO6sQRO,5;WO6xQRO,5;ZOOQP,5;^,5;^O#hQRO,5;^O6}QRO,5;_O7SQRO,5;_POOO'#Ey'#EyP-uOQO/'6pPOOO/'6p/'6pO7XQRO1G0PO7`QRO1G0POOQP1G0P1G0PO#hQRO,5:gO7hQRO1G0QO7oQRO1G0QOOQP1G0Q1G0QO#hQRO,5:^OOQP1G/}1G/}O8lQRO'#DwOOQP'#EO'#EOOOQP,5:i,5:iO8yQRO,5:iO9RQRO,5:iO9WQRO'#EPO9]QRO'#EOOOQP,5:h,5:hO9bQRO,5:hOOQP-E9S-E9SOOQP,5;t,5;tOOQP-E9W-E9WO9gQRO'#CeO9lQRO1G0vO:vQRO1G0vO:{QTO1G0vO;TQRO1G0fO;]QRO1G0oO;bQRO1G0rO;gQRO1G0uO;lQRO'#DmO<pQRO1G0fO<}QRO1G0fO=SQRO1G0oO=XQRO1G0rO=aQRO1G0uOOQP1G0x1G0xO=fQRO'#EtO=kQRO1G0yO=pQRO1G0yPOOO-E8w-E8wPOOO49,[49,[OOQP,5;n,5;nOOQP7+%k7+%kO=uQRO7+%kOOQP-E9Q-E9QOOQP1G0R1G0ROOQP,5;o,5;oOOQP7+%l7+%lO=|QRO7+%lOOQP-E9R-E9RO>TQRO1G/xO>YQRO,5:jO@TQRO1G0TO@[QRO1G0TOOQP1G0T1G0TO>aQRO1G0TO@dQRO,5:kOOQP1G0S1G0SO@lQTO,59PO@tQTO'#DjOAfQTO'#DgOOQP'#Dg'#DgO0uQRO'#DgO;lQRO'#DgOBTQTO'#DfOBoQRO'#DgOBtQRO7+$QOOQP7+&b7+&bO9lQRO7+&bOByQRO7+&bO<pQRO7+&QOCOQRO7+&QO=SQRO7+&ZOCTQRO7+&^OC]QRO7+&aOOQP,5:X,5:XOCbQRO'#DvOClQRO7+%^OCqQRO'#EaOOQP7+&Q7+&QOOQP7+&T7+&TOOQP7+&W7+&WOOQP7+&c7+&cOCvQRO'#EjOC{QRO7+&ZODQQRO'#EROD]QRO'#EQODeQTO7+&^OCWQRO7+&^OOQP7+&a7+&aODpQRO,5;`O=pQRO7+&eODuQRO'#EwOOQP7+&e7+&eOOQP<<IV<<IVP#hQRO'#FSOOQP<<IW<<IWP%]QRO'#FTOOQP7+%d7+%dOOQP1G0U1G0UOOQP,5;r,5;rOOQP7+%o7+%oOEQQRO7+%oOOQP-E9U-E9UOEXQRO7+%oOEdQXO1G0VOEiQRO1G0VOEnQTO1G.kOEvQTO1G.kOOQP1G.k1G.kO;lQRO'#DiOFOQRO'#FOOFTQTO,5:UOOQP,5:U,5:UOOQP,5:R,5:ROFuQTO'#DkOF}QRO,5:ROGVQRO,5:RO;lQRO'#FQOG[QTO,5:QOGvQRO,5:RO0uQRO'#CfOOQP<<Gl<<GlOBtQRO<<GlOOQP<<I|<<I|O9lQRO<<I|OClQRO<<HxOOQP<<Il<<IlOOQP<<Io<<IoOOQP<<Ir<<IrOOQP<<I}<<I}O<pQRO<<IlOG{QRO<<IuOHQQTO<<IxOH]QRO<<IxOOQP<<I{<<I{OHbQRO,5:bOOQP,5;O,5;OOOQP,5;R,5;ROHlQRO'#EeOHqQRO'#EhOHvQTO'#DnOOQP<<Hx<<HxO*{QRO,5:{O;lQRO,5;UOLeQRO<<IuOOQP,5:m,5:mOLjQRO,5:lOLrQRO,5:lO<sQRO<<IxO;lQRO<<IxOLzQRO1G0zOOQP<<JP<<JPOMPQRO,5;cOOQP<<IZ<<IZP>aQRO'#FWO.tQRO<<IZOM[QRO<<IZOMgQRO<<IZO#hQRO7+%qOMlQXO7+%qOOQP,5;g,5;gOOQP7+$V7+$VOMqQTO7+$VOOQP-E8y-E8yOMyQTO,5:TOOQP,5;j,5;jOOQP-E8|-E8|OOQP1G/p1G/pO;lQRO,5:VONRQRO,5:VONWQRO1G/mON_QRO1G/mOOQP1G/m1G/mOOQP,5;l,5;lOOQP-E9O-E9OONgQRO1G/mONlQTO'#CgOOQP'#E|'#E|ONtQRO,59QOOQPAN=WAN=WOBtQROAN=WOOQPAN?hAN?hOOQPAN>dAN>dOClQROAN>dOOQPAN?WAN?WOOQPAN?ZAN?ZOOQPAN?^AN?^OOQPAN?iAN?iO! OQROAN?aO<sQROAN?dO;lQROAN?dO! TQTOAN?dOOQP1G0j1G0jOOQP1G0m1G0mO*{QRO,5;PO*{QRO,5;SO! `QRO'#ChO! gQRO'#DpO!$}QRO'#EWOOQP'#Do'#DoO*{QRO'#DoOOQP'#FR'#FRO!%[QTO,5:YO!%fQRO'#CiO!%mQRO'#CiO!%tQRO'#CiO!&lQRO'#CiO#hQRO'#EZO!&sQRO'#E^OClQRO1G0gOOQP1G0p1G0pO*{QROAN?aOOQP,5;q,5;qO!&xQRO1G0WOOQP-E9T-E9TO*{QRO'#EmOClQRO'#EmOOQPAN?dAN?dO!'QQROAN?dO!'VQRO7+&fOOQP,5;s,5;sO!'aQROAN>uO.tQROAN>uOOQP-E9V-E9VO!'hQROAN>uO!'mQROAN>uOOQP<<I]<<I]O#hQRO<<I]OOQP<<Gq<<GqP!'rQRO'#E{O!'wQTO1G/oO!(OQTO1G/oOOQP1G/o1G/oOOQP1G/q1G/qO;lQRO1G/qOOQP,5;k,5;kOOQP7+%X7+%XO!(WQRO7+%XOOQP-E8}-E8}O;lQRO,59RO!(_QRO,59ROOQP-E8z-E8zOOQP1G.l1G.lOOQPG22rG22rOOQPG24OG24OO*{QROG24{OOQPG25OG25OO!(dQROG25OO<sQROG25OO;lQROG25OOClQRO1G0kOClQRO1G0nO<sQRO,5:[O!(iQTO,5:rO!,aQRO,5:rO*{QRO,5:rOOQP,5:Z,5:ZOOQP-E9P-E9POOQP1G/t1G/tO!,fQRO,5:tO!,qQRO,5:uO!,vQRO,5:xOOQP7+&R7+&RO!,{QROG24{P!-QQRO'#FVOOQP,5;X,5;XO!-VQRO'#EuO!-[QRO'#EuO!-aQRO<<JQOOQP1G1_1G1_O!-iQROG24aO!-nQROG24aP.tQRO'#FXOOQPG24aG24aOOQPAN>wAN>wOOQP,5;i,5;iOOQP7+%Z7+%ZO!-uQTO7+%ZOOQP-E8{-E8{OOQP7+%]7+%]OOQP<<Hs<<HsP0uQRO'#FPO*{QRO1G.mO;lQRO1G.mO!,{QROLD*gO<sQROLD*jOOQPLD*jLD*jO!-|QROLD*jOOQP7+&V7+&VOOQP7+&Y7+&YO*{QRO1G/vO!.RQTO1G/vOOQP1G0^1G0^O#hQRO1G0^O!1yQTO1G0^OOQP1G0`1G0`O!5qQRO1G0`O*{QRO1G0aO#hQRO1G0dO!5vQRO'#EkOOQPLD*gLD*gO!5{QRO,5;aO!6QQRO,5;aOOQPAN?lAN?lO!6VQROAN?lOOQPLD){LD){O!6[QROLD){P>aQRO,5;sOOQP<<Hu<<HuP;lQRO'#E}OOQP7+$X7+$XO*{QRO7+$XOOQP!$'NR!$'NROOQP!$'NU!$'NUO<sQRO!$'NUOOQP7+%b7+%bO*{QRO7+%xOOQP7+%x7+%xO*{QRO7+%zOClQRO7+%{O!6aQRO7+&OOOQP'#FZ'#FZO!6fQRO,5;VO#hQRO'#EYOOQP1G0{1G0{O!6qQRO'#EvO!6vQROG25WOOQP!$'Mg!$'MgOOQP<<Gs<<GsOOQP!)9Cp!)9CpO!6{QTO<<IdOOQP<<If<<IfO!:sQTO<<IgO*{QRO<<IjOOQP-E9X-E9XOOQP1G0q1G0qO;lQRO,5;bO!>kQROLD*rOOQPAN?OAN?OO!>pQROAN?ROClQROAN?UO!>uQRO1G0|O!>zQRO!$'N^O*{QROG24mOOQPG24pG24pOOQP7+&h7+&hOOQP!)9Cx!)9CxOClQROLD*XOOQP!$'Ms!$'Ms",
+  stateData: "!?S~O$TOSPOS$RPQ~OUSOV`OWbO^hO`eOagObfOciOdjOsdOwaOxaOyaOzaO{aO|aO}aO!OaO!QaO!RaO!SaO!TSO!USO!VSO!WSO!XSO!lSO!vWO$_UO$aTO$bRO$eQO~O$RkO~OUSOsdOwaOxaOyaOzaO{aO|aO}aO!OaO!QaO!RaO!SaO!TSO!USO!VSO!WSO!XSO!lSO!vWO$_UO$aTO$bRO$eQO~O$flO~P#hOUnOVsOWsO^sO_sO`sOasObsOcsOdsOesOfsOgsOhsOisOjsOksOlsOmsOnsOosOpsOqsOrsOssOtsOusOvsOwsOxsOysOzsO{sO|sO}sO!OsO!PsO!QsO!RsO!SsO!TsO!UsO!VsO!WnO!XnO!gtO~O$cpO~P%]OUuO~O$_wO$ayO$ezO$hyOh!jXq!jXr!jX!x!jX!y!jX$V!jX$W!jX~O$Y!jX$f!jX$`!jXg!jX$c!jXf!jX$^!jX~P(kOh}Oq}Or}O!x}O!y}O~O$V!hX$W!hX$Y!hX$f!hX$`!hXg!hX$c!hXf!hX$^!hX~P)yO$V!QO$W!QO~OU!TO~OW!UO^!YO`!VOa!XOb!WO~OUSOwaOxaOyaOzaO{aO|aO}aO!OaO!QaO!RaO!SaO!TSO!USO!VSO!WSO!XSO!lSO$_UO$aTO$bRO$eQO~OU![O~OU!]O~OU!^O~O!W!_O~Oi!aO~P#hOi!bO~P#hOP!dO$T!dO$V!QO$W!QO~O$Y!gO$f!iO~O$^!jO~O$Y!kO$c!mO~O$_!nO~O$`!oO~OU!pOa!uOsdOwaOxaOyaOzaO{aO|aO}aO!OaO!QaO!RaO!SaO!TSO!USO!VSO!WSO!XSO!g!vO!lSO!vWO$V!QO$W!QO$_UO$aTO$bRO$eQO~O$`!rO~P.tOUnOVsOWsO^sO_sO`sOasObsOcsOdsOesOfsOgsOhsOisOjsOksOlsOmsOnsOosOpsOqsOrsOssOtsOusOvsOwsOxsOysOzsO{sO|sO}sO!OsO!PsO!QsO!RsO!SsO!TsO!UsO!VsO!WnO!XnO~O$_wO$ayO$ezO$hyOh!jaq!jar!ja!x!ja!y!ja$V!ja$W!ja~O$Y!ja$f!ja$`!jag!ja$c!jaf!ja$^!ja~P3tO$V!ha$W!ha$Y!ha$f!ha$`!hag!ha$c!haf!ha$^!ha~P)yO$X!|O$[!}O~OU#PO~OU#QO~OU#RO~OU#SO~O!W#TO~O$[#VO$^#UO~O$_#XO~O$_#YO~O_#ZO~Oj#]O~Og#_O~O$f#cO~P#hO$Y#dO$f#cO~O$c#hO~P%]O$Y#iO$c#hO~Oh!kXq!kXr!kX!x!kX!y!kX$_!kX$a!kX$e!kX$h!kX$V!kX$W!kX~O$[#lO$Y!kX$`!kX~P7wO$Y#mO$`#oO~O$P#pO~O$_#qO~O$[#lO~O$f#rO~OU#sO~OU#tOwaOxaOyaOzaO{aO|aO}aO!OaO!P#zO!QaO!RaO!SaO!W#vO$V!QO$W!QO$_#xO$b#wO~O$[#}O~O$X!|O$[#}O~O$[$PO$^#UO~O$_$RO~O$_$SO~O_$TO~OU#tOwaOxaOyaOzaO{aO|aO}aO!OaO!P#zO!QaO!RaO!SaO!W#vO$_#xO$b#wO~O#U$XO$V!QO$W!QO~P#hO$[$PO~OU$^O~OU$`O$`$bO~OU$dO~O$_$eO~Og$fO~OU$gO~O$f$iO~P#hO$c$kO~P%]O$`$mO~Oa!uO~P#hOU!pOa!uOsdOwaOxaOyaOzaO{aO|aO}aO!OaO!QaO!RaO!SaO!TSO!USO!VSO!WSO!XSO!g!vO!lSO!vWO$_UO$aTO$bRO$eQO~O$`$pO~P>aO$Y$qO$`$pO~OU$`O$`$tO~O$Y$vO$Z$xO~O$X$yO$a$zO$V!^X$W!^X$d!^X$[!^X$`!^X$Y!^X$Z!^X$c!^X~O$X$yO$V!ZX$W!ZX$d!ZX$[!ZX$`!ZX$Y!ZX$Z!ZX$c!ZX~O$d%RO$V!YX$W!YX$[!YX$`!YX$Y!YX$Z!YX$c!YX~O$_%TO~O$P%UO~O$[%YO~O$[%`O~OU$`O$`%bO~OU%dO~Ot%hOu%iO~P(kO$P%jO~O$^%lO~O$^%mO~O$`%nO~O$^#UO$Y!uX$`!uX~O$Y%pO$`!tX~O$[%rO$^%sO$i%sO~Ov%tO~O$a$zO$V#kX$W#kX~O$`%wO~P>aO$V!QO$W!QO$Y%yO~O$g%|O~O$`%}O~OU&OO$Z&PO~O$Y&QO$Z&PO~OU&TO~O$X$yO$a$zO$V!^a$W!^a$d!^a$[!^a$`!^a$Y!^a$Z!^a$c!^a~O$]&XO$^&WO~O$Y&YO$c&[O~O$`&[O~O$d%RO$V!Ya$W!Ya$[!Ya$`!Ya$Y!Ya$Z!Ya$c!Ya~O!W&_O~O$`&lO~O$[&mO$^&nO$i&nO~O$`&oO~Ot%hOu%iO~P3tO$^&rO~O$^&sO~OU&tOVsOWsO^sO_sO`sOasObsOcsOdsOe&{OfsOgsOhsOisOjsOksOlsOmsOnsOosOpsOqsOrsOs&|OtsOusOvsOw&}Ox&}Oy&}Oz&}O{&}O|&}O}&}O!O&}O!PsO!Q&}O!R&}O!S&}O!T'OO!U'OO!V'OO!W&tO!X&tO!gtO!lSO!vWO!{&vO#O'PO#R'QO$_UO$aTO$bRO$eQO~O$^'TO~OU$`O$`!ta~O$Y'VO$`!ta~O$Y']O~O$a$zO$V#ka$W#ka~O$V!QO$W!QO$Y'`O~O$Q'cO~O$g'eO~OU&OO$Z'fO~O$Y'hO$Z'jO~O$^'lO~O$c'nO~P0uO$Y'oO$c'nO~O$`'nO~O$]'rO$^'qO~O$Q'tO$W'tO~P0uO$^'wO~O$['zO$^'{O$i'{O~O$^[X~P7wO$^(OO~OU&tOVsOWsO^sO_sO`sOasObsOcsOdsOfsOgsOhsOisOjsOksOlsOmsOnsOosOpsOqsOrsOs&|OtsOusOvsOw&}Ox&}Oy&}Oz&}O{&}O|&}O}&}O!O&}O!PsO!Q&}O!R&}O!S&}O!T'OO!U'OO!V'OO!W&tO!X&tO!gtO!lSO!vWO$_UO$aTO$bRO$eQO~OesO$V!QO$W!QO~P! lO$Q(UO$W(UO~PHvO$^]X~P#hO$^]X~P+kOh![Xq![Xr![X!x![X!y![X$V![X$W![X$^]X$_![X$a![X$e![X$h![X~O$^]X~P7wOU(XO~OU$`O$`!ti~O$['zO~Ok(^Ol(_O~P;lO$Q(bO~P>aO$Q(bO~O$`(eO~OU&OO~O$Z(hO~P;lO$Y(iO$Z(hO~O$c(lO~P0uO$^(oO~O$[(qO~O$P%jOU!zaV!zaW!za^!za_!za`!zaa!zab!zac!zad!zae!zaf!zag!zah!zai!zaj!zak!zal!zam!zan!zao!zap!zaq!zar!zas!zat!zau!zav!zaw!zax!zay!zaz!za{!za|!za}!za!O!za!P!za!Q!za!R!za!S!za!T!za!U!za!V!za!W!za!X!za!g!za!l!za!v!za!{!za#O!za#R!za$Q!za$W!za$_!za$a!za$b!za$e!za~O$^(yO~Of(|O$V!QO$W!QO~O$^(}O~Oh)OO~O$P)PO~OU$`O~O$[)RO~O$[)SO~O$Y)UO$`)TO~O$`)VO~O$Q)WO~P>aO$Z)YO~P;lO$[)`O~O$P%jOU!diV!diW!di^!di_!di`!dia!dib!dic!did!die!dif!dig!dih!dii!dij!dik!dil!dim!din!dio!dip!diq!dir!dis!dit!diu!div!diw!dix!diy!diz!di{!di|!di}!di!O!di!P!di!Q!di!R!di!S!di!T!di!U!di!V!di!W!di!X!di!g!di!l!di!v!di!{!di#O!di#R!di$Q!di$W!di$_!di$a!di$b!di$e!di~O$P%jOU!ziV!ziW!zi^!zi_!zi`!zia!zib!zic!zid!zie!zif!zig!zih!zii!zij!zik!zil!zim!zin!zio!zip!ziq!zir!zis!zit!ziu!ziv!ziw!zix!ziy!ziz!zi{!zi|!zi}!zi!O!zi!P!zi!Q!zi!R!zi!S!zi!T!zi!U!zi!V!zi!W!zi!X!zi!g!zi!l!zi!v!zi!{!zi#O!zi#R!zi$Q!zi$W!zi$_!zi$a!zi$b!zi$e!zi~O!W)dO~Oe)iO~Oa!uO~Om)kO~On)lO~O$`)mO~O$^)sO~Oe)iO$Q)uO$W)uO~O$_)vO~O$[)wO~O$P%jOU!zyV!zyW!zy^!zy_!zy`!zya!zyb!zyc!zyd!zye!zyf!zyg!zyh!zyi!zyj!zyk!zyl!zym!zyn!zyo!zyp!zyq!zyr!zys!zyt!zyu!zyv!zyw!zyx!zyy!zyz!zy{!zy|!zy}!zy!O!zy!P!zy!Q!zy!R!zy!S!zy!T!zy!U!zy!V!zy!W!zy!X!zy!g!zy!l!zy!v!zy!{!zy#O!zy#R!zy$Q!zy$W!zy$_!zy$a!zy$b!zy$e!zy~O#P)yOU!}yV!}yW!}y^!}y_!}y`!}ya!}yb!}yc!}yd!}ye!}yf!}yg!}yh!}yi!}yj!}yk!}yl!}ym!}yn!}yo!}yp!}yq!}yr!}ys!}yt!}yu!}yv!}yw!}yx!}yy!}yz!}y{!}y|!}y}!}y!O!}y!P!}y!Q!}y!R!}y!S!}y!T!}y!U!}y!V!}y!W!}y!X!}y!g!}y!l!}y!v!}y!{!}y#O!}y#R!}y$Q!}y$W!}y$_!}y$a!}y$b!}y$e!}y~O!X)|O~O$^)}O~O$`*PO~O$`*QO~O!v!y~",
+  goto: ":j$VPPP$W$[$`PPP$d$j$s$w%_PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP%o&v'`(y)S)j$[)r){*w*{+P+^P+g-i.l/qP0v0v1y2R2X2_2t3X3bP3lPP*{P3p*{PP*{P$[3xP$[4R4[$[4b4k$[4q4w$W4}5^5b5b5b5b5b5f5i5l5o5b5u5{6R6X6_6e6o6u6{7R7X7_7i7o7u7{8RPPPPPP8XT]O_TYO_TcO_Q#O!TR$O#PQ%V#{Q&c%WR'u&dT&a%U&b^rR!k#i$l%j&v&zQ!wyW%O#w&Y'o(mT&`%U&bmnRy!k#i#w$l%U%j&Y&b&v&z'o(mQ#|!}Q$U#UQ%Q#xQ%X#}Q&S$yQ&e%YQ'S%mQ'[%sQ'k&WQ'y&nQ(`']U(g'h(i)ZQ(k'lQ(n'qQ(s'{Q)](oR){)vv#y!}#U#x#}$y%Y%m%s&W&n']'h'l'q'{(i(o)Z)vR&]%R#QSOQU_dijwz!O!a!g!j!n#V#d#l#m#p$P$j$q%`%j%r%x%y%|&m&v&z&{&|'P'_'`'e'z(O(c(d(q(y)O)X)`)iy#u!}#U#x#}$y%R%Y%m%s&W&n']'h'l'q'{(i(o)Z)vQ$|#tQ$}#uR&V${y#v!}#U#x#}$y%R%Y%m%s&W&n']'h'l'q'{(i(o)Z)vQ%P#wV'm&Y'o(mQ#W![Q$Q#QR%o$`Q%k$WQ&f%ZQ'v&gQ(Y'RQ(]'YQ(t'|Q(u'}Q(x(PQ)a(wQ)c(zQ)r)eQ)x)pQ*O)zR*S*RT&y%j&zT&w%j&zWoR!k#i$lS&u%j&zR(Q&v_rR!k#i$l%j&v&zSZO_QmQQvUQ!`iQ!cjf!qw#m#p$q%x%y'_'`(c(d)XQ!xzQ#[!aU#b!g#d$jQ#f!jQ#k!nQ$]#VQ$n#lQ%_$PQ&k%`S&x%j&zY'X%r&m'z(q)`Q'd%|Q(R&vS(V&{)iQ(W'PQ(f'eQ(v(OQ)b(yR)f)O!zXOQU_ijwz!a!g!j!n#V#d#l#m#p$P$j$q%`%j%r%x%y%|&m&v&z&{'P'_'`'e'z(O(c(d(q(y)O)X)`)iR!z!O!|WOQU_ijwz!O!a!g!j!n#V#d#l#m#p$P$j$q%`%j%r%x%y%|&m&v&z&{'P'_'`'e'z(O(c(d(q(y)O)X)`)iT!Zd&|!zVOQU_dijwz!O!a!g!j!n#d#l#m#p$j$q%j%r%x%y%|&m&v&z&{&|'P'_'`'e'z(O(c(d(q(y)O)X)`)iV$V#V$P%`#RSOQU_dijwz!O!a!g!j!n#V#d#l#m#p$P$j$q%`%j%r%x%y%|&m&v&z&{&|'P'_'`'e'z(O(c(d(q(y)O)X)`)iQqRV#g!k#i$lX{V|$V%eXxV|$V%eQ!swU$o#m$q%xQ$s#pU'^%y'`(dV(a'_(c)Xf!qw#m#p$q%x%y'_'`(c(d)XQ$n#lR)j)RQ$c#YQ$u#qR%c$SU$a#Y#q$SV'U%p'V([T!OX!PS&w%j&zT)g)P)hQ$Y#VQ%[$PR&h%`Q$Z#VQ%]$PR&i%`Q%f$VR&p%eQ$[#VQ%^$PR&j%`Q%g$VR&q%eQ$_#XR%a$RQ)Q(ZR)^(pQ'Z%rQ'x&mQ(r'zQ)_(qR)o)`T^O_T[O_R#^!bR(`']R)j)SQ$h#_R%u$fQ!ekR#`!eQ_OR!S_Q$w#sR&R$wQ&b%UR's&bQ'i&SR(j'iQ${#tQ%v$gT&U${%vQ&Z%PR'p&ZQ%S#yR&^%SQ&z%jR(T&zQ!hmR#e!hQ!lqR#j!lQ|VS!y|%eR%e$VQ%q$aR'W%qQ#n!sR$r#nQ%z$sR'a%zQ!PXR!{!PQ)h)PR)t)hQ!R^Q!fkQ!twQ#a!eQ#{!}Q$W#VQ%W#}Q%Z$PQ%{$sQ&d%YQ&g%`Q'R%lY'Y%r&m'z(q)`Q'_%yQ'b%zQ'|&rQ'}&sQ(P&vQ(S&xQ(Z'TQ(]'XQ(c'`Q(p'wQ(w(OQ(z(RQ({(VQ)X(dQ)[(nQ)a(vQ)e(}Q)n)]Q)p)bQ)q)dQ)z)sR*R)}",
+  nodeNames: "⚠ Comment MCL BlockStatement TypeRecordDeclaration Export Identifier export type TypeParameterList TypeRecordBlock TypeField MapKey MapKeyword import as let fn rule emit validate require message using in each descendants where select bySchema minMatches requireEach requireDescendants and or not with without output Any Null Bool Int Decimal String List Map schema Function Node Schema true false null QuotedString Number TypeExpression TypeAtom PrimitiveType TypeArguments TypeReference TypeFieldInline LetBlockDeclaration TypeAnnotation Block BlockLine MapEntry MapEntryKey DynamicMapKey key Expression UnaryExpression PostfixExpression PrimaryExpression MultiString ListExpression InlineMap InlineMapEntry Postfix CallArguments CallArgument LambdaExpression ParameterList Parameter NegativeNumber BinaryOperator Operator Minus SequenceItem ListMarker RequireStatement IfExpression if else ForExpression for LetNodeDeclaration NodeExpression node LetOverlayDeclaration OverlayExpression Overlay LetRemovalDeclaration RemovalExpression Removal RuleDeclaration TypedParameter RuleBlock FunctionDeclaration FunctionBody Statement ImportDeclaration TypeDeclaration LetDeclaration EmitStatement ValidateStatement DescendantsQuery NamedQuerySelector BySchemaSelector RuleReference ExpressionStatement",
+  maxTerm: 163,
+  context: trackIndent,
+  skippedNodes: [0,1,121],
+  repeatNodeCount: 17,
+  tokenData: ".u~RoXY#SYZ#_]^#dpq#Sqr#lrs#wst'|uv#rxy(hyz(mz{#r{|#r|}(r}!O(w!O!P*}!P!Q#r!Q![+S![!],e!^!_,j!_!`,t!`!a-W!a!b-b!c!}-r!}#O.T#P#Q.Y#R#S-r#T#o-r#o#p._#p#q.d#q#r.k~~.p~#XQ$T~XY#Spq#S~#dO$V~~#iP$V~YZ#_P#oP!_!`#rP#wO!xP~#zXOY$gZ]$g^r$grs&as#O$g#O#P%[#P;'S$g;'S;=`&Z<%lO$g~$jXOY$gZ]$g^r$grs%Vs#O$g#O#P%[#P;'S$g;'S;=`&Z<%lO$g~%[O!W~~%_RO;'S$g;'S;=`%h;=`O$g~%kYOY$gZ]$g^r$grs%Vs#O$g#O#P%[#P;'S$g;'S;=`&Z;=`<%l$g<%lO$g~&^P;=`<%l$g~&fP!W~rs&i~&lTOr&irs&{s;'S&i;'S;=`'v<%lO&i~'OTOr&irs'_s;'S&i;'S;=`'v<%lO&i~'bTOr&irs'qs;'S&i;'S;=`'v<%lO&i~'vO!l~~'yP;=`<%l&i~(RTP~OY'|Z]'|^;'S'|;'S;=`(b<%lO'|~(eP;=`<%l'|~(mO$_~~(rO$`~~(wO$Y~~(|S!yPXY)Ypq)Y!Q![)e!`!a*vQ)_Q!{QXY)Ypq)Y~)jS!v~!O!P)v!Q![)e!g!h*[#X#Y*[~)yP!Q![)|~*RR!v~!Q![)|!g!h*[#X#Y*[~*_R{|*h}!O*h!Q![*n~*kP!Q![*n~*sP!v~!Q![*nR*}O$iQ!xP~+SO$a~~+XS!X~!O!P+e!Q![+S!g!h+y#X#Y+y~+hP!Q![+k~+pR!X~!Q![+k!g!h+y#X#Y+y~+|R{|,V}!O,V!Q![,]~,YP!Q![,]~,bP!X~!Q![,]~,jO$^~R,qP$XQ!xP!_!`#rV,yQ$[R!_!`#r!`!a-PT-WO$gS!xPR-_P$ZQ!xP!_!`#rR-gQ$]Q!O!P-m!a!b#rP-rO$hP~-wSU~!Q![-r!c!}-r#R#S-r#T#o-r~.YO$e~~._O$f~~.dO$b~R.kO$dQ!xP~.pO$c~~.uO$W~",
+  tokenizers: [indentation, 0, 1, 2],
+  topRules: {"MCL":[0,2]},
+  specialized: [{term: 6, get: (value) => spec_Identifier[value] || -1}],
+  tokenPrec: 3497
+})

package/src/parser.terms.js

@@ -0,0 +1,125 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+export const
+  indent = 139,
+  dedent = 140,
+  blankLineStart = 141,
+  Comment = 1,
+  MCL = 2,
+  BlockStatement = 3,
+  TypeRecordDeclaration = 4,
+  Export = 5,
+  Identifier = 6,
+  _export = 7,
+  type = 8,
+  TypeParameterList = 9,
+  TypeRecordBlock = 10,
+  TypeField = 11,
+  MapKey = 12,
+  MapKeyword = 13,
+  _import = 14,
+  as = 15,
+  _let = 16,
+  fn = 17,
+  rule = 18,
+  emit = 19,
+  validate = 20,
+  _require = 21,
+  message = 22,
+  using = 23,
+  _in = 24,
+  each = 25,
+  descendants = 26,
+  where = 27,
+  select = 28,
+  bySchema = 29,
+  minMatches = 30,
+  requireEach = 31,
+  requireDescendants = 32,
+  and = 33,
+  or = 34,
+  not = 35,
+  _with = 36,
+  without = 37,
+  output = 38,
+  Any = 39,
+  Null = 40,
+  Bool = 41,
+  Int = 42,
+  Decimal = 43,
+  String = 44,
+  List = 45,
+  Map = 46,
+  schema = 47,
+  Function = 48,
+  Node = 49,
+  Schema = 50,
+  _true = 51,
+  _false = 52,
+  _null = 53,
+  QuotedString = 54,
+  Number = 55,
+  TypeExpression = 56,
+  TypeAtom = 57,
+  PrimitiveType = 58,
+  TypeArguments = 59,
+  TypeReference = 60,
+  TypeFieldInline = 61,
+  LetBlockDeclaration = 62,
+  TypeAnnotation = 63,
+  Block = 64,
+  BlockLine = 65,
+  MapEntry = 66,
+  MapEntryKey = 67,
+  DynamicMapKey = 68,
+  key = 69,
+  Expression = 70,
+  UnaryExpression = 71,
+  PostfixExpression = 72,
+  PrimaryExpression = 73,
+  MultiString = 74,
+  ListExpression = 75,
+  InlineMap = 76,
+  InlineMapEntry = 77,
+  Postfix = 78,
+  CallArguments = 79,
+  CallArgument = 80,
+  LambdaExpression = 81,
+  ParameterList = 82,
+  Parameter = 83,
+  NegativeNumber = 84,
+  BinaryOperator = 85,
+  Operator = 86,
+  Minus = 87,
+  SequenceItem = 88,
+  ListMarker = 89,
+  RequireStatement = 90,
+  IfExpression = 91,
+  _if = 92,
+  _else = 93,
+  ForExpression = 94,
+  _for = 95,
+  LetNodeDeclaration = 96,
+  NodeExpression = 97,
+  node = 98,
+  LetOverlayDeclaration = 99,
+  OverlayExpression = 100,
+  Overlay = 101,
+  LetRemovalDeclaration = 102,
+  RemovalExpression = 103,
+  Removal = 104,
+  RuleDeclaration = 105,
+  TypedParameter = 106,
+  RuleBlock = 107,
+  FunctionDeclaration = 108,
+  FunctionBody = 109,
+  Statement = 110,
+  ImportDeclaration = 111,
+  TypeDeclaration = 112,
+  LetDeclaration = 113,
+  EmitStatement = 114,
+  ValidateStatement = 115,
+  DescendantsQuery = 116,
+  NamedQuerySelector = 117,
+  BySchemaSelector = 118,
+  RuleReference = 119,
+  ExpressionStatement = 120