@gdquest/gd-exercise/dist/dist-UWS6CGEQ.mjs.map

Core package that handles logic for the GDExercise project.

{
  "version": 3,
  "sources": ["../../codemirror-gdscript/src/index.mts", "../../lezer-gdscript/src/parser.js", "../../lezer-gdscript/src/tokens.js", "../../lezer-gdscript/src/parser.terms.js", "../../lezer-gdscript/src/highlight.js", "../../../node_modules/.pnpm/@lezer+common@1.0.3/node_modules/@lezer/common/dist/index.js", "../../codemirror-gdscript/src/complete.mts", "../../../node_modules/.pnpm/@lezer+common@1.0.3/node_modules/@lezer/common/dist/index.js", "../../../node_modules/.pnpm/@lezer+lr@1.3.9/node_modules/@lezer/lr/dist/index.js", "../../../node_modules/.pnpm/@lezer+highlight@1.1.6/node_modules/@lezer/highlight/dist/index.js", "../../../node_modules/.pnpm/@codemirror+autocomplete@6.8.1_@codemirror+language@6.9.0_@codemirror+state@6.2.1_@codemirror_xdyrjbo3jiz3uawtkjryt6trui/node_modules/@codemirror/autocomplete/dist/index.js"],
  "sourcesContent": ["import {\n  foldNodeProp,\n  foldInside,\n  indentNodeProp,\n  LRLanguage,\n  LanguageSupport,\n  type TreeIndentContext,\n} from \"@codemirror/language\";\n\nimport { parser } from \"@gdquest/lezer-gdscript\";\n\nimport { globalCompletion, localCompletionSource } from \"./complete.mts\";\nimport { type SyntaxNode } from \"@lezer/common\";\nexport { globalCompletion, localCompletionSource };\n\nfunction indentBody(\n  context: TreeIndentContext,\n  node: SyntaxNode\n): number | null {\n  const base = context.baseIndentFor(node);\n  const line = context.lineAt(context.pos, -1);\n  const to = line.from + line.text.length;\n  // Don't consider blank, deindented lines at the end of the\n  // block part of the block\n  if (\n    /^\\s*($|#)/.test(line.text) &&\n    context.node.to < to + 100 &&\n    !/\\S/.test(context.state.sliceDoc(to, context.node.to)) &&\n    context.lineIndent(context.pos, -1) <= base\n  ) {\n    return null;\n  }\n  // A normally deindenting keyword that appears at a higher\n  // indentation than the block should probably be handled by the next\n  // level\n  if (\n    /^\\s*(else:|elif)/.test(context.textAfter) &&\n    context.lineIndent(context.pos, -1) > base\n  ) {\n    return null;\n  }\n  return base + context.unit;\n}\n\nexport const gdscriptLanguage = LRLanguage.define({\n  name: \"gdscript\",\n  parser: parser.configure({\n    props: [\n      indentNodeProp.add({\n        Body: (context) => {\n          return indentBody(context, context.node) ?? context.continue();\n        },\n        IfNode: (context) => {\n          return /^\\s*(else:|elif )/.test(context.textAfter)\n            ? context.baseIndent\n            : context.continue();\n        },\n        SuiteNode: (context) => {\n          return indentBody(context, context.node) ?? context.continue();\n        },\n        String: () => {\n          return null;\n        },\n        Script: (context) => {\n          if (\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            context.pos + /\\s*/.exec(context.textAfter)![0].length >=\n            context.node.to\n          ) {\n            let endBody = null;\n            for (let cur: SyntaxNode | null = context.node, to = cur.to; ; ) {\n              cur = cur.lastChild;\n              if (cur == null || cur.to !== to) break;\n              if (cur.type.name === \"Body\") endBody = cur;\n            }\n            if (endBody != null) {\n              const bodyIndent = indentBody(context, endBody);\n              if (bodyIndent != null) return bodyIndent;\n            }\n          }\n          return context.continue();\n        },\n      }),\n      foldNodeProp.add({\n        \"ArrayExpressionNode DictionaryExpressionNode\": foldInside,\n        Body: (node, state) => ({\n          from: node.from + 1,\n          to: node.to - (node.to === state.doc.length ? 0 : 1),\n        }),\n      }),\n    ],\n  }),\n  languageData: {\n    closeBrackets: {\n      brackets: [\"(\", \"[\", \"{\", \"'\", '\"', \"'''\", '\"\"\"'],\n    },\n    commentTokens: { line: \"#\" },\n    // eslint-disable-next-line no-useless-escape\n    indentOnInput: /^\\s*([\\}\\]\\)]|else:|elif )$/,\n  },\n});\n\nexport function gdscript(): LanguageSupport {\n  return new LanguageSupport(gdscriptLanguage, [\n    gdscriptLanguage.data.of({ autocomplete: localCompletionSource }),\n    gdscriptLanguage.data.of({ autocomplete: globalCompletion }),\n  ]);\n}\n", "// This file was generated by lezer-generator. You probably shouldn't edit it.\nimport {LRParser} from \"@lezer/lr\"\nimport {indentation, newlines, trackIndent} from \"./tokens.js\"\nimport {gdscriptHighlighting} from \"./highlight\"\nconst spec_Identifier = {__proto__:null,PI:34, TAU:36, INF:38, NaN:40, assert:48, var:70, const:80, await:86, in:116, as:122, func:138, preload:162, is:176, class_name:186, extends:190, signal:194, pass:198, return:202, class:214, if:222, elif:226, else:230, for:234, match:238, while:254}\nexport const parser = LRParser.deserialize({\n  version: 14,\n  states: \"KtQ`QUOOP#rOQOOOOQQ'#Cq'#CqOOQQ'#Ch'#ChO#wQUO'#CbO#|QUO'#CaO&OQYO'#CyO&iQUO'#CzO&nQUO'#CxO(jQYO'#FmO*bQUO'#CwO*iQYO'#FmO*vQUO'#DOOOQQ'#Fq'#FqO,cQYO'#C`O,^QUO'#C}O,pQUO'#DmO(qQUO'#DpOOQQ'#EQ'#EQO(qQUO'#EYOOQQ'#Fm'#FmOOQQ'#C`'#C`O.aQUO'#C_OOQR'#C_'#C_O.lQVO'#EmOOQR'#Ei'#EiOOQR'#Fg'#FgOOQR'#FQ'#FQQ`QUOOOOQQ'#Cl'#ClO1bQUO'#DOO1gQUO'#DTO(qQUO'#DWO1lQUO'#ElO1qQUO'#EOO1qQUO'#CsO1vQUO'#E[O1{QUO'#E^O2QQUO'#E`OOQQ'#Eb'#EbO(qQUO'#EdO2VQUO'#EjO,pQUO'#EnO2[QUO'#EtO2aQUO'#EvO,pQUO'#FOP2fOUO'#FfPOOO)CAY)CAYO2qQUO,58|O3`QUO'#DQOOQQ,59q,59qO(qQUO,59iOOQQ,5:T,5:TO3eQUO'#CuO3lQYO,59fO5iQUO'#FTO5nQYO,59dOOQQ,59c,59cO7qQUO,59cOOQQ'#FU'#FUO7vQUO'#DOO8RQYO'#FlO8`QUO'#DrO8eQUO,59cO,pQUO,5:XOOQQ-E9S-E9SO8lQUO,59jO8qQUO,59oO8vQUO,5;UO8{QUO,5;WO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,59tO(qQUO,5:nO(qQUO,59tO9QQUO,59tO3`QUO,5:UO9VQUO,5:qO:cQYO'#DoO:mQUO'#FsO:uQUO,5:XO:zQYO,5:[OOQQ,5:t,5:tOOQR'#Dy'#DyOOQR'#Ef'#EfO;RQUO'#FYO.aQUO,5;ROOQR,58y,58yOOQR'#FZ'#FZO;rQVO,5;XOOQR,5;X,5;XO,pQUO'#EpO>hQUO'#ErOOQR-E9O-E9OO>mQUO,59jO>uQUO,59oOOQQ,59r,59rO8`QUO,5;WOOQQ,5:j,5:jOOQQ,59_,59_OOQQ,5:v,5:vOOQQ,5:x,5:xO>}QUO,5:zO?]QYO,5;OO?jQUO,5;UO?rQYO,5;YO?|QUO,5;`O@RQUO,5;bO?rQYO,5;jPOOO,5<Q,5<QP@WOQO,5<QP@]OUO,5<QOAVQUO'#CgOOQQ1G.h1G.hOOQQ'#DS'#DSOOQQ,59l,59lOBeQYO1G/TOOQQ,59a,59aOCUQUO,59aOCZQUO'#FSOC`QYO1G/QOOQQ'#Cy'#CyOOQQ,5;o,5;oOOQQ-E9R-E9ROOQQ1G.}1G.}OE]QUO,5<WOEgQUO,5<WOErQUO'#DtOEzQbO'#FtOFSQUO,5:^OFXQUO1G.}OF^QUO1G/sOFcQUO1G/UOFkQUO1G/ZO?jQUO1G0pO8`QUO1G0rOOQQ1G/`1G/`OHdQYO1G/`OHkQYO1G/`OJcQYO1G/`OLZQYO1G/`OLbQYO1G/`ONYQYO1G/`ONaQYO1G/`O!!UQYO1G/`O!!`QYO1G/`O!!jQYO1G0YO!#iQYO1G/`O(qQUO1G/`OOQQ1G/p1G/pOOQQ'#EX'#EXOOQQ1G0]1G0]O,pQUO,59iO(qQUO,5:ZO!$iQUO,5<_O!$pQUO,5<_OOQQ1G/s1G/sOOQQ1G/v1G/vOOQQ,5;t,5;tOOQQ-E9W-E9WOOQR1G0m1G0mOOQR-E9X-E9XOOQR1G0s1G0sO?rQYO,5;[O!$xQUO'#DwOOQR,5;^,5;^OOQQ1G/U1G/UOOQQ1G/Z1G/ZO>hQUO1G0rOOQQ1G0f1G0fOOQR1G0p1G0pO>hQUO1G0pOOQR1G0t1G0tO,pQUO1G0zO!%PQUO1G0|OOQR1G1U1G1UPOOO1G1l1G1lP!%UOQO1G1lO!%ZQUO'#FhOOQQ,59R,59RO!%cQUO,59ROOQQ1G.{1G.{OOQQ,5;n,5;nOOQQ-E9Q-E9QO!%hQYO,5;sO!%uQUO1G1rOOQQ-E9V-E9VO!&PQUO'#DVO!&_QUO'#FuO!&jQUO'#FuOOQQ,5:`,5:`O!&rQUO,5:`O3`QUO'#DvOOQQ,5<`,5<`OOQQ1G/x1G/xOOQQ7+$i7+$iOOQQ7+%_7+%_OOQQ7+$p7+$pOOQQ7+$u7+$uOOQR7+&[7+&[O>hQUO7+&[O>hQUO7+&^O(qQUO7+%tO!'oQYO7+$zO!(oQYO1G/TO!)PQYO1G/uOOQQ,5;q,5;qO!)ZQUO1G1yOOQQ-E9T-E9TOOQR1G0v1G0vO!)bQVO'#DxOOQR'#D}'#D}OOQR,5:c,5:cOOQR7+&^7+&^O?rQYO7+&fO!)bQVO7+&hPOOO7+'W7+'WO!)gQUO,5<SO!)nQUO,5<SOOQQ1G.m1G.mP(qQUO'#FXO(qQUO,5:aO!)vQUO,5<aO!*OQUO,5<aOOQQ1G/z1G/zOOQQ,5:b,5:bO!*WQYO'#EmOOQR<<Iv<<IvOOQR<<Ix<<IxO!-XQYO<<I`P,pQUO'#FVOOQQ'#D{'#D{O`QUO'#DzOOQR,5:d,5:dOOQR<<JQ<<JQO!-{QUO<<JSOOQQ,5;m,5;mO!.YQUO1G1nOOQQ-E9P-E9PO!.aQYO1G/{O!.kQUO,5;rOOQQ,5;r,5;rO!.vQUO1G1{OOQQ-E9U-E9UO!/OQYO,5;XO!0{QVO,5:fOOQQ'#E{'#E{OOQQ'#E|'#E|OOQQ'#E}'#E}OOQQ'#Ey'#EyO>hQUO'#ExOOQR'#F['#F[O!1VQVOAN?nO!1jQUO'#EzP@eQUO'#FRP!1oQUO'#FWOOQR'#D|'#D|OOQR1G0Q1G0QOOQR,5;d,5;dOOQR-E9Y-E9YOOQRG25YG25YOOQQ,5;f,5;fO!1tQYO'#CyO,pQUO'#EYO,pQUO'#DWO,pQUO,59iO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO,pQUO,59tO!2OQYO1G/TO!2`QYO1G/`O!3PQYO1G/`O!3pQYO1G/`O!4aQYO1G/`O!5QQYO1G/`O!5qQYO1G/`O!6bQYO1G/`O!8`QYO1G/`O!8jQYO1G/`O!8tQYO1G/`O,pQUO1G/`O!9eQUO'#DwOFSQUO1G0rOFSQUO1G0pOFSQUO7+&[OFSQUO7+&^O,pQUO7+%tO!;^QYO7+$zO!;}QYO7+&fO!=]QYO<<I`O!=pQUO'#C}O!=uQUO,59tOFSQUO'#ErO8`QUO,5;WO!=zQUO,5;UO!;}QYO,5;YO!;}QYO,5;jO!=zQUO1G0pO8`QUO1G0rO!>SQYO1G0YO!;}QYO,5;[O,pQUO1G0zO!>ZQUO'#ElO!>`QUO'#EjO,pQUO'#EnO,pQUO'#FOO!>eQUO,5;UO!>jQUO,5;WO(qQUO,5:nO,pQUO'#EpO!>oQUO,5;`O!>tQUO'#DOO!?VQUO'#Et\",\n  stateData: \"!?s~OPOS$XOS$UOS$TPQ~OVSOWUOYaO]RO^RO_ROamObmOcmOdmOhsOpYOsnOxoO{pO!ZcO!b`O!gqO!srO!ubO!}cO#PtO#RuO#TvO#VwO#XxO#_yO#czO#i{O#k|O#s}O$]RO$^RO$_QO$bVO$cVO~O$T!OO~OW!QO~OV#xXs#xXx#xX!g#xX#[TX#_#xX$STX$VTX~OY!VOu!ROomX}!eX!O!eX!P!eX!Q!eX!R!eX!S!eX!T!eX!U!eX!V!eX!W!eX!X!eX!Y!eX!Z!eX![!eX!_!eX!w!eX!z!eXf!eX!`!eX~O$f!TO#[!eX$S!eX$V!eXj!eXX!eX!x!eX~P$hOW!WO~Oo!XO~O}$aX!O$aX!P$aX!Q$aX!R$aX!S$aX!T$aX!U$aX!V$aX!W$aX!X$aX!Y$aX!Z$aX![$aX!_$aX!w$aX!z$aX#[$aX$S$aX$V$aX$f$aXf$aXj$aXu$aXX$aX!x$aX!`$aX~Oo!XO~P&sOVSOWUOYaO]RO^RO_ROamObmOcmOdmOpYOsnOxoO{pO!ZcO!b`O!g!`O!srO!ubO!}cO$]RO$^RO$_QO$bVO$cVO~Oj!ZO~P(qOY!VOp!aO!b!bO~P&sOVSOs!dOx!eO!g!gO#_!fO~O}!hO!O!iO!P!jO!Q!kO!R!lO!S!mO!T!nO!U!oO!V!pO!W!pO!X!qO!Y!qO!Z!tO![!sO!_!uO!w!rO!z!vO$f!TO~O#[SX$SSX$VSX~P+XOVSOW&wOYaO]RO^RO_ROamObmOcmOdmOpYOsnOxoO{&yO!Z&xO!b`O!g!`O!srO!ubO!}&xO$]RO$^RO$_QO$bVO$cVO~O#[#OO$S!|O$V!}O~O#e#UO#g#VOV#aXW#aXY#aX]#aX^#aX_#aXa#aXb#aXc#aXd#aXh#aXp#aXs#aXx#aX{#aX!Z#aX!b#aX!g#aX!s#aX!u#aX!}#aX#P#aX#R#aX#T#aX#V#aX#X#aX#_#aX#c#aX#i#aX#k#aX#s#aX$P#aX$]#aX$^#aX$_#aX$b#aX$c#aX$R#aX$V#aX$k#aX~OW#XO~OW#YO~OW#[O~OY!VO~OW#_O~OW#`O~OW#aO~OW#cO~OW#eO~OW#fO~OP#iO$S#hO$X#jO~OY#kOVUasUaxUa!gUa#[Ua#_Ua$SUa$VUa~OW#mO~OX#pO~P(qO$d#rOona}na!Ona!Pna!Qna!Rna!Sna!Tna!Una!Vna!Wna!Xna!Yna!Zna![na!_na!wna!zna#[na$Sna$Vna$fnafnajnaunaXna!xna!`na~OW#tO~Oo!XOYlapla}la!Ola!Pla!Qla!Rla!Sla!Tla!Ula!Vla!Wla!Xla!Yla!Zla![la!_la!bla!wla!zla#[la$Sla$Vla$flaflajlaulaXla!xla!`la~Oj#wO~OVSOs!dOx!eO~Of#xOj$`XX$`X~P+XOY#zO~Oj#wO~P(qOW$PO~OW$QO~OW$RO~OW$SO~O![$aO~OW$cO~O}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SO!V'TO!W'TO!X'UO!Y'UO!Z'nO!['VO!_!uO!w(PO!z!vO~Ou$fO$f$eO~P9[Of$gO!`$gX~O!`$iO~OX$jO~P+XOhsO#PtO#RuO#TvO#VwO#XxO#[#|X$S#|X$V#|X~P(qO#e#UO#g#VOV#aaW#aaY#aa]#aa^#aa_#aaa#aab#aac#aad#aah#aap#aas#aax#aa{#aa!Z#aa!b#aa!g#aa!s#aa!u#aa!}#aa#P#aa#R#aa#T#aa#V#aa#X#aa#_#aa#c#aa#i#aa#k#aa#s#aa$P#aa$]#aa$^#aa$_#aa$b#aa$c#aa$R#aa$V#aa$k#aa~Ou$qO~Ou!RO$fra~Ou!RO$fwa~OY!VO#[#Sa$S#Sa$V#Sa~O#[#Wa$S#Wa$V#Wa~P+XOu$qO#RuO~Ou$qO$f&zO~P9[O![$zO~Ou${O~O$S$}O~OP%OO$S$}O~O]RO^RO_ROamObmOcmOdmO$]RO$^RO$_QO~OX%QO~P@eO}!hO!O!iO!P!jO!Q!kO!R!lO!S!mO!T!nO!U!oO!V!pO!W!pO!X!qO!Y!qO!Z!tO![!sO!_!uO!w!rO!z!vO~O#[qi$Sqi$Vqi$fqifqijqiXqi!xqi!`qi~PA^OX%SO~OW%TO~O$d#rOoni}ni!Oni!Pni!Qni!Rni!Sni!Tni!Uni!Vni!Wni!Xni!Yni!Zni![ni!_ni!wni!zni#[ni$Sni$Vni$fnifnijniuniXni!xni!`ni~Oj$`aX$`a~P(qOf%WOj$`aX$`a~OW%YOX%]O~O$j%_Ou$hX~Ou'dO~Oj%bO~O!`%cO~Ou!RO$fri~Ou!RO$fwi~O}!hO!P|i!Q|i!R|i!S|i!T|i!U|i!V|i!W|i!X|i!Y|i!Z|i![|i!_|i!w|i!z|i#[|i$S|i$V|i$f|if|ij|iX|i!x|i!`|i~O!O|i~PFsO!O!iO~PFsO}!hO!O!iO!P!jO!R|i!S|i!T|i!U|i!V|i!W|i!X|i!Y|i!Z|i![|i!_|i!w|i!z|i#[|i$S|i$V|i$f|if|ij|iX|i!x|i!`|i~O!Q|i~PHrO}!hO!O!iO!P!jO!Q!kO!T!nO!U!oO!R|i!V|i!W|i!X|i!Y|i!Z|i![|i!_|i!w|i!z|i#[|i$S|i$V|i$f|if|ij|iX|i!x|i!`|i~O!S!mO~PJjO!S|i~PJjO}!hO!O!iO!P!jO!Q!kO!R|i!S|i!T|i!V|i!W|i!X|i!Y|i!Z|i![|i!_|i!w|i!z|i#[|i$S|i$V|i$f|if|ij|iX|i!x|i!`|i~O!U!oO~PLiO!Q!kO~PHrO}!hO!O!iO!P!jO!Q!kO!R!lO!S!mO!T!nO!U!oO!Z!tO![!sO!z!vO!X|i!Y|i!_|i!w|i#[|i$S|i$V|i$f|if|ij|iX|i!x|i!`|i~O!V|i!W|i~PNhO!V!pO!W!pO~PNhO!x%iO~P+XO!V|i!W|i!X|i!Y|i!Z|i![|i!_|i!w|i!z|i$f|if|i!`|i~O}!hO!O!iO!P!jO!Q!kO!R!lO!S!mO!T!nO!U!oO#[|i$S|i$V|ij|iX|i!x|i~P!!qO!`$ga~P,pOf%nO!`$ga~O$S!|O~P`O$S!|O~O$S%wO~Of%xOX$[X~OX%zO~Of#{aj#{aX#{a~P+XOj$`iX$`i~P(qOu!ROXyXfyX$fyX~Of%}O$f%|OX$iX~Of%}OX$iX~OX&PO~O!V|q!W|q!X|q!Y|q!Z|q![|q!_|q!w|q!z|q$f|qf|q!`|q~O}!hO!O!iO!P!jO!Q!kO!R!lO!S!mO!T!nO!U!oO#[|q$S|q$V|qj|qX|q!x|q~P!&wOf!ciuqi!`!ci$fqi~P9[Of!ci!`!ci~P+XO!`$gi~P,pO$Q&WO~OX$[a~P@eOf&^OX$[a~OW%YOX$ia~Of&cOX$ia~O#e(QO#g'oOf#aXj#aX}#aX!O#aX!P#aX!Q#aX!R#aX!S#aX!T#aX!U#aX!V#aX!W#aX!X#aX!Y#aX!Z#aX![#aX!_#aX!w#aX!z#aX$f#aXu#aXX#aX#[#aX$S#aX$V#aX!x#aX!`#aX~O}!hO!O!iO!P!jO!Q!kO!R!lO!S!mO!T!nO!U!oO!V!pO!W!pO!X!qO!Y!qO!Z!tO![!sO!w!rO!z!vO~O!_!vy#[!vy$S!vy$V!vy$f!vyf!vyj!vyX!vy!x!vy!`!vy~P!,TOW&gOs&nO$k&iO~P@eOX$[i~P@eOX!iif!ii~P+XO$f%|OX#zaf#za~OW%YOX$ii~O#e(QO#g'oOf#aaj#aa}#aa!O#aa!P#aa!Q#aa!R#aa!S#aa!T#aa!U#aa!V#aa!W#aa!X#aa!Y#aa!Z#aa![#aa!_#aa!w#aa!z#aa$f#aau#aaX#aa#[#aa$S#aa$V#aa!x#aa!`#aa~O$R&qO$V&rO~P`OW&gOs&nO$R&qO$V!}O$k&iO~P@eOW&vO~OW%YO~O$f&zOu!eX~P$hOuqi$fqifqi!`qi~P9[O}&{Ou|i!O|i!P|i!Q|i!R|i!S|i!T|i!U|i~P!!qO}&{O!O&|Ou|i!P|i!Q|i!R|i!S|i!T|i!U|i~P!!qO}&{O!O&|O!P&}Ou|i!Q|i!R|i!S|i!T|i!U|i~P!!qO}&{O!O&|O!P&}O!Q'OO!S'QO!T'RO!U'SOu|i!R|i~P!!qO}&{O!O&|O!P&}O!Q'OO!T'RO!U'SOu|i!R|i!S|i~P!!qO}&{O!O&|O!P&}O!Q'OO!U'SOu|i!R|i!S|i!T|i~P!!qO}&{O!O&|O!P&}O!Q'OOu|i!R|i!S|i!T|i!U|i~P!!qO}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SO!Z'nO!['VO!z!vOu|i!X|i!Y|i!_|i!w|i$f|if|i!`|i~O!V|i!W|i~P!7RO!V'TO!W'TO~P!7RO}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SOu|i~P!!qOVSOWUOYaOhsOpYOsnOxoO{pO!ZcO!b`O!g'yO!srO!ubO!}cO#PtO#RuO#TvO#VwO#XxO#_'zO#c'{O#i(TO#k|O#s'|O$S!|O$bVO$cVO~P@eO}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SOu|q~P!&wOu'dO$f&zO~P9[O}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SO!V'TO!W'TO!X'UO!Y'UO!Z'nO!['VO!w(PO!z!vO~Ou!vy!_!vy$f!vyf!vy!`!vy~P!<XO$f&zO~O!['cO~Ou'dO#RuO~O!x'iO~P+XOW'pO~OW'qO~OW'tO~OW'uO~O!['xO~OVSOs!dOx!eO!g(OO#_'}O~OW(RO~O$^$]]!V!X!Z^_$_!uW$k$d$fu!}o}!O!P!x!w~\",\n  goto: \"Ab$jPPP$k$s%O%XPPPP&s&vPPP(iPPPP(iP%OP*UP*d+y-`.xPP*d0_P1tP2V0_P2`*dP*dPPPPPPPPPPPPPP*d*dPP*dP3}*d*d*dP4W4_4g4j5l5p5}6Q6W5l*dP*dP*dPP*dP6^*dP%OP6aP%OP%OP%OP6v7PP$k7XP7X7X7aP7kP7qP7XP7XP7y7}8R8R8R8R7XP8V8a8g8m8t:d:j:q:w:};XPPPPPPPPP;_;b;lPPP;o;xPPP?aP@xAOA_]jOl$q&X&f'd[fOl$q&X&f'dR$k#O_eOl#O$q&X&f'd^TOl#O$q&X&f'd#o!]Y[`acpxz}!T!V!^!a!b!h!i!j!k!l!m!n!o!p!q!r!s#U#x$a$e$f$g$z%W%i%n%{%|&V&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'i'x'{'|(P(Q(SR#l!Q#vdOY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(QQ%P#kU&]%x&^&oT&h&[&m$TROY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#k#x$a$e$f$g$q$z%W%i%n%x%{%|&V&X&[&^&f&m&o&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(QU!UUZ&wQ#]rQ#^sR$v#a#wdOY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(Q#wZOY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(Q#vWOY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(QR#u!X#wXOY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(Q#w]OY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(QU!SU%Y&wQ$s#XQ$t#YQ%d$PR%e$QQ#n!RQ$b!uR&Q%_#v]OY`aclpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$q$z%W%i%n%{%|&V&X&f&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'd'i'x'{'|(P(QQ%Z#zV&a%}&c&pS!x`!bV%m$g%n&VZ#{!`#[$S'p'uQ%[#zV&b%}&c&pR%`#{S$r#V'oS$w#c'qS$y#d'rS$|#g'sQ%a#|W%f$R$x'f'tS%p$p'wS%t$u'eS&S%g'gS&T%h'hS&Z%u'kR&s&kT%s$q'dQ#QfQ$m#PS%q$q'dR%v${R&Y%qQ&X%qR&[%vQ&r&fR&u&mR$d!v^eOl#O$q&X&f'dQ$x#cQ%g$RQ'f'qR'g'tQ#QfQ$m#PR&u&m]gOl$q&X&f'd]iOl$q&X&f'dYhOl$q&X&fR&R'dX#Rh#S&R&eS#Th&RT$o#S&eT&l&[&mT&k&[&mT&j&[&mQlOS#Wl&fR&f&XQ%y%PR&_%yQ#s!WR%U#sS!YWXR#v!YY[Ol$q&X&f#j!^Y`acpxz}!T!V!a!b!h!i!j!k!l!m!n!o!p!q!r!s#O#U#x$a$e$f$g$z%W%i%n%{%|&V&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'i'x'{'|(P(QU!c[!^(SR(S'dQ$h!xR%o$hS&O%Z%[R&d&OQ#y!_R%X#yQ#PfR$l#PQ#ShS$n#S&eR&e&RQ&m&[R&t&mR!PPWkOl&X&fT%r$q'dR%R#kQ![YQ#q!VR#}!a^^Ol#O$q&X&f'dU!_Y!V!aY!w`!b$g%n&VQ!zaS!{c&xS#Zp&yQ#bxQ#dzQ#g}Q#o!TS$T!h&{Q$U!iQ$V!jQ$W!kQ$X!lQ$Y!mQ$Z!nQ$[!oQ$]!pQ$^!qQ$_!rQ$`!sQ$p#UU%V#x%W%{Q%j$aQ%k$eQ%l$fQ%u$zQ&U%iQ&`%|Q'W&zQ'X&|Q'Y&}Q'Z'OQ'['PQ']'QQ'^'RQ'_'SQ'`'TQ'a'UQ'b'VQ'j'cQ'k'xQ'l'iQ'r'{Q's'|Q'v(PR'w(Q!h_OYaclpx!T!V!a!h!i!j!k!l!m!n!o!p!q!r!s#O#x$a$f$q%W%i%{%|&X&f'd(P!_'m`z}!b#U$e$g$z%n&V&x&y&z&{&|&}'O'P'Q'R'S'T'U'V'c'i'x'{'|(QQ!y`R$O!bQ#|!`Q$u#[Q%h$SQ'e'pR'h'uR%^#z\",\n  nodeNames: \"\u26A0 Comment Script SimpleStatement SmallStatement StandaloneAnnotationNode AnnotationNode @ Identifier ) ( CallParamsLiteralExpressionNode LiteralExpressionNode True False Null BuiltinConstants PI TAU INF NaN String , AssertNode assert CallParamsExpressionNode ] ArrayExpressionNode SubscriptExpressionNode VariableName GetNodeExpressionNode . [ AssignmentExpressionNode VariableNode var TypeCast : Type ConstantNode const ParameterNode AwaitExpressionNode await BinaryOperatorExpressionNode ArithOp ArithOp ArithOp BitOp CompareOp BitOp BitOp BitOp AndOp LogicOp OrOp LogicOp NotOp in CallExpressionNode CastExpressionNode as } DictionaryExpressionNode { DictionaryEntry GroupedExpressionNode IdentifierExpressionNode LambdaExpressionNode func CallParamsParameterNode AssignmentExpressionNode FunctionReturnType Body SuiteNodeBody Newline SuiteNode Indent Dedent ExpressionNodeBody PreloadExpressionNode preload SelfExpressionNode SelfToken TernaryOperatorExpressionNode TernaryOp TernaryOp TypeTestExpressionNode is ClassName UnaryOperatorNode ArithOp ClassNameStatement class_name ExtendsStatement extends SignalStatement signal PassStatement pass ReturnNode return Eof StatementGroup ; CompoundStatement ClassNode class FunctionNode IfNode IfClause if ElifClause elif ElseClause else ForNode for MatchNode match MatchBranchNode PatternNode VarPatternNode IdentifierPatternNode LiteralPatternNode WildcardPatternNode WhileNode while\",\n  maxTerm: 165,\n  context: trackIndent,\n  nodeProps: [\n    [\"group\", -2,3,105,\"Statement\",-18,12,27,28,30,33,42,44,59,60,63,66,67,68,80,82,84,87,90,\"ExpressionNode\",-3,34,39,41,\"AssignableNode\"],\n    [\"openedBy\", 9,\"(\"],\n    [\"closedBy\", 10,\")\"]\n  ],\n  propSources: [gdscriptHighlighting],\n  skippedNodes: [0,1],\n  repeatNodeCount: 11,\n  tokenData: \"@U~R|XY#{pq#{qr$Wrs$est(Vtu(quv(vvw(}wx)[xy,|yz-Rz{-W{|-e|}-l}!O-q!O!P.Q!P!Q/]!Q!R/d!R![0U![!]1v!]!^1}!^!_2S!_!`2d!`!a2l!a!b2w!b!c2|!c!}3R!}#O3d#P#Q3i#Q#R3n#R#S3s#T#U4W#U#Y3R#Y#Z5k#Z#b3R#b#c7{#c#d:y#d#g3R#g#h;u#h#i=q#i#o3R#o#p?m#p#q?r#q#r@P~$QQ$X~XY#{pq#{R$]P!}P!_!`$`Q$eO!RQ~$hXOY$eZ]$e^r$ers%Ts#O$e#O#P%u#P;'S$e;'S;=`(P<%lO$e~%YX$_~OY$eZ]$e^r$ers%Ts#O$e#O#P%u#P;'S$e;'S;=`(P<%lO$e~%xVO#i$e#i#j&_#j#l$e#l#m&z#m;'S$e;'S;=`(P<%lO$e~&bS!Q![&n!c!i&n#T#Z&n#o#p'd~&qR!Q![&z!c!i&z#T#Z&z~&}R!Q!['W!c!i'W#T#Z'W~'ZR!Q![$e!c!i$e#T#Z$e~'gR!Q!['p!c!i'p#T#Z'p~'sS!Q!['p!c!i'p#T#Z'p#q#r$e~(SP;=`<%l$e~([TP~OY(VZ](V^;'S(V;'S;=`(k<%lO(V~(nP;=`<%l(V~(vO$b~R(}O$cP!OQ~)SP!U~vw)V~)[O!W~~)_XOY)[Z])[^w)[wx)zx#O)[#O#P*l#P;'S)[;'S;=`,v<%lO)[~*PX$_~OY)[Z])[^w)[wx)zx#O)[#O#P*l#P;'S)[;'S;=`,v<%lO)[~*oVO#i)[#i#j+U#j#l)[#l#m+q#m;'S)[;'S;=`,v<%lO)[~+XS!Q![+e!c!i+e#T#Z+e#o#p,Z~+hR!Q![+q!c!i+q#T#Z+q~+tR!Q![+}!c!i+}#T#Z+}~,QR!Q![)[!c!i)[#T#Z)[~,^R!Q![,g!c!i,g#T#Z,g~,jS!Q![,g!c!i,g#T#Z,g#q#r)[~,yP;=`<%l)[~-ROY~~-WOX~~-]P!OQz{-`~-eO}~R-lO!}P!PQ~-qOf~V-xP!}P!PQ!`!a-{S.QO$jS~.VPo~!Q![.Y~._S$^~!Q![.Y!g!h.k#R#S/V#X#Y.k~.nQ{|.t}!O.t~.wP!Q![.z~/PQ$^~!Q![.z#R#S.t~/YP!Q![.Y~/dO$d~!OQ~/iX$]~!O!P/V!Q![0U!d!e0p!g!h.k!z!{1X#R#S0j#U#V0p#X#Y.k#l#m1X~0ZT$]~!O!P/V!Q![0U!g!h.k#R#S0j#X#Y.k~0mP!Q![0U~0sQ!Q!R0y!R!S0y~1OR$]~!Q!R0y!R!S0y#R#S0p~1[R!Q![1e!c!i1e#T#Z1e~1jS$]~!Q![1e!c!i1e#R#S1X#T#Z1e~1}Ou~!x~~2SO#[~~2XQ!RQ!^!_2_!_!`$`~2dO!Q~~2iP$f~!_!`$`~2qQ!RQ!_!`$`!`!a2_~2|O!w~~3ROV~~3WSW~!Q![3R!c!}3R#R#S3R#T#o3R~3iOp~~3nOj~~3sO!T~~3zSW~$k~!Q![3R!c!}3R#R#S3R#T#o3R~4]UW~!Q![3R!c!}3R#R#S3R#T#b3R#b#c4o#c#o3R~4tUW~!Q![3R!c!}3R#R#S3R#T#W3R#W#X5W#X#o3R~5_S!V~W~!Q![3R!c!}3R#R#S3R#T#o3R~5pTW~!Q![3R!c!}3R#R#S3R#T#U6P#U#o3R~6UUW~!Q![3R!c!}3R#R#S3R#T#`3R#`#a6h#a#o3R~6mUW~!Q![3R!c!}3R#R#S3R#T#g3R#g#h7P#h#o3R~7UUW~!Q![3R!c!}3R#R#S3R#T#X3R#X#Y7h#Y#o3R~7oS^~W~!Q![3R!c!}3R#R#S3R#T#o3R~8QWW~!Q![3R!c!}3R#R#S3R#T#c3R#c#d8j#d#i3R#i#j9f#j#o3R~8oUW~!Q![3R!c!}3R#R#S3R#T#h3R#h#i9R#i#o3R~9YS!Z~W~!Q![3R!c!}3R#R#S3R#T#o3R~9kUW~!Q![3R!c!}3R#R#S3R#T#`3R#`#a9}#a#o3R~:SUW~!Q![3R!c!}3R#R#S3R#T#`3R#`#a:f#a#o3R~:mS_~W~!Q![3R!c!}3R#R#S3R#T#o3R~;OUW~!Q![3R!c!}3R#R#S3R#T#f3R#f#g;b#g#o3R~;iS!X~W~!Q![3R!c!}3R#R#S3R#T#o3R~;zUW~!Q![3R!c!}3R#R#S3R#T#X3R#X#Y<^#Y#o3R~<cUW~!Q![3R!c!}3R#R#S3R#T#`3R#`#a<u#a#o3R~<zUW~!Q![3R!c!}3R#R#S3R#T#Y3R#Y#Z=^#Z#o3R~=eS!u~W~!Q![3R!c!}3R#R#S3R#T#o3R~=vUW~!Q![3R!c!}3R#R#S3R#T#f3R#f#g>Y#g#o3R~>_UW~!Q![3R!c!}3R#R#S3R#T#i3R#i#j>q#j#o3R~>vUW~!Q![3R!c!}3R#R#S3R#T#X3R#X#Y?Y#Y#o3R~?aS]~W~!Q![3R!c!}3R#R#S3R#T#o3R~?rO!b~~?wP!S~#p#q?z~@PO!Y~~@UO!`~\",\n  tokenizers: [indentation, newlines, 0, 1, 2],\n  topRules: {\"Script\":[0,2]},\n  specialized: [{term: 8, get: value => spec_Identifier[value] || -1}],\n  tokenPrec: 3508\n})\n", "import { ContextTracker, ExternalTokenizer } from \"@lezer/lr\";\nimport {\n  // created\n  // indentation\n  indent,\n  dedent,\n  // newlines\n  newline as newlineToken,\n  blankLineStart,\n  newlineBracketed,\n  eof,\n  // existing\n  GroupedExpressionNode,\n  ArrayExpressionNode,\n  DictionaryExpressionNode,\n  CallExpressionNode,\n  CallParamsExpressionNode,\n  CallParamsLiteralExpressionNode,\n  CallParamsParameterNode,\n  // tokens\n  ParenL,\n  BracketL,\n  BraceL,\n} from \"./parser.terms\";\n\nconst bracketed = new Set([\n  GroupedExpressionNode,\n  ArrayExpressionNode,\n  DictionaryExpressionNode,\n  CallExpressionNode,\n  CallParamsExpressionNode,\n  CallParamsLiteralExpressionNode,\n  CallParamsParameterNode,\n]);\n\nconst newline = \"\\n\".charCodeAt(0);\nconst carriageReturn = \"\\r\".charCodeAt(0);\nconst space = \" \".charCodeAt(0);\nconst tab = \"\\t\".charCodeAt(0);\nconst hash = \"#\".charCodeAt(0);\n\nclass IndentLevel {\n  constructor(parent, depth) {\n    this.parent = parent;\n    // -1 means this is not an actual indent level but a set of brackets\n    this.depth = depth;\n    this.hash =\n      (parent ? (parent.hash + parent.hash) << 8 : 0) + depth + (depth << 4);\n  }\n}\n\nconst topIndent = new IndentLevel(null, 0);\n\nfunction isLineBreak(ch) {\n  return ch === newline || ch === carriageReturn;\n}\n\nexport const newlines = new ExternalTokenizer(\n  (input, stack) => {\n    let prev;\n    if (input.next < 0) {\n      input.acceptToken(eof);\n    } else if (stack.context.depth < 0) {\n      if (isLineBreak(input.next)) {\n        input.acceptToken(newlineBracketed, 1);\n      }\n    } else if (\n      ((prev = input.peek(-1)) < 0 || isLineBreak(prev)) &&\n      stack.canShift(blankLineStart)\n    ) {\n      let spaces = 0;\n      while (input.next === space || input.next === tab) {\n        input.advance();\n        spaces++;\n      }\n      if (\n        input.next === newline ||\n        input.next === carriageReturn ||\n        input.next === hash\n      ) {\n        input.acceptToken(blankLineStart, -spaces);\n      }\n    } else if (isLineBreak(input.next)) {\n      input.acceptToken(newlineToken, 1);\n    }\n  },\n  { contextual: true }\n);\n\nfunction countIndent(space) {\n  let depth = 0;\n  for (let i = 0; i < space.length; i++)\n    depth += space.charCodeAt(i) === tab ? 8 - (depth % 8) : 1;\n  return depth;\n}\n\nexport const trackIndent = new ContextTracker({\n  start: topIndent,\n  reduce(context, term) {\n    return context.depth < 0 && bracketed.has(term) ? context.parent : context;\n  },\n  shift(context, term, stack, input) {\n    switch (term) {\n      case indent:\n        return new IndentLevel(\n          context,\n          countIndent(input.read(input.pos, stack.pos))\n        );\n      case dedent:\n        return context.parent;\n      case ParenL:\n      case BracketL:\n      case BraceL:\n        return new IndentLevel(context, -1);\n      default:\n        return context;\n    }\n  },\n  hash(context) {\n    return context.hash;\n  },\n});\n\nexport const indentation = new ExternalTokenizer((input, stack) => {\n  const contextDepth = stack.context.depth;\n  if (contextDepth < 0) return;\n\n  const prev = input.peek(-1);\n\n  if (!(prev === newline || prev === carriageReturn)) {\n    return;\n  }\n\n  let chars = 0;\n  let depth = 0;\n\n  while (true) {\n    if (input.next === space) {\n      depth++;\n    } else if (input.next === tab) {\n      depth += 8 - (depth % 8);\n    } else {\n      break;\n    }\n\n    input.advance();\n    chars += 1;\n  }\n\n  if (\n    depth !== contextDepth &&\n    input.next !== newline &&\n    input.next !== carriageReturn &&\n    input.next !== hash\n  ) {\n    if (depth < contextDepth) {\n      input.acceptToken(dedent, -chars);\n    } else {\n      input.acceptToken(indent);\n    }\n  }\n});\n", "// This file was generated by lezer-generator. You probably shouldn't edit it.\nexport const\n  indent = 140,\n  dedent = 141,\n  newline = 142,\n  blankLineStart = 143,\n  newlineBracketed = 144,\n  eof = 145,\n  Comment = 1,\n  Script = 2,\n  SimpleStatement = 3,\n  SmallStatement = 4,\n  AnnotationNode = 6,\n  Identifier = 8,\n  ParenL = 10,\n  CallParamsLiteralExpressionNode = 11,\n  LiteralExpressionNode = 12,\n  True = 13,\n  False = 14,\n  Null = 15,\n  BuiltinConstants = 16,\n  String = 21,\n  AssertNode = 23,\n  CallParamsExpressionNode = 25,\n  ArrayExpressionNode = 27,\n  SubscriptExpressionNode = 28,\n  VariableName = 29,\n  GetNodeExpressionNode = 30,\n  BracketL = 32,\n  VariableNode = 34,\n  TypeCast = 36,\n  Type = 38,\n  ConstantNode = 39,\n  ParameterNode = 41,\n  AwaitExpressionNode = 42,\n  BinaryOperatorExpressionNode = 44,\n  AndOp = 53,\n  OrOp = 55,\n  NotOp = 57,\n  CallExpressionNode = 59,\n  CastExpressionNode = 60,\n  DictionaryExpressionNode = 63,\n  BraceL = 64,\n  DictionaryEntry = 65,\n  GroupedExpressionNode = 66,\n  IdentifierExpressionNode = 67,\n  LambdaExpressionNode = 68,\n  CallParamsParameterNode = 70,\n  FunctionReturnType = 72,\n  Body = 73,\n  SuiteNodeBody = 74,\n  Newline = 75,\n  SuiteNode = 76,\n  Indent = 77,\n  Dedent = 78,\n  ExpressionNodeBody = 79,\n  PreloadExpressionNode = 80,\n  SelfToken = 83,\n  TernaryOperatorExpressionNode = 84,\n  TypeTestExpressionNode = 87,\n  ClassName = 89,\n  UnaryOperatorNode = 90,\n  ClassNameStatement = 92,\n  ExtendsStatement = 94,\n  SignalStatement = 96,\n  PassStatement = 98,\n  ReturnNode = 100,\n  Eof = 102,\n  CompoundStatement = 105,\n  ClassNode = 106,\n  FunctionNode = 108,\n  IfNode = 109,\n  IfClause = 110,\n  ElifClause = 112,\n  ElseClause = 114,\n  ForNode = 116,\n  MatchNode = 118,\n  MatchBranchNode = 120,\n  PatternNode = 121,\n  WhileNode = 126\n", "import { styleTags, tags as t } from \"@lezer/highlight\";\n\nexport const gdscriptHighlighting = styleTags({\n  \"for while if elif else return break continue pass assert await match case\":\n    t.controlKeyword,\n  \"in not and or is del\": t.operatorKeyword,\n  \"func class class_name extends const var\": t.definitionKeyword,\n  \"preload load\": t.moduleKeyword,\n  \"as PI TAU INF NaN\": t.keyword,\n  True: t.bool,\n  False: t.bool,\n  Null: t.bool,\n  Comment: t.lineComment,\n  Number: t.number,\n  String: t.string,\n  UpdateOp: t.updateOperator,\n  ArithOp: t.arithmeticOperator,\n  BitOp: t.bitwiseOperator,\n  CompareOp: t.compareOperator,\n  AssignOp: t.definitionOperator,\n  \"ClassNode/Identifier ClassNode/ExtendsStatement/Identifier VariableNode/TypeCast/Type/Identifier\":\n    t.definition(t.className),\n  \"( )\": t.paren,\n  \"[ ]\": t.squareBracket,\n  \"{ }\": t.brace,\n  \".\": t.derefOperator,\n  \", ;\": t.separator,\n});\n", "// FIXME profile adding a per-Tree TreeNode cache, validating it by\n// parent pointer\n/// The default maximum length of a `TreeBuffer` node.\nconst DefaultBufferLength = 1024;\nlet nextPropID = 0;\nclass Range {\n    constructor(from, to) {\n        this.from = from;\n        this.to = to;\n    }\n}\n/// Each [node type](#common.NodeType) or [individual tree](#common.Tree)\n/// can have metadata associated with it in props. Instances of this\n/// class represent prop names.\nclass NodeProp {\n    /// Create a new node prop type.\n    constructor(config = {}) {\n        this.id = nextPropID++;\n        this.perNode = !!config.perNode;\n        this.deserialize = config.deserialize || (() => {\n            throw new Error(\"This node type doesn't define a deserialize function\");\n        });\n    }\n    /// This is meant to be used with\n    /// [`NodeSet.extend`](#common.NodeSet.extend) or\n    /// [`LRParser.configure`](#lr.ParserConfig.props) to compute\n    /// prop values for each node type in the set. Takes a [match\n    /// object](#common.NodeType^match) or function that returns undefined\n    /// if the node type doesn't get this prop, and the prop's value if\n    /// it does.\n    add(match) {\n        if (this.perNode)\n            throw new RangeError(\"Can't add per-node props to node types\");\n        if (typeof match != \"function\")\n            match = NodeType.match(match);\n        return (type) => {\n            let result = match(type);\n            return result === undefined ? null : [this, result];\n        };\n    }\n}\n/// Prop that is used to describe matching delimiters. For opening\n/// delimiters, this holds an array of node names (written as a\n/// space-separated string when declaring this prop in a grammar)\n/// for the node types of closing delimiters that match it.\nNodeProp.closedBy = new NodeProp({ deserialize: str => str.split(\" \") });\n/// The inverse of [`closedBy`](#common.NodeProp^closedBy). This is\n/// attached to closing delimiters, holding an array of node names\n/// of types of matching opening delimiters.\nNodeProp.openedBy = new NodeProp({ deserialize: str => str.split(\" \") });\n/// Used to assign node types to groups (for example, all node\n/// types that represent an expression could be tagged with an\n/// `\"Expression\"` group).\nNodeProp.group = new NodeProp({ deserialize: str => str.split(\" \") });\n/// The hash of the [context](#lr.ContextTracker.constructor)\n/// that the node was parsed in, if any. Used to limit reuse of\n/// contextual nodes.\nNodeProp.contextHash = new NodeProp({ perNode: true });\n/// The distance beyond the end of the node that the tokenizer\n/// looked ahead for any of the tokens inside the node. (The LR\n/// parser only stores this when it is larger than 25, for\n/// efficiency reasons.)\nNodeProp.lookAhead = new NodeProp({ perNode: true });\n/// This per-node prop is used to replace a given node, or part of a\n/// node, with another tree. This is useful to include trees from\n/// different languages in mixed-language parsers.\nNodeProp.mounted = new NodeProp({ perNode: true });\n/// A mounted tree, which can be [stored](#common.NodeProp^mounted) on\n/// a tree node to indicate that parts of its content are\n/// represented by another tree.\nclass MountedTree {\n    constructor(\n    /// The inner tree.\n    tree, \n    /// If this is null, this tree replaces the entire node (it will\n    /// be included in the regular iteration instead of its host\n    /// node). If not, only the given ranges are considered to be\n    /// covered by this tree. This is used for trees that are mixed in\n    /// a way that isn't strictly hierarchical. Such mounted trees are\n    /// only entered by [`resolveInner`](#common.Tree.resolveInner)\n    /// and [`enter`](#common.SyntaxNode.enter).\n    overlay, \n    /// The parser used to create this subtree.\n    parser) {\n        this.tree = tree;\n        this.overlay = overlay;\n        this.parser = parser;\n    }\n}\nconst noProps = Object.create(null);\n/// Each node in a syntax tree has a node type associated with it.\nclass NodeType {\n    /// @internal\n    constructor(\n    /// The name of the node type. Not necessarily unique, but if the\n    /// grammar was written properly, different node types with the\n    /// same name within a node set should play the same semantic\n    /// role.\n    name, \n    /// @internal\n    props, \n    /// The id of this node in its set. Corresponds to the term ids\n    /// used in the parser.\n    id, \n    /// @internal\n    flags = 0) {\n        this.name = name;\n        this.props = props;\n        this.id = id;\n        this.flags = flags;\n    }\n    /// Define a node type.\n    static define(spec) {\n        let props = spec.props && spec.props.length ? Object.create(null) : noProps;\n        let flags = (spec.top ? 1 /* NodeFlag.Top */ : 0) | (spec.skipped ? 2 /* NodeFlag.Skipped */ : 0) |\n            (spec.error ? 4 /* NodeFlag.Error */ : 0) | (spec.name == null ? 8 /* NodeFlag.Anonymous */ : 0);\n        let type = new NodeType(spec.name || \"\", props, spec.id, flags);\n        if (spec.props)\n            for (let src of spec.props) {\n                if (!Array.isArray(src))\n                    src = src(type);\n                if (src) {\n                    if (src[0].perNode)\n                        throw new RangeError(\"Can't store a per-node prop on a node type\");\n                    props[src[0].id] = src[1];\n                }\n            }\n        return type;\n    }\n    /// Retrieves a node prop for this type. Will return `undefined` if\n    /// the prop isn't present on this node.\n    prop(prop) { return this.props[prop.id]; }\n    /// True when this is the top node of a grammar.\n    get isTop() { return (this.flags & 1 /* NodeFlag.Top */) > 0; }\n    /// True when this node is produced by a skip rule.\n    get isSkipped() { return (this.flags & 2 /* NodeFlag.Skipped */) > 0; }\n    /// Indicates whether this is an error node.\n    get isError() { return (this.flags & 4 /* NodeFlag.Error */) > 0; }\n    /// When true, this node type doesn't correspond to a user-declared\n    /// named node, for example because it is used to cache repetition.\n    get isAnonymous() { return (this.flags & 8 /* NodeFlag.Anonymous */) > 0; }\n    /// Returns true when this node's name or one of its\n    /// [groups](#common.NodeProp^group) matches the given string.\n    is(name) {\n        if (typeof name == 'string') {\n            if (this.name == name)\n                return true;\n            let group = this.prop(NodeProp.group);\n            return group ? group.indexOf(name) > -1 : false;\n        }\n        return this.id == name;\n    }\n    /// Create a function from node types to arbitrary values by\n    /// specifying an object whose property names are node or\n    /// [group](#common.NodeProp^group) names. Often useful with\n    /// [`NodeProp.add`](#common.NodeProp.add). You can put multiple\n    /// names, separated by spaces, in a single property name to map\n    /// multiple node names to a single value.\n    static match(map) {\n        let direct = Object.create(null);\n        for (let prop in map)\n            for (let name of prop.split(\" \"))\n                direct[name] = map[prop];\n        return (node) => {\n            for (let groups = node.prop(NodeProp.group), i = -1; i < (groups ? groups.length : 0); i++) {\n                let found = direct[i < 0 ? node.name : groups[i]];\n                if (found)\n                    return found;\n            }\n        };\n    }\n}\n/// An empty dummy node type to use when no actual type is available.\nNodeType.none = new NodeType(\"\", Object.create(null), 0, 8 /* NodeFlag.Anonymous */);\n/// A node set holds a collection of node types. It is used to\n/// compactly represent trees by storing their type ids, rather than a\n/// full pointer to the type object, in a numeric array. Each parser\n/// [has](#lr.LRParser.nodeSet) a node set, and [tree\n/// buffers](#common.TreeBuffer) can only store collections of nodes\n/// from the same set. A set can have a maximum of 2**16 (65536) node\n/// types in it, so that the ids fit into 16-bit typed array slots.\nclass NodeSet {\n    /// Create a set with the given types. The `id` property of each\n    /// type should correspond to its position within the array.\n    constructor(\n    /// The node types in this set, by id.\n    types) {\n        this.types = types;\n        for (let i = 0; i < types.length; i++)\n            if (types[i].id != i)\n                throw new RangeError(\"Node type ids should correspond to array positions when creating a node set\");\n    }\n    /// Create a copy of this set with some node properties added. The\n    /// arguments to this method can be created with\n    /// [`NodeProp.add`](#common.NodeProp.add).\n    extend(...props) {\n        let newTypes = [];\n        for (let type of this.types) {\n            let newProps = null;\n            for (let source of props) {\n                let add = source(type);\n                if (add) {\n                    if (!newProps)\n                        newProps = Object.assign({}, type.props);\n                    newProps[add[0].id] = add[1];\n                }\n            }\n            newTypes.push(newProps ? new NodeType(type.name, newProps, type.id, type.flags) : type);\n        }\n        return new NodeSet(newTypes);\n    }\n}\nconst CachedNode = new WeakMap(), CachedInnerNode = new WeakMap();\n/// Options that control iteration. Can be combined with the `|`\n/// operator to enable multiple ones.\nvar IterMode;\n(function (IterMode) {\n    /// When enabled, iteration will only visit [`Tree`](#common.Tree)\n    /// objects, not nodes packed into\n    /// [`TreeBuffer`](#common.TreeBuffer)s.\n    IterMode[IterMode[\"ExcludeBuffers\"] = 1] = \"ExcludeBuffers\";\n    /// Enable this to make iteration include anonymous nodes (such as\n    /// the nodes that wrap repeated grammar constructs into a balanced\n    /// tree).\n    IterMode[IterMode[\"IncludeAnonymous\"] = 2] = \"IncludeAnonymous\";\n    /// By default, regular [mounted](#common.NodeProp^mounted) nodes\n    /// replace their base node in iteration. Enable this to ignore them\n    /// instead.\n    IterMode[IterMode[\"IgnoreMounts\"] = 4] = \"IgnoreMounts\";\n    /// This option only applies in\n    /// [`enter`](#common.SyntaxNode.enter)-style methods. It tells the\n    /// library to not enter mounted overlays if one covers the given\n    /// position.\n    IterMode[IterMode[\"IgnoreOverlays\"] = 8] = \"IgnoreOverlays\";\n})(IterMode || (IterMode = {}));\n/// A piece of syntax tree. There are two ways to approach these\n/// trees: the way they are actually stored in memory, and the\n/// convenient way.\n///\n/// Syntax trees are stored as a tree of `Tree` and `TreeBuffer`\n/// objects. By packing detail information into `TreeBuffer` leaf\n/// nodes, the representation is made a lot more memory-efficient.\n///\n/// However, when you want to actually work with tree nodes, this\n/// representation is very awkward, so most client code will want to\n/// use the [`TreeCursor`](#common.TreeCursor) or\n/// [`SyntaxNode`](#common.SyntaxNode) interface instead, which provides\n/// a view on some part of this data structure, and can be used to\n/// move around to adjacent nodes.\nclass Tree {\n    /// Construct a new tree. See also [`Tree.build`](#common.Tree^build).\n    constructor(\n    /// The type of the top node.\n    type, \n    /// This node's child nodes.\n    children, \n    /// The positions (offsets relative to the start of this tree) of\n    /// the children.\n    positions, \n    /// The total length of this tree\n    length, \n    /// Per-node [node props](#common.NodeProp) to associate with this node.\n    props) {\n        this.type = type;\n        this.children = children;\n        this.positions = positions;\n        this.length = length;\n        /// @internal\n        this.props = null;\n        if (props && props.length) {\n            this.props = Object.create(null);\n            for (let [prop, value] of props)\n                this.props[typeof prop == \"number\" ? prop : prop.id] = value;\n        }\n    }\n    /// @internal\n    toString() {\n        let mounted = this.prop(NodeProp.mounted);\n        if (mounted && !mounted.overlay)\n            return mounted.tree.toString();\n        let children = \"\";\n        for (let ch of this.children) {\n            let str = ch.toString();\n            if (str) {\n                if (children)\n                    children += \",\";\n                children += str;\n            }\n        }\n        return !this.type.name ? children :\n            (/\\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) +\n                (children.length ? \"(\" + children + \")\" : \"\");\n    }\n    /// Get a [tree cursor](#common.TreeCursor) positioned at the top of\n    /// the tree. Mode can be used to [control](#common.IterMode) which\n    /// nodes the cursor visits.\n    cursor(mode = 0) {\n        return new TreeCursor(this.topNode, mode);\n    }\n    /// Get a [tree cursor](#common.TreeCursor) pointing into this tree\n    /// at the given position and side (see\n    /// [`moveTo`](#common.TreeCursor.moveTo).\n    cursorAt(pos, side = 0, mode = 0) {\n        let scope = CachedNode.get(this) || this.topNode;\n        let cursor = new TreeCursor(scope);\n        cursor.moveTo(pos, side);\n        CachedNode.set(this, cursor._tree);\n        return cursor;\n    }\n    /// Get a [syntax node](#common.SyntaxNode) object for the top of the\n    /// tree.\n    get topNode() {\n        return new TreeNode(this, 0, 0, null);\n    }\n    /// Get the [syntax node](#common.SyntaxNode) at the given position.\n    /// If `side` is -1, this will move into nodes that end at the\n    /// position. If 1, it'll move into nodes that start at the\n    /// position. With 0, it'll only enter nodes that cover the position\n    /// from both sides.\n    ///\n    /// Note that this will not enter\n    /// [overlays](#common.MountedTree.overlay), and you often want\n    /// [`resolveInner`](#common.Tree.resolveInner) instead.\n    resolve(pos, side = 0) {\n        let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);\n        CachedNode.set(this, node);\n        return node;\n    }\n    /// Like [`resolve`](#common.Tree.resolve), but will enter\n    /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node\n    /// pointing into the innermost overlaid tree at the given position\n    /// (with parent links going through all parent structure, including\n    /// the host trees).\n    resolveInner(pos, side = 0) {\n        let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);\n        CachedInnerNode.set(this, node);\n        return node;\n    }\n    /// Iterate over the tree and its children, calling `enter` for any\n    /// node that touches the `from`/`to` region (if given) before\n    /// running over such a node's children, and `leave` (if given) when\n    /// leaving the node. When `enter` returns `false`, that node will\n    /// not have its children iterated over (or `leave` called).\n    iterate(spec) {\n        let { enter, leave, from = 0, to = this.length } = spec;\n        let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0;\n        for (let c = this.cursor(mode | IterMode.IncludeAnonymous);;) {\n            let entered = false;\n            if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== false)) {\n                if (c.firstChild())\n                    continue;\n                entered = true;\n            }\n            for (;;) {\n                if (entered && leave && (anon || !c.type.isAnonymous))\n                    leave(c);\n                if (c.nextSibling())\n                    break;\n                if (!c.parent())\n                    return;\n                entered = true;\n            }\n        }\n    }\n    /// Get the value of the given [node prop](#common.NodeProp) for this\n    /// node. Works with both per-node and per-type props.\n    prop(prop) {\n        return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : undefined;\n    }\n    /// Returns the node's [per-node props](#common.NodeProp.perNode) in a\n    /// format that can be passed to the [`Tree`](#common.Tree)\n    /// constructor.\n    get propValues() {\n        let result = [];\n        if (this.props)\n            for (let id in this.props)\n                result.push([+id, this.props[id]]);\n        return result;\n    }\n    /// Balance the direct children of this tree, producing a copy of\n    /// which may have children grouped into subtrees with type\n    /// [`NodeType.none`](#common.NodeType^none).\n    balance(config = {}) {\n        return this.children.length <= 8 /* Balance.BranchFactor */ ? this :\n            balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));\n    }\n    /// Build a tree from a postfix-ordered buffer of node information,\n    /// or a cursor over such a buffer.\n    static build(data) { return buildTree(data); }\n}\n/// The empty tree\nTree.empty = new Tree(NodeType.none, [], [], 0);\nclass FlatBufferCursor {\n    constructor(buffer, index) {\n        this.buffer = buffer;\n        this.index = index;\n    }\n    get id() { return this.buffer[this.index - 4]; }\n    get start() { return this.buffer[this.index - 3]; }\n    get end() { return this.buffer[this.index - 2]; }\n    get size() { return this.buffer[this.index - 1]; }\n    get pos() { return this.index; }\n    next() { this.index -= 4; }\n    fork() { return new FlatBufferCursor(this.buffer, this.index); }\n}\n/// Tree buffers contain (type, start, end, endIndex) quads for each\n/// node. In such a buffer, nodes are stored in prefix order (parents\n/// before children, with the endIndex of the parent indicating which\n/// children belong to it).\nclass TreeBuffer {\n    /// Create a tree buffer.\n    constructor(\n    /// The buffer's content.\n    buffer, \n    /// The total length of the group of nodes in the buffer.\n    length, \n    /// The node set used in this buffer.\n    set) {\n        this.buffer = buffer;\n        this.length = length;\n        this.set = set;\n    }\n    /// @internal\n    get type() { return NodeType.none; }\n    /// @internal\n    toString() {\n        let result = [];\n        for (let index = 0; index < this.buffer.length;) {\n            result.push(this.childString(index));\n            index = this.buffer[index + 3];\n        }\n        return result.join(\",\");\n    }\n    /// @internal\n    childString(index) {\n        let id = this.buffer[index], endIndex = this.buffer[index + 3];\n        let type = this.set.types[id], result = type.name;\n        if (/\\W/.test(result) && !type.isError)\n            result = JSON.stringify(result);\n        index += 4;\n        if (endIndex == index)\n            return result;\n        let children = [];\n        while (index < endIndex) {\n            children.push(this.childString(index));\n            index = this.buffer[index + 3];\n        }\n        return result + \"(\" + children.join(\",\") + \")\";\n    }\n    /// @internal\n    findChild(startIndex, endIndex, dir, pos, side) {\n        let { buffer } = this, pick = -1;\n        for (let i = startIndex; i != endIndex; i = buffer[i + 3]) {\n            if (checkSide(side, pos, buffer[i + 1], buffer[i + 2])) {\n                pick = i;\n                if (dir > 0)\n                    break;\n            }\n        }\n        return pick;\n    }\n    /// @internal\n    slice(startI, endI, from) {\n        let b = this.buffer;\n        let copy = new Uint16Array(endI - startI), len = 0;\n        for (let i = startI, j = 0; i < endI;) {\n            copy[j++] = b[i++];\n            copy[j++] = b[i++] - from;\n            let to = copy[j++] = b[i++] - from;\n            copy[j++] = b[i++] - startI;\n            len = Math.max(len, to);\n        }\n        return new TreeBuffer(copy, len, this.set);\n    }\n}\nfunction checkSide(side, pos, from, to) {\n    switch (side) {\n        case -2 /* Side.Before */: return from < pos;\n        case -1 /* Side.AtOrBefore */: return to >= pos && from < pos;\n        case 0 /* Side.Around */: return from < pos && to > pos;\n        case 1 /* Side.AtOrAfter */: return from <= pos && to > pos;\n        case 2 /* Side.After */: return to > pos;\n        case 4 /* Side.DontCare */: return true;\n    }\n}\nfunction enterUnfinishedNodesBefore(node, pos) {\n    let scan = node.childBefore(pos);\n    while (scan) {\n        let last = scan.lastChild;\n        if (!last || last.to != scan.to)\n            break;\n        if (last.type.isError && last.from == last.to) {\n            node = scan;\n            scan = last.prevSibling;\n        }\n        else {\n            scan = last;\n        }\n    }\n    return node;\n}\nfunction resolveNode(node, pos, side, overlays) {\n    var _a;\n    // Move up to a node that actually holds the position, if possible\n    while (node.from == node.to ||\n        (side < 1 ? node.from >= pos : node.from > pos) ||\n        (side > -1 ? node.to <= pos : node.to < pos)) {\n        let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;\n        if (!parent)\n            return node;\n        node = parent;\n    }\n    let mode = overlays ? 0 : IterMode.IgnoreOverlays;\n    // Must go up out of overlays when those do not overlap with pos\n    if (overlays)\n        for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {\n            if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)\n                node = parent;\n        }\n    for (;;) {\n        let inner = node.enter(pos, side, mode);\n        if (!inner)\n            return node;\n        node = inner;\n    }\n}\nclass TreeNode {\n    constructor(_tree, from, \n    // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)\n    index, _parent) {\n        this._tree = _tree;\n        this.from = from;\n        this.index = index;\n        this._parent = _parent;\n    }\n    get type() { return