{
  "version": 3,
  "sources": ["../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", "../src/complete.mts"],
  "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&lQUO'#CzO&qQUO'#CxO(pQYO'#FmO*hQUO'#CwO*oQYO'#FmO*|QUO'#DOOOQQ'#Fq'#FqO,lQYO'#C`O,dQYO'#C}O,yQUO'#DmO(wQUO'#DpOOQQ'#EQ'#EQO(wQUO'#EYOOQQ'#Fm'#FmOOQQ'#C`'#C`O.jQUO'#C_OOQR'#C_'#C_O.uQVO'#EmOOQR'#Ei'#EiOOQR'#Fg'#FgOOQR'#FQ'#FQQ`QUOOOOQQ'#Cl'#ClO1kQUO'#DOO1pQUO'#DTO(wQUO'#DWO1uQUO'#ElO1zQUO'#EOO1zQUO'#CsO2PQUO'#E[O2UQUO'#E^O2ZQUO'#E`OOQQ'#Eb'#EbO(wQUO'#EdO2`QUO'#EjO,yQUO'#EnO2eQUO'#EtO2jQUO'#EvO,yQUO'#FOP2oOUO'#FfPOOO)CAY)CAYO2zQUO,58|O3iQUO'#DQOOQQ,59q,59qO(wQUO,59iOOQQ,5:T,5:TO3nQUO'#CuO3uQYO,59fO5uQUO'#FTO5zQYO,59dOOQQ,59c,59cO8QQUO,59cOOQQ'#FU'#FUO8VQUO'#DOO8bQYO'#FlO8oQUO'#DrO8tQUO,59cO,yQUO,5:XOOQQ-E9S-E9SO8{QUO,59jO9QQUO,59oO9VQUO,5;UO9[QUO,5;WO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,59tO(wQUO,5:nO(wQUO,59tO9aQUO,59tO3iQUO,5:UO9fQUO,5:qO:uQYO'#DoO;PQUO'#FtO;XQUO,5:XO;^QYO,5:[OOQQ,5:t,5:tOOQR'#Dy'#DyOOQR'#Ef'#EfO;eQUO'#FYO.jQUO,5;ROOQR,58y,58yOOQR'#FZ'#FZO<UQVO,5;XOOQR,5;X,5;XO,yQUO'#EpO>zQUO'#ErOOQR-E9O-E9OO?PQYO,59jO?[QYO,59oOOQQ,59r,59rO8oQUO,5;WOOQQ,5:j,5:jOOQQ,59_,59_OOQQ,5:v,5:vOOQQ,5:x,5:xO?gQUO,5:zO?uQYO,5;OO@SQUO,5;UO@[QYO,5;YO@fQUO,5;`O@kQUO,5;bO@[QYO,5;jPOOO,5<Q,5<QP@pOQO,5<QP@uOUO,5<QOAoQUO'#CgOOQQ1G.h1G.hOOQQ'#DS'#DSOOQQ,59l,59lOB}QYO1G/TOOQQ,59a,59aOCqQUO,59aOCvQUO'#FSOC{QYO1G/QOOQQ'#Cy'#CyOOQQ,5;o,5;oOOQQ-E9R-E9ROOQQ1G.}1G.}OE{QUO,5<WOFVQUO,5<WOFbQUO'#DtOFjQbO'#FuOFrQUO,5:^OFwQUO1G.}OF|QUO1G/sOGRQYO1G/UOG^QYO1G/ZO@SQUO1G0pO8oQUO1G0rOOQQ1G/`1G/`OI]QYO1G/`OIdQYO1G/`OK_QYO1G/`OMYQYO1G/`OMaQYO1G/`O! [QYO1G/`O! cQYO1G/`O!#ZQYO1G/`O!#eQYO1G/`O!#oQYO1G0YO!$qQYO1G/`O(wQUO1G/`OOQQ1G/p1G/pOOQQ'#EX'#EXOOQQ1G0]1G0]O,yQUO,59iO(wQUO,5:ZO!%qQUO,5<`O!%xQUO,5<`OOQQ1G/s1G/sOOQQ1G/v1G/vOOQQ,5;t,5;tOOQQ-E9W-E9WOOQR1G0m1G0mOOQR-E9X-E9XOOQR1G0s1G0sO@[QYO,5;[O!&QQUO'#DwOOQR,5;^,5;^OOQQ1G/U1G/UOOQQ1G/Z1G/ZO>zQUO1G0rOOQQ1G0f1G0fOOQR1G0p1G0pO>zQUO1G0pOOQR1G0t1G0tO,yQUO1G0zO!&XQUO1G0|OOQR1G1U1G1UPOOO1G1l1G1lP!&^OQO1G1lO!&cQUO'#FhOOQQ,59R,59RO!&kQUO,59ROOQQ1G.{1G.{OOQQ,5;n,5;nOOQQ-E9Q-E9QO!&pQYO,5;sO!&}QUO1G1rOOQQ-E9V-E9VO!'XQYO'#DVO!'jQYO'#FvO!'xQUO'#FvOOQQ,5:`,5:`O!(QQUO,5:`O3iQUO'#DvOOQQ,5<a,5<aOOQQ1G/x1G/xOOQQ7+$i7+$iOOQQ7+%_7+%_OOQQ7+$p7+$pOOQQ7+$u7+$uOOQR7+&[7+&[O>zQUO7+&[O>zQUO7+&^O(wQUO7+%tO!)QQYO7+$zO!+bQYO1G/TO!+lQYO1G/uOOQQ,5;q,5;qO!+vQUO1G1zOOQQ-E9T-E9TOOQR1G0v1G0vO!+}QVO'#DxOOQR'#D}'#D}OOQR,5:c,5:cOOQR7+&^7+&^O@[QYO7+&fO!+}QVO7+&hPOOO7+'W7+'WO!,SQUO,5<SO!,ZQUO,5<SOOQQ1G.m1G.mP(wQUO'#FXO(wQUO,5:aO!,cQUO,5<bO!,kQUO,5<bOOQQ1G/z1G/zOOQQ,5:b,5:bO!,sQYO'#EmOOQR<<Iv<<IvOOQR<<Ix<<IxO!/wQYO<<I`P,yQUO'#FVOOQQ'#D{'#D{O`QUO'#DzOOQR,5:d,5:dOOQR<<JQ<<JQO!0nQUO<<JSOOQQ,5;m,5;mO!0{QUO1G1nOOQQ-E9P-E9PO!1SQYO1G/{O!1^QYO,5;rOOQQ,5;r,5;rO!1lQUO1G1|OOQQ-E9U-E9UO!1tQYO,5;XO!3tQVO,5:fOOQQ'#E{'#E{OOQQ'#E|'#E|OOQQ'#E}'#E}OOQQ'#Ey'#EyO>zQUO'#ExOOQR'#F['#F[O!4OQVOAN?nO!4cQUO'#EzP@}QUO'#FRP!4hQUO'#FWOOQR'#D|'#D|OOQR1G0Q1G0QOOQR,5;d,5;dOOQR-E9Y-E9YOOQRG25YG25YOOQQ,5;f,5;fO!4mQYO'#CyO,yQUO'#EYO,yQUO'#DWO,yQUO,59iO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO,yQUO,59tO!4zQYO1G/TO!5UQYO1G/`O!5uQYO1G/`O!6fQYO1G/`O!7VQYO1G/`O!7vQYO1G/`O!8gQYO1G/`O!9WQYO1G/`O!;XQYO1G/`O!;cQYO1G/`O!;mQYO1G/`O,yQUO1G/`O!<^QUO'#DwOFrQUO1G0rOFrQUO1G0pOFrQUO7+&[OFrQUO7+&^O,yQUO7+%tO!>VQYO7+$zO!>vQYO7+&fO!@UQYO<<I`O!@lQYO'#C}O!@tQUO,59tOFrQUO'#ErO8oQUO,5;WO!@yQUO,5;UO!>vQYO,5;YO!>vQYO,5;jO!@yQUO1G0pO8oQUO1G0rO!ARQYO1G0YO!>vQYO,5;[O,yQUO1G0zO!AYQUO'#ElO!A_QUO'#EjO,yQUO'#EnO,yQUO'#FOO!AdQUO,5;UO!AiQUO,5;WO(wQUO,5:nO,yQUO'#EpO!AnQUO,5;`O!AsQUO'#DOO!BUQUO'#Et\",\n  stateData: \"!Bq~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$g!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$aX$g$aXf$aXj$aXu$aXX$aX!x$aX!`$aX~Oo!XO~P&vOVSOWUOYaO]RO^RO_ROamObmOcmOdmOpYOsnOxoO{pO!ZcO!b`O!g!`O!srO!ubO!}cO$]RO$^RO$_QO$bVO$cVO~Oj!ZO~P(wOY!VOp!aO!b!bO~P&vOVSOs!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$g!TO~O#[SX$SSX$VSX~P+_OVSOW&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$l#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(wO$d#rOona}na!Ona!Pna!Qna!Rna!Sna!Tna!Una!Vna!Wna!Xna!Yna!Zna![na!_na!wna!zna#[na$Sna$Vna$fna$gnafnajnaunaXna!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$fla$glaflajlaulaXla!xla!`la~Oj#wO~OVSOs!dOx!eO~Of#xOj$`XX$`X~P+_OY#zO~Oj#wO~P(wOW$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$f&zO~Ou$fO$g$eO~P9kOf$gO!`$hX~O!`$iO~OX$jO~P+_OhsO#PtO#RuO#TvO#VwO#XxO#[#|X$S#|X$V#|X~P(wO#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$l#aa~Ou$qO~Ou!RO$fra$gra~Ou!RO$fwa$gwa~OY!VO#[#Sa$S#Sa$V#Sa~O#[#Wa$S#Wa$V#Wa~P+_Ou$qO#RuO~Ou$qO$g&zO~P9kO![$zO~Ou${O~O$S$}O~OP%OO$S$}O~O]RO^RO_ROamObmOcmOdmO$]RO$^RO$_QO~OX%QO~P@}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~O#[qi$Sqi$Vqi$fqi$gqifqijqiXqi!xqi!`qi~PAvOX%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$fni$gnifnijniuniXni!xni!`ni~Oj$`aX$`a~P(wOf%WOj$`aX$`a~OW%YOX%]O~O$k%_Ou$iX~Ou'dO~Oj%bO~O!`%cO~Ou!RO$fri$gri~Ou!RO$fwi$gwi~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|i$g|if|ij|iX|i!x|i!`|i~O!O|i~PGiO!O!iO~PGiO}!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|i$g|if|ij|iX|i!x|i!`|i~O!Q|i~PIkO}!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|i$g|if|ij|iX|i!x|i!`|i~O!S!mO~PKfO!S|i~PKfO}!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|i$g|if|ij|iX|i!x|i!`|i~O!U!oO~PMhO!Q!kO~PIkO}!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|i$g|if|ij|iX|i!x|i!`|i~O!V|i!W|i~P! jO!V!pO!W!pO~P! jO!x%iO~P+_O!V|i!W|i!X|i!Y|i!Z|i![|i!_|i!w|i!z|i$f|i$g|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!#vO!`$ha~P,yOf%nO!`$ha~O$S!|O~P`O$S!|O~O$S%wO~Of%xOX$[X~OX%zO~Of#{aj#{aX#{a~P+_Oj$`iX$`i~P(wOu!ROXyXfyX$fyX$gyX~Of%}O$f%|O$g%|OX$jX~Of%}OX$jX~OX&PO~O!V|q!W|q!X|q!Y|q!Z|q![|q!_|q!w|q!z|q$f|q$g|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!(VO}&{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!vOuqi$fqi$gqi~Of!ci!`!ci~P!*QOf!ci!`!ci~P+_O!`$hi~P,yO$Q&WO~OX$[a~P@}Of&^OX$[a~OW%YOX$ja~Of&cOX$ja~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#aX$g#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!vy$g!vyf!vyj!vyX!vy!x!vy!`!vy~P!.sOW&gOs&nO$l&iO~P@}OX$[i~P@}OX!iif!ii~P+_O$f%|O$g%|OX#zaf#za~OW%YOX$ji~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#aa$g#aau#aaX#aa#[#aa$S#aa$V#aa!x#aa!`#aa~O$R&qO$V&rO~P`OW&gOs&nO$R&qO$V!}O$l&iO~P@}OW&vO~OW%YO~O$f&zO$g&zOu!eX~P$hOfqi!`qi~P!*QO}&{Ou|i!O|i!P|i!Q|i!R|i!S|i!T|i!U|i~P!#vO}&{O!O&|Ou|i!P|i!Q|i!R|i!S|i!T|i!U|i~P!#vO}&{O!O&|O!P&}Ou|i!Q|i!R|i!S|i!T|i!U|i~P!#vO}&{O!O&|O!P&}O!Q'OO!S'QO!T'RO!U'SOu|i!R|i~P!#vO}&{O!O&|O!P&}O!Q'OO!T'RO!U'SOu|i!R|i!S|i~P!#vO}&{O!O&|O!P&}O!Q'OO!U'SOu|i!R|i!S|i!T|i~P!#vO}&{O!O&|O!P&}O!Q'OOu|i!R|i!S|i!T|i!U|i~P!#vO}&{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|i$g|if|i!`|i~O!V|i!W|i~P!9wO!V'TO!W'TO~P!9wO}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SOu|i~P!#vOVSOWUOYaOhsOpYOsnOxoO{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@}O}&{O!O&|O!P&}O!Q'OO!R'PO!S'QO!T'RO!U'SOu|q~P!(VOu'dO$g&zO~P9kO}&{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!vy$g!vyf!vy!`!vy~P!?QO$f&zO$g&zO~O!['cO~Ou'dO#RuO~O!x'iO~P+_OW'pO~OW'qO~OW'tO~OW'uO~O!['xO~OVSOs!dOx!eO!g(OO#_'}O~OW(RO~O$^$]]!V!X!Z^_$_!uW$du!}o$l}!O!P!x!w~\",\n  goto: \"Ac$kPPP$l$t%P%YPPPP&t&wPPP(jPPPP(jP%PP*VP*e+z-a.yPP*e0`P1uP2W0`P2a*eP*ePPPPPPPPPPPPPP*e*ePP*eP4O*e*e*eP4X4`4h4k5m5q6O6R6X5m*eP*eP*ePP*eP6_*eP%PP6bP%PP%PP%PP6w7QP$l7YP7Y7Y7bP7lP7rP7YP7YP7z8O8S8S8S8S7YP8W8b8h8n8u:e:k:r:x;O;YPPPPPPPPP;`;c;mPPP;p;yPPP?bPP@yAPA`]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: 166,\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: \"Ae~R|XY#{pq#{qr$Wrs$est(Vtu(quv(vvw)Vwx)jxy-[yz-az{-f{|-y|}.T}!O.Y!O!P.l!P!Q/w!Q!R0R!R![0s![!]2e!]!^2l!^!_2q!_!`3U!`!a3^!a!b3z!b!c4S!c!}4X!}#O4j#P#Q4o#Q#R4t#R#S4|#T#U5a#U#Y4X#Y#Z6t#Z#b4X#b#c9U#c#d<S#d#g4X#g#h=O#h#i>z#i#o4X#o#p@v#p#q@{#q#rA`~$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(}P$cP!OQ!_!`)QQ)VO$fQ~)[Q!U~vw)b!_!`)Q~)gP!W~!_!`)Q~)mXOY)jZ])j^w)jwx*Yx#O)j#O#P*z#P;'S)j;'S;=`-U<%lO)j~*_X$_~OY)jZ])j^w)jwx*Yx#O)j#O#P*z#P;'S)j;'S;=`-U<%lO)j~*}VO#i)j#i#j+d#j#l)j#l#m,P#m;'S)j;'S;=`-U<%lO)j~+gS!Q![+s!c!i+s#T#Z+s#o#p,i~+vR!Q![,P!c!i,P#T#Z,P~,SR!Q![,]!c!i,]#T#Z,]~,`R!Q![)j!c!i)j#T#Z)j~,lR!Q![,u!c!i,u#T#Z,u~,xS!Q![,u!c!i,u#T#Z,u#q#r)j~-XP;=`<%l)j~-aOY~~-fOX~~-kQ!OQz{-q!_!`)Q~-vP}~!_!`)QR.QP!}P!PQ!_!`)Q~.YOf~V.aQ!}P!PQ!_!`)Q!`!a.gS.lO$kS~.qPo~!Q![.t~.yS$^~!Q![.t!g!h/V#R#S/q#X#Y/V~/YQ{|/`}!O/`~/cP!Q![/f~/kQ$^~!Q![/f#R#S/`~/tP!Q![.t~0OP$d~!OQ!_!`)Q~0WX$]~!O!P/q!Q![0s!d!e1_!g!h/V!z!{1v#R#S1X#U#V1_#X#Y/V#l#m1v~0xT$]~!O!P/q!Q![0s!g!h/V#R#S1X#X#Y/V~1[P!Q![0s~1bQ!Q!R1h!R!S1h~1mR$]~!Q!R1h!R!S1h#R#S1_~1yR!Q![2S!c!i2S#T#Z2S~2XS$]~!Q![2S!c!i2S#R#S1v#T#Z2S~2lOu~!x~~2qO#[~~2vQ!RQ!^!_2|!_!`$`~3RP!Q~!_!`)Q~3ZP$g~!_!`$`~3cQ!RQ!_!`$`!`!a3i~3nQ!Q~!_!`)Q!`!a3tQ3wP!_!`)Q~4PP!w~!a!b3t~4XOV~~4^SW~!Q![4X!c!}4X#R#S4X#T#o4X~4oOp~~4tOj~~4yP!T~!_!`)Q~5TSW~$l~!Q![4X!c!}4X#R#S4X#T#o4X~5fUW~!Q![4X!c!}4X#R#S4X#T#b4X#b#c5x#c#o4X~5}UW~!Q![4X!c!}4X#R#S4X#T#W4X#W#X6a#X#o4X~6hS!V~W~!Q![4X!c!}4X#R#S4X#T#o4X~6yTW~!Q![4X!c!}4X#R#S4X#T#U7Y#U#o4X~7_UW~!Q![4X!c!}4X#R#S4X#T#`4X#`#a7q#a#o4X~7vUW~!Q![4X!c!}4X#R#S4X#T#g4X#g#h8Y#h#o4X~8_UW~!Q![4X!c!}4X#R#S4X#T#X4X#X#Y8q#Y#o4X~8xS^~W~!Q![4X!c!}4X#R#S4X#T#o4X~9ZWW~!Q![4X!c!}4X#R#S4X#T#c4X#c#d9s#d#i4X#i#j:o#j#o4X~9xUW~!Q![4X!c!}4X#R#S4X#T#h4X#h#i:[#i#o4X~:cS!Z~W~!Q![4X!c!}4X#R#S4X#T#o4X~:tUW~!Q![4X!c!}4X#R#S4X#T#`4X#`#a;W#a#o4X~;]UW~!Q![4X!c!}4X#R#S4X#T#`4X#`#a;o#a#o4X~;vS_~W~!Q![4X!c!}4X#R#S4X#T#o4X~<XUW~!Q![4X!c!}4X#R#S4X#T#f4X#f#g<k#g#o4X~<rS!X~W~!Q![4X!c!}4X#R#S4X#T#o4X~=TUW~!Q![4X!c!}4X#R#S4X#T#X4X#X#Y=g#Y#o4X~=lUW~!Q![4X!c!}4X#R#S4X#T#`4X#`#a>O#a#o4X~>TUW~!Q![4X!c!}4X#R#S4X#T#Y4X#Y#Z>g#Z#o4X~>nS!u~W~!Q![4X!c!}4X#R#S4X#T#o4X~?PUW~!Q![4X!c!}4X#R#S4X#T#f4X#f#g?c#g#o4X~?hUW~!Q![4X!c!}4X#R#S4X#T#i4X#i#j?z#j#o4X~@PUW~!Q![4X!c!}4X#R#S4X#T#X4X#X#Y@c#Y#o4X~@jS]~W~!Q![4X!c!}4X#R#S4X#T#o4X~@{O!b~~AQQ!S~!_!`)Q#p#qAW~A]P!Y~!_!`)Q~AeO!`~\",\n  tokenizers: [indentation, newlines, 0, 1, 2],\n  topRules: {\"Script\":[0,2]},\n  specialized: [{term: 8, get: value => spec_Identifier[value] || -1}],\n  tokenPrec: 3645\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 this._tree.type; }\n    get name() { return this._tree.type.name; }\n    get to() { return this.from + this._tree.length; }\n    nextChild(i, dir, pos, side, mode = 0) {\n        for (let parent = this;;) {\n            for (let { children, positions } = parent._tree, e = dir > 0 ? children.length : -1; i != e; i += dir) {\n                let next = children[i], start = positions[i] + parent.from;\n                if (!checkSide(side, pos, start, start + next.length))\n                    continue;\n                if (next instanceof TreeBuffer) {\n                    if (mode & IterMode.ExcludeBuffers)\n                        continue;\n                    let index = next.findChild(0, next.buffer.length, dir, pos - start, side);\n                    if (index > -1)\n                        return new BufferNode(new BufferContext(parent, next, i, start), null, index);\n                }\n                else if ((mode & IterMode.IncludeAnonymous) || (!next.type.isAnonymous || hasChild(next))) {\n                    let mounted;\n                    if (!(mode & IterMode.IgnoreMounts) &&\n                        next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)\n                        return new TreeNode(mounted.tree, start, i, parent);\n                    let inner = new TreeNode(next, start, i, parent);\n                    return (mode & IterMode.IncludeAnonymous) || !inner.type.isAnonymous ? inner\n                        : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);\n                }\n            }\n            if ((mode & IterMode.IncludeAnonymous) || !parent.type.isAnonymous)\n                return null;\n            if (parent.index >= 0)\n                i = parent.index + dir;\n            else\n                i = dir < 0 ? -1 : parent._parent._tree.children.length;\n            parent = parent._parent;\n            if (!parent)\n                return null;\n        }\n    }\n    get firstChild() { return this.nextChild(0, 1, 0, 4 /* Side.DontCare */); }\n    get lastChild() { return this.nextChild(this._tree.children.length - 1, -1, 0, 4 /* Side.DontCare */); }\n    childAfter(pos) { return this.nextChild(0, 1, pos, 2 /* Side.After */); }\n    childBefore(pos) { return this.nextChild(this._tree.children.length - 1, -1, pos, -2 /* Side.Before */); }\n    enter(pos, side, mode = 0) {\n        let mounted;\n        if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {\n            let rPos = pos - this.from;\n            for (let { from, to } of mounted.overlay) {\n                if ((side > 0 ? from <= rPos : from < rPos) &&\n                    (side < 0 ? to >= rPos : to > rPos))\n                    return new TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);\n            }\n        }\n        return this.nextChild(0, 1, pos, side, mode);\n    }\n    nextSignificantParent() {\n        let val = this;\n        while (val.type.isAnonymous && val._parent)\n            val = val._parent;\n        return val;\n    }\n    get parent() {\n        return this._parent ? this._parent.nextSignificantParent() : null;\n    }\n    get nextSibling() {\n        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index + 1, 1, 0, 4 /* Side.DontCare */) : null;\n    }\n    get prevSibling() {\n        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4 /* Side.DontCare */) : null;\n    }\n    cursor(mode = 0) { return new TreeCursor(this, mode); }\n    get tree() { return this._tree; }\n    toTree() { return this._tree; }\n    resolve(pos, side = 0) {\n        return resolveNode(this, pos, side, false);\n    }\n    resolveInner(pos, side = 0) {\n        return resolveNode(this, pos, side, true);\n    }\n    enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }\n    getChild(type, before = null, after = null) {\n        let r = getChildren(this, type, before, after);\n        return r.length ? r[0] : null;\n    }\n    getChildren(type, before = null, after = null) {\n        return getChildren(this, type, before, after);\n    }\n    /// @internal\n    toString() { return this._tree.toString(); }\n    get node() { return this; }\n    matchContext(context) { return matchNodeContext(this, context); }\n}\nfunction getChildren(node, type, before, after) {\n    let cur = node.cursor(), result = [];\n    if (!cur.firstChild())\n        return result;\n    if (before != null)\n        while (!cur.type.is(before))\n            if (!cur.nextSibling())\n                return result;\n    for (;;) {\n        if (after != null && cur.type.is(after))\n            return result;\n        if (cur.type.is(type))\n            result.push(cur.node);\n        if (!cur.nextSibling())\n            return after == null ? result : [];\n    }\n}\nfunction matchNodeContext(node, context, i = context.length - 1) {\n    for (let p = node.parent; i >= 0; p = p.parent) {\n        if (!p)\n            return false;\n        if (!p.type.isAnonymous) {\n            if (context[i] && context[i] != p.name)\n                return false;\n            i--;\n        }\n    }\n    return true;\n}\nclass BufferContext {\n    constructor(parent, buffer, index, start) {\n        this.parent = parent;\n        this.buffer = buffer;\n        this.index = index;\n        this.start = start;\n    }\n}\nclass BufferNode {\n    get name() { return this.type.name; }\n    get from() { return this.context.start + this.context.buffer.buffer[this.index + 1]; }\n    get to() { return this.context.start + this.context.buffer.buffer[this.index + 2]; }\n    constructor(context, _parent, index) {\n        this.context = context;\n        this._parent = _parent;\n        this.index = index;\n        this.type = context.buffer.set.types[context.buffer.buffer[index]];\n    }\n    child(dir, pos, side) {\n        let { buffer } = this.context;\n        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.context.start, side);\n        return index < 0 ? null : new BufferNode(this.context, this, index);\n    }\n    get firstChild() { return this.child(1, 0, 4 /* Side.DontCare */); }\n    get lastChild() { return this.child(-1, 0, 4 /* Side.DontCare */); }\n    childAfter(pos) { return this.child(1, pos, 2 /* Side.After */); }\n    childBefore(pos) { return this.child(-1, pos, -2 /* Side.Before */); }\n    enter(pos, side, mode = 0) {\n        if (mode & IterMode.ExcludeBuffers)\n            return null;\n        let { buffer } = this.context;\n        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);\n        return index < 0 ? null : new BufferNode(this.context, this, index);\n    }\n    get parent() {\n        return this._parent || this.context.parent.nextSignificantParent();\n    }\n    externalSibling(dir) {\n        return this._parent ? null : this.context.parent.nextChild(this.context.index + dir, dir, 0, 4 /* Side.DontCare */);\n    }\n    get nextSibling() {\n        let { buffer } = this.context;\n        let after = buffer.buffer[this.index + 3];\n        if (after < (this._parent ? buffer.buffer[this._parent.index + 3] : buffer.buffer.length))\n            return new BufferNode(this.context, this._parent, after);\n        return this.externalSibling(1);\n    }\n    get prevSibling() {\n        let { buffer } = this.context;\n        let parentStart = this._parent ? this._parent.index + 4 : 0;\n        if (this.index == parentStart)\n            return this.externalSibling(-1);\n        return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* Side.DontCare */));\n    }\n    cursor(mode = 0) { return new TreeCursor(this, mode); }\n    get tree() { return null; }\n    toTree() {\n        let children = [], positions = [];\n        let { buffer } = this.context;\n        let startI = this.index + 4, endI = buffer.buffer[this.index + 3];\n        if (endI > startI) {\n            let from = buffer.buffer[this.index + 1];\n            children.push(buffer.slice(startI, endI, from));\n            positions.push(0);\n        }\n        return new Tree(this.type, children, positions, this.to - this.from);\n    }\n    resolve(pos, side = 0) {\n        return resolveNode(this, pos, side, false);\n    }\n    resolveInner(pos, side = 0) {\n        return resolveNode(this, pos, side, true);\n    }\n    enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }\n    /// @internal\n    toString() { return this.context.buffer.childString(this.index); }\n    getChild(type, before = null, after = null) {\n        let r = getChildren(this, type, before, after);\n        return r.length ? r[0] : null;\n    }\n    getChildren(type, before = null, after = null) {\n        return getChildren(this, type, before, after);\n    }\n    get node() { return this; }\n    matchContext(context) { return matchNodeContext(this, context); }\n}\n/// A tree cursor object focuses on a given node in a syntax tree, and\n/// allows you to move to adjacent nodes.\nclass TreeCursor {\n    /// Shorthand for `.type.name`.\n    get name() { return this.type.name; }\n    /// @internal\n    constructor(node, \n    /// @internal\n    mode = 0) {\n        this.mode = mode;\n        /// @internal\n        this.buffer = null;\n        this.stack = [];\n        /// @internal\n        this.index = 0;\n        this.bufferNode = null;\n        if (node instanceof TreeNode) {\n            this.yieldNode(node);\n        }\n        else {\n            this._tree = node.context.parent;\n            this.buffer = node.context;\n            for (let n = node._parent; n; n = n._parent)\n                this.stack.unshift(n.index);\n            this.bufferNode = node;\n            this.yieldBuf(node.index);\n        }\n    }\n    yieldNode(node) {\n        if (!node)\n            return false;\n        this._tree = node;\n        this.type = node.type;\n        this.from = node.from;\n        this.to = node.to;\n        return true;\n    }\n    yieldBuf(index, type) {\n        this.index = index;\n        let { start, buffer } = this.buffer;\n        this.type = type || buffer.set.types[buffer.buffer[index]];\n        this.from = start + buffer.buffer[index + 1];\n        this.to = start + buffer.buffer[index + 2];\n        return true;\n    }\n    yield(node) {\n        if (!node)\n            return false;\n        if (node instanceof TreeNode) {\n            this.buffer = null;\n            return this.yieldNode(node);\n        }\n        this.buffer = node.context;\n        return this.yieldBuf(node.index, node.type);\n    }\n    /// @internal\n    toString() {\n        return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();\n    }\n    /// @internal\n    enterChild(dir, pos, side) {\n        if (!this.buffer)\n            return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode));\n        let { buffer } = this.buffer;\n        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);\n        if (index < 0)\n            return false;\n        this.stack.push(this.index);\n        return this.yieldBuf(index);\n    }\n    /// Move the cursor to this node's first child. When this returns\n    /// false, the node has no child, and the cursor has not been moved.\n    firstChild() { return this.enterChild(1, 0, 4 /* Side.DontCare */); }\n    /// Move the cursor to this node's last child.\n    lastChild() { return this.enterChild(-1, 0, 4 /* Side.DontCare */); }\n    /// Move the cursor to the first child that ends after `pos`.\n    childAfter(pos) { return this.enterChild(1, pos, 2 /* Side.After */); }\n    /// Move to the last child that starts before `pos`.\n    childBefore(pos) { return this.enterChild(-1, pos, -2 /* Side.Before */); }\n    /// Move the cursor to the child around `pos`. If side is -1 the\n    /// child may end at that position, when 1 it may start there. This\n    /// will also enter [overlaid](#common.MountedTree.overlay)\n    /// [mounted](#common.NodeProp^mounted) trees unless `overlays` is\n    /// set to false.\n    enter(pos, side, mode = this.mode) {\n        if (!this.buffer)\n            return this.yield(this._tree.enter(pos, side, mode));\n        return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);\n    }\n    /// Move to the node's parent node, if this isn't the top node.\n    parent() {\n        if (!this.buffer)\n            return this.yieldNode((this.mode & IterMode.IncludeAnonymous) ? this._tree._parent : this._tree.parent);\n        if (this.stack.length)\n            return this.yieldBuf(this.stack.pop());\n        let parent = (this.mode & IterMode.IncludeAnonymous) ? this.buffer.parent : this.buffer.parent.nextSignificantParent();\n        this.buffer = null;\n        return this.yieldNode(parent);\n    }\n    /// @internal\n    sibling(dir) {\n        if (!this.buffer)\n            return !this._tree._parent ? false\n                : this.yield(this._tree.index < 0 ? null\n                    : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4 /* Side.DontCare */, this.mode));\n        let { buffer } = this.buffer, d = this.stack.length - 1;\n        if (dir < 0) {\n            let parentStart = d < 0 ? 0 : this.stack[d] + 4;\n            if (this.index != parentStart)\n                return this.yieldBuf(buffer.findChild(parentStart, this.index, -1, 0, 4 /* Side.DontCare */));\n        }\n        else {\n            let after = buffer.buffer[this.index + 3];\n            if (after < (d < 0 ? buffer.buffer.length : buffer.buffer[this.stack[d] + 3]))\n                return this.yieldBuf(after);\n        }\n        return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4 /* Side.DontCare */, this.mode)) : false;\n    }\n    /// Move to this node's next sibling, if any.\n    nextSibling() { return this.sibling(1); }\n    /// Move to this node's previous sibling, if any.\n    prevSibling() { return this.sibling(-1); }\n    atLastNode(dir) {\n        let index, parent, { buffer } = this;\n        if (buffer) {\n            if (dir > 0) {\n                if (this.index < buffer.buffer.buffer.length)\n                    return false;\n            }\n            else {\n                for (let i = 0; i < this.index; i++)\n                    if (buffer.buffer.buffer[i + 3] < this.index)\n                        return false;\n            }\n            ({ index, parent } = buffer);\n        }\n        else {\n            ({ index, _parent: parent } = this._tree);\n        }\n        for (; parent; { index, _parent: parent } = parent) {\n            if (index > -1)\n                for (let i = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i != e; i += dir) {\n                    let child = parent._tree.children[i];\n                    if ((this.mode & IterMode.IncludeAnonymous) ||\n                        child instanceof TreeBuffer ||\n                        !child.type.isAnonymous ||\n                        hasChild(child))\n                        return false;\n                }\n        }\n        return true;\n    }\n    move(dir, enter) {\n        if (enter && this.enterChild(dir, 0, 4 /* Side.DontCare */))\n            return true;\n        for (;;) {\n            if (this.sibling(dir))\n                return true;\n            if (this.atLastNode(dir) || !this.parent())\n                return false;\n        }\n    }\n    /// Move to the next node in a\n    /// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)\n    /// traversal, going from a node to its first child or, if the\n    /// current node is empty or `enter` is false, its next sibling or\n    /// the next sibling of the first parent node that has one.\n    next(enter = true) { return this.move(1, enter); }\n    /// Move to the next node in a last-to-first pre-order traveral. A\n    /// node is followed by its last child or, if it has none, its\n    /// previous sibling or the previous sibling of the first parent\n    /// node that has one.\n    prev(enter = true) { return this.move(-1, enter); }\n    /// Move the cursor to the innermost node that covers `pos`. If\n    /// `side` is -1, it will enter nodes that end at `pos`. If it is 1,\n    /// it will enter nodes that start at `pos`.\n    moveTo(pos, side = 0) {\n        // Move up to a node that actually holds the position, if possible\n        while (this.from == this.to ||\n            (side < 1 ? this.from >= pos : this.from > pos) ||\n            (side > -1 ? this.to <= pos : this.to < pos))\n            if (!this.parent())\n                break;\n        // Then scan down into child nodes as far as possible\n        while (this.enterChild(1, pos, side)) { }\n        return this;\n    }\n    /// Get a [syntax node](#common.SyntaxNode) at the cursor's current\n    /// position.\n    get node() {\n        if (!this.buffer)\n            return this._tree;\n        let cache = this.bufferNode, result = null, depth = 0;\n        if (cache && cache.context == this.buffer) {\n            scan: for (let index = this.index, d = this.stack.length; d >= 0;) {\n                for (let c = cache; c; c = c._parent)\n                    if (c.index == index) {\n                        if (index == this.index)\n                            return c;\n                        result = c;\n                        depth = d + 1;\n                        break scan;\n                    }\n                index = this.stack[--d];\n            }\n        }\n        for (let i = depth; i < this.stack.length; i++)\n            result = new BufferNode(this.buffer, result, this.stack[i]);\n        return this.bufferNode = new BufferNode(this.buffer, result, this.index);\n    }\n    /// Get the [tree](#common.Tree) that represents the current node, if\n    /// any. Will return null when the node is in a [tree\n    /// buffer](#common.TreeBuffer).\n    get tree() {\n        return this.buffer ? null : this._tree._tree;\n    }\n    /// Iterate over the current node and all its descendants, calling\n    /// `enter` when entering a node and `leave`, if given, when leaving\n    /// one. When `enter` returns `false`, any children of that node are\n    /// skipped, and `leave` isn't called for it.\n    iterate(enter, leave) {\n        for (let depth = 0;;) {\n            let mustLeave = false;\n            if (this.type.isAnonymous || enter(this) !== false) {\n                if (this.firstChild()) {\n                    depth++;\n                    continue;\n                }\n                if (!this.type.isAnonymous)\n                    mustLeave = true;\n            }\n            for (;;) {\n                if (mustLeave && leave)\n                    leave(this);\n                mustLeave = this.type.isAnonymous;\n                if (this.nextSibling())\n                    break;\n                if (!depth)\n                    return;\n                this.parent();\n                depth--;\n                mustLeave = true;\n            }\n        }\n    }\n    /// Test whether the current node matches a given context\u2014a sequence\n    /// of direct parent node names. Empty strings in the context array\n    /// are treated as wildcards.\n    matchContext(context) {\n        if (!this.buffer)\n            return matchNodeContext(this.node, context);\n        let { buffer } = this.buffer, { types } = buffer.set;\n        for (let i = context.length - 1, d = this.stack.length - 1; i >= 0; d--) {\n            if (d < 0)\n                return matchNodeContext(this.node, context, i);\n            let type = types[buffer.buffer[this.stack[d]]];\n            if (!type.isAnonymous) {\n                if (context[i] && context[i] != type.name)\n                    return false;\n                i--;\n            }\n        }\n        return true;\n    }\n}\nfunction hasChild(tree) {\n    return tree.children.some(ch => ch instanceof TreeBuffer || !ch.type.isAnonymous || hasChild(ch));\n}\nfunction buildTree(data) {\n    var _a;\n    let { buffer, nodeSet, maxBufferLength = DefaultBufferLength, reused = [], minRepeatType = nodeSet.types.length } = data;\n    let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;\n    let types = nodeSet.types;\n    let contextHash = 0, lookAhead = 0;\n    function takeNode(parentStart, minPos, children, positions, inRepeat) {\n        let { id, start, end, size } = cursor;\n        let lookAheadAtStart = lookAhead;\n        while (size < 0) {\n            cursor.next();\n            if (size == -1 /* SpecialRecord.Reuse */) {\n                let node = reused[id];\n                children.push(node);\n                positions.push(start - parentStart);\n                return;\n            }\n            else if (size == -3 /* SpecialRecord.ContextChange */) { // Context change\n                contextHash = id;\n                return;\n            }\n            else if (size == -4 /* SpecialRecord.LookAhead */) {\n                lookAhead = id;\n                return;\n            }\n            else {\n                throw new RangeError(`Unrecognized record size: ${size}`);\n            }\n        }\n        let type = types[id], node, buffer;\n        let startPos = start - parentStart;\n        if (end - start <= maxBufferLength && (buffer = findBufferSize(cursor.pos - minPos, inRepeat))) {\n            // Small enough for a buffer, and no reused nodes inside\n            let data = new Uint16Array(buffer.size - buffer.skip);\n            let endPos = cursor.pos - buffer.size, index = data.length;\n            while (cursor.pos > endPos)\n                index = copyToBuffer(buffer.start, data, index);\n            node = new TreeBuffer(data, end - buffer.start, nodeSet);\n            startPos = buffer.start - parentStart;\n        }\n        else { // Make it a node\n            let endPos = cursor.pos - size;\n            cursor.next();\n            let localChildren = [], localPositions = [];\n            let localInRepeat = id >= minRepeatType ? id : -1;\n            let lastGroup = 0, lastEnd = end;\n            while (cursor.pos > endPos) {\n                if (localInRepeat >= 0 && cursor.id == localInRepeat && cursor.size >= 0) {\n                    if (cursor.end <= lastEnd - maxBufferLength) {\n                        makeRepeatLeaf(localChildren, localPositions, start, lastGroup, cursor.end, lastEnd, localInRepeat, lookAheadAtStart);\n                        lastGroup = localChildren.length;\n                        lastEnd = cursor.end;\n                    }\n                    cursor.next();\n                }\n                else {\n                    takeNode(start, endPos, localChildren, localPositions, localInRepeat);\n                }\n            }\n            if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)\n                makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart);\n            localChildren.reverse();\n            localPositions.reverse();\n            if (localInRepeat > -1 && lastGroup > 0) {\n                let make = makeBalanced(type);\n                node = balanceRange(type, localChildren, localPositions, 0, localChildren.length, 0, end - start, make, make);\n            }\n            else {\n                node = makeTree(type, localChildren, localPositions, end - start, lookAheadAtStart - end);\n            }\n        }\n        children.push(node);\n        positions.push(startPos);\n    }\n    function makeBalanced(type) {\n        return (children, positions, length) => {\n            let lookAhead = 0, lastI = children.length - 1, last, lookAheadProp;\n            if (lastI >= 0 && (last = children[lastI]) instanceof Tree) {\n                if (!lastI && last.type == type && last.length == length)\n                    return last;\n                if (lookAheadProp = last.prop(NodeProp.lookAhead))\n                    lookAhead = positions[lastI] + last.length + lookAheadProp;\n            }\n            return makeTree(type, children, positions, length, lookAhead);\n        };\n    }\n    function makeRepeatLeaf(children, positions, base, i, from, to, type, lookAhead) {\n        let localChildren = [], localPositions = [];\n        while (children.length > i) {\n            localChildren.push(children.pop());\n            localPositions.push(positions.pop() + base - from);\n        }\n        children.push(makeTree(nodeSet.types[type], localChildren, localPositions, to - from, lookAhead - to));\n        positions.push(from - base);\n    }\n    function makeTree(type, children, positions, length, lookAhead = 0, props) {\n        if (contextHash) {\n            let pair = [NodeProp.contextHash, contextHash];\n            props = props ? [pair].concat(props) : [pair];\n        }\n        if (lookAhead > 25) {\n            let pair = [NodeProp.lookAhead, lookAhead];\n            props = props ? [pair].concat(props) : [pair];\n        }\n        return new Tree(type, children, positions, length, props);\n    }\n    function findBufferSize(maxSize, inRepeat) {\n        // Scan through the buffer to find previous siblings that fit\n        // together in a TreeBuffer, and don't contain any reused nodes\n        // (which can't be stored in a buffer).\n        // If `inRepeat` is > -1, ignore node boundaries of that type for\n        // nesting, but make sure the end falls either at the start\n        // (`maxSize`) or before such a node.\n        let fork = cursor.fork();\n        let size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength;\n        let result = { size: 0, start: 0, skip: 0 };\n        scan: for (let minPos = fork.pos - maxSize; fork.pos > minPos;) {\n            let nodeSize = fork.size;\n            // Pretend nested repeat nodes of the same type don't exist\n            if (fork.id == inRepeat && nodeSize >= 0) {\n                // Except that we store the current state as a valid return\n                // value.\n                result.size = size;\n                result.start = start;\n                result.skip = skip;\n                skip += 4;\n                size += 4;\n                fork.next();\n                continue;\n            }\n            let startPos = fork.pos - nodeSize;\n            if (nodeSize < 0 || startPos < minPos || fork.start < minStart)\n                break;\n            let localSkipped = fork.id >= minRepeatType ? 4 : 0;\n            let nodeStart = fork.start;\n            fork.next();\n            while (fork.pos > startPos) {\n                if (fork.size < 0) {\n                    if (fork.size == -3 /* SpecialRecord.ContextChange */)\n                        localSkipped += 4;\n                    else\n                        break scan;\n                }\n                else if (fork.id >= minRepeatType) {\n                    localSkipped += 4;\n                }\n                fork.next();\n            }\n            start = nodeStart;\n            size += nodeSize;\n            skip += localSkipped;\n        }\n        if (inRepeat < 0 || size == maxSize) {\n            result.size = size;\n            result.start = start;\n            result.skip = skip;\n        }\n        return result.size > 4 ? result : undefined;\n    }\n    function copyToBuffer(bufferStart, buffer, index) {\n        let { id, start, end, size } = cursor;\n        cursor.next();\n        if (size >= 0 && id < minRepeatType) {\n            let startIndex = index;\n            if (size > 4) {\n                let endPos = cursor.pos - (size - 4);\n                while (cursor.pos > endPos)\n                    index = copyToBuffer(bufferStart, buffer, index);\n            }\n            buffer[--index] = startIndex;\n            buffer[--index] = end - bufferStart;\n            buffer[--index] = start - bufferStart;\n            buffer[--index] = id;\n        }\n        else if (size == -3 /* SpecialRecord.ContextChange */) {\n            contextHash = id;\n        }\n        else if (size == -4 /* SpecialRecord.LookAhead */) {\n            lookAhead = id;\n        }\n        return index;\n    }\n    let children = [], positions = [];\n    while (cursor.pos > 0)\n        takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);\n    let length = (_a = data.length) !== null && _a !== void 0 ? _a : (children.length ? positions[0] + children[0].length : 0);\n    return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);\n}\nconst nodeSizeCache = new WeakMap;\nfunction nodeSize(balanceType, node) {\n    if (!balanceType.isAnonymous || node instanceof TreeBuffer || node.type != balanceType)\n        return 1;\n    let size = nodeSizeCache.get(node);\n    if (size == null) {\n        size = 1;\n        for (let child of node.children) {\n            if (child.type != balanceType || !(child instanceof Tree)) {\n                size = 1;\n                break;\n            }\n            size += nodeSize(balanceType, child);\n        }\n        nodeSizeCache.set(node, size);\n    }\n    return size;\n}\nfunction balanceRange(\n// The type the balanced tree's inner nodes.\nbalanceType, \n// The direct children and their positions\nchildren, positions, \n// The index range in children/positions to use\nfrom, to, \n// The start position of the nodes, relative to their parent.\nstart, \n// Length of the outer node\nlength, \n// Function to build the top node of the balanced tree\nmkTop, \n// Function to build internal nodes for the balanced tree\nmkTree) {\n    let total = 0;\n    for (let i = from; i < to; i++)\n        total += nodeSize(balanceType, children[i]);\n    let maxChild = Math.ceil((total * 1.5) / 8 /* Balance.BranchFactor */);\n    let localChildren = [], localPositions = [];\n    function divide(children, positions, from, to, offset) {\n        for (let i = from; i < to;) {\n            let groupFrom = i, groupStart = positions[i], groupSize = nodeSize(balanceType, children[i]);\n            i++;\n            for (; i < to; i++) {\n                let nextSize = nodeSize(balanceType, children[i]);\n                if (groupSize + nextSize >= maxChild)\n                    break;\n                groupSize += nextSize;\n            }\n            if (i == groupFrom + 1) {\n                if (groupSize > maxChild) {\n                    let only = children[groupFrom]; // Only trees can have a size > 1\n                    divide(only.children, only.positions, 0, only.children.length, positions[groupFrom] + offset);\n                    continue;\n                }\n                localChildren.push(children[groupFrom]);\n            }\n            else {\n                let length = positions[i - 1] + children[i - 1].length - groupStart;\n                localChildren.push(balanceRange(balanceType, children, positions, groupFrom, i, groupStart, length, null, mkTree));\n            }\n            localPositions.push(groupStart + offset - start);\n        }\n    }\n    divide(children, positions, from, to, 0);\n    return (mkTop || mkTree)(localChildren, localPositions, length);\n}\n/// Provides a way to associate values with pieces of trees. As long\n/// as that part of the tree is reused, the associated values can be\n/// retrieved from an updated tree.\nclass NodeWeakMap {\n    constructor() {\n        this.map = new WeakMap();\n    }\n    setBuffer(buffer, index, value) {\n        let inner = this.map.get(buffer);\n        if (!inner)\n            this.map.set(buffer, inner = new Map);\n        inner.set(index, value);\n    }\n    getBuffer(buffer, index) {\n        let inner = this.map.get(buffer);\n        return inner && inner.get(index);\n    }\n    /// Set the value for this syntax node.\n    set(node, value) {\n        if (node instanceof BufferNode)\n            this.setBuffer(node.context.buffer, node.index, value);\n        else if (node instanceof TreeNode)\n            this.map.set(node.tree, value);\n    }\n    /// Retrieve value for this syntax node, if it exists in the map.\n    get(node) {\n        return node instanceof BufferNode ? this.getBuffer(node.context.buffer, node.index)\n            : node instanceof TreeNode ? this.map.get(node.tree) : undefined;\n    }\n    /// Set the value for the node that a cursor currently points to.\n    cursorSet(cursor, value) {\n        if (cursor.buffer)\n            this.setBuffer(cursor.buffer.buffer, cursor.index, value);\n        else\n            this.map.set(cursor.tree, value);\n    }\n    /// Retrieve the value for the node that a cursor currently points\n    /// to.\n    cursorGet(cursor) {\n        return cursor.buffer ? this.getBuffer(cursor.buffer.buffer, cursor.index) : this.map.get(cursor.tree);\n    }\n}\n\n/// Tree fragments are used during [incremental\n/// parsing](#common.Parser.startParse) to track parts of old trees\n/// that can be reused in a new parse. An array of fragments is used\n/// to track regions of an old tree whose nodes might be reused in new\n/// parses. Use the static\n/// [`applyChanges`](#common.TreeFragment^applyChanges) method to\n/// update fragments for document changes.\nclass TreeFragment {\n    /// Construct a tree fragment. You'll usually want to use\n    /// [`addTree`](#common.TreeFragment^addTree) and\n    /// [`applyChanges`](#common.TreeFragment^applyChanges) instead of\n    /// calling this directly.\n    constructor(\n    /// The start of the unchanged range pointed to by this fragment.\n    /// This refers to an offset in the _updated_ document (as opposed\n    /// to the original tree).\n    from, \n    /// The end of the unchanged range.\n    to, \n    /// The tree that this fragment is based on.\n    tree, \n    /// The offset between the fragment's tree and the document that\n    /// this fragment can be used against. Add this when going from\n    /// document to tree positions, subtract it to go from tree to\n    /// document positions.\n    offset, openStart = false, openEnd = false) {\n        this.from = from;\n        this.to = to;\n        this.tree = tree;\n        this.offset = offset;\n        this.open = (openStart ? 1 /* Open.Start */ : 0) | (openEnd ? 2 /* Open.End */ : 0);\n    }\n    /// Whether the start of the fragment represents the start of a\n    /// parse, or the end of a change. (In the second case, it may not\n    /// be safe to reuse some nodes at the start, depending on the\n    /// parsing algorithm.)\n    get openStart() { return (this.open & 1 /* Open.Start */) > 0; }\n    /// Whether the end of the fragment represents the end of a\n    /// full-document parse, or the start of a change.\n    get openEnd() { return (this.open & 2 /* Open.End */) > 0; }\n    /// Create a set of fragments from a freshly parsed tree, or update\n    /// an existing set of fragments by replacing the ones that overlap\n    /// with a tree with content from the new tree. When `partial` is\n    /// true, the parse is treated as incomplete, and the resulting\n    /// fragment has [`openEnd`](#common.TreeFragment.openEnd) set to\n    /// true.\n    static addTree(tree, fragments = [], partial = false) {\n        let result = [new TreeFragment(0, tree.length, tree, 0, false, partial)];\n        for (let f of fragments)\n            if (f.to > tree.length)\n                result.push(f);\n        return result;\n    }\n    /// Apply a set of edits to an array of fragments, removing or\n    /// splitting fragments as necessary to remove edited ranges, and\n    /// adjusting offsets for fragments that moved.\n    static applyChanges(fragments, changes, minGap = 128) {\n        if (!changes.length)\n            return fragments;\n        let result = [];\n        let fI = 1, nextF = fragments.length ? fragments[0] : null;\n        for (let cI = 0, pos = 0, off = 0;; cI++) {\n            let nextC = cI < changes.length ? changes[cI] : null;\n            let nextPos = nextC ? nextC.fromA : 1e9;\n            if (nextPos - pos >= minGap)\n                while (nextF && nextF.from < nextPos) {\n                    let cut = nextF;\n                    if (pos >= cut.from || nextPos <= cut.to || off) {\n                        let fFrom = Math.max(cut.from, pos) - off, fTo = Math.min(cut.to, nextPos) - off;\n                        cut = fFrom >= fTo ? null : new TreeFragment(fFrom, fTo, cut.tree, cut.offset + off, cI > 0, !!nextC);\n                    }\n                    if (cut)\n                        result.push(cut);\n                    if (nextF.to > nextPos)\n                        break;\n                    nextF = fI < fragments.length ? fragments[fI++] : null;\n                }\n            if (!nextC)\n                break;\n            pos = nextC.toA;\n            off = nextC.toA - nextC.toB;\n        }\n        return result;\n    }\n}\n/// A superclass that parsers should extend.\nclass Parser {\n    /// Start a parse, returning a [partial parse](#common.PartialParse)\n    /// object. [`fragments`](#common.TreeFragment) can be passed in to\n    /// make the parse incremental.\n    ///\n    /// By default, the entire input is parsed. You can pass `ranges`,\n    /// which should be a sorted array of non-empty, non-overlapping\n    /// ranges, to parse only those ranges. The tree returned in that\n    /// case will start at `ranges[0].from`.\n    startParse(input, fragments, ranges) {\n        if (typeof input == \"string\")\n            input = new StringInput(input);\n        ranges = !ranges ? [new Range(0, input.length)] : ranges.length ? ranges.map(r => new Range(r.from, r.to)) : [new Range(0, 0)];\n        return this.createParse(input, fragments || [], ranges);\n    }\n    /// Run a full parse, returning the resulting tree.\n    parse(input, fragments, ranges) {\n        let parse = this.startParse(input, fragments, ranges);\n        for (;;) {\n            let done = parse.advance();\n            if (done)\n                return done;\n        }\n    }\n}\nclass StringInput {\n    constructor(string) {\n        this.string = string;\n    }\n    get length() { return this.string.length; }\n    chunk(from) { return this.string.slice(from); }\n    get lineChunks() { return false; }\n    read(from, to) { return this.string.slice(from, to); }\n}\n\n/// Create a parse wrapper that, after the inner parse completes,\n/// scans its tree for mixed language regions with the `nest`\n/// function, runs the resulting [inner parses](#common.NestedParse),\n/// and then [mounts](#common.NodeProp^mounted) their results onto the\n/// tree.\nfunction parseMixed(nest) {\n    return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);\n}\nclass InnerParse {\n    constructor(parser, parse, overlay, target, ranges) {\n        this.parser = parser;\n        this.parse = parse;\n        this.overlay = overlay;\n        this.target = target;\n        this.ranges = ranges;\n        if (!ranges.length || ranges.some(r => r.from >= r.to))\n            throw new RangeError(\"Invalid inner parse ranges given: \" + JSON.stringify(ranges));\n    }\n}\nclass ActiveOverlay {\n    constructor(parser, predicate, mounts, index, start, target, prev) {\n        this.parser = parser;\n        this.predicate = predicate;\n        this.mounts = mounts;\n        this.index = index;\n        this.start = start;\n        this.target = target;\n        this.prev = prev;\n        this.depth = 0;\n        this.ranges = [];\n    }\n}\nconst stoppedInner = new NodeProp({ perNode: true });\nclass MixedParse {\n    constructor(base, nest, input, fragments, ranges) {\n        this.nest = nest;\n        this.input = input;\n        this.fragments = fragments;\n        this.ranges = ranges;\n        this.inner = [];\n        this.innerDone = 0;\n        this.baseTree = null;\n        this.stoppedAt = null;\n        this.baseParse = base;\n    }\n    advance() {\n        if (this.baseParse) {\n            let done = this.baseParse.advance();\n            if (!done)\n                return null;\n            this.baseParse = null;\n            this.baseTree = done;\n            this.startInner();\n            if (this.stoppedAt != null)\n                for (let inner of this.inner)\n                    inner.parse.stopAt(this.stoppedAt);\n        }\n        if (this.innerDone == this.inner.length) {\n            let result = this.baseTree;\n            if (this.stoppedAt != null)\n                result = new Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));\n            return result;\n        }\n        let inner = this.inner[this.innerDone], done = inner.parse.advance();\n        if (done) {\n            this.innerDone++;\n            // This is a somewhat dodgy but super helpful hack where we\n            // patch up nodes created by the inner parse (and thus\n            // presumably not aliased anywhere else) to hold the information\n            // about the inner parse.\n            let props = Object.assign(Object.create(null), inner.target.props);\n            props[NodeProp.mounted.id] = new MountedTree(done, inner.overlay, inner.parser);\n            inner.target.props = props;\n        }\n        return null;\n    }\n    get parsedPos() {\n        if (this.baseParse)\n            return 0;\n        let pos = this.input.length;\n        for (let i = this.innerDone; i < this.inner.length; i++) {\n            if (this.inner[i].ranges[0].from < pos)\n                pos = Math.min(pos, this.inner[i].parse.parsedPos);\n        }\n        return pos;\n    }\n    stopAt(pos) {\n        this.stoppedAt = pos;\n        if (this.baseParse)\n            this.baseParse.stopAt(pos);\n        else\n            for (let i = this.innerDone; i < this.inner.length; i++)\n                this.inner[i].parse.stopAt(pos);\n    }\n    startInner() {\n        let fragmentCursor = new FragmentCursor(this.fragments);\n        let overlay = null;\n        let covered = null;\n        let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), IterMode.IncludeAnonymous | IterMode.IgnoreMounts);\n        scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {\n            let enter = true, range;\n            if (fragmentCursor.hasNode(cursor)) {\n                if (overlay) {\n                    let match = overlay.mounts.find(m => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);\n                    if (match)\n                        for (let r of match.mount.overlay) {\n                            let from = r.from + match.pos, to = r.to + match.pos;\n                            if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some(r => r.from < to && r.to > from))\n                                overlay.ranges.push({ from, to });\n                        }\n                }\n                enter = false;\n            }\n            else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {\n                enter = isCovered != 2 /* Cover.Full */;\n            }\n            else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {\n                if (!cursor.tree)\n                    materialize(cursor);\n                let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);\n                if (typeof nest.overlay == \"function\") {\n                    overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, cursor.tree, overlay);\n                }\n                else {\n                    let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);\n                    if (ranges.length)\n                        this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges));\n                    if (!nest.overlay)\n                        enter = false;\n                    else if (ranges.length)\n                        covered = { ranges, depth: 0, prev: covered };\n                }\n            }\n            else if (overlay && (range = overlay.predicate(cursor))) {\n                if (range === true)\n                    range = new Range(cursor.from, cursor.to);\n                if (range.from < range.to)\n                    overlay.ranges.push(range);\n            }\n            if (enter && cursor.firstChild()) {\n                if (overlay)\n                    overlay.depth++;\n                if (covered)\n                    covered.depth++;\n            }\n            else {\n                for (;;) {\n                    if (cursor.nextSibling())\n                        break;\n                    if (!cursor.parent())\n                        break scan;\n                    if (overlay && !--overlay.depth) {\n                        let ranges = punchRanges(this.ranges, overlay.ranges);\n                        if (ranges.length)\n                            this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map(r => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target, ranges));\n                        overlay = overlay.prev;\n                    }\n                    if (covered && !--covered.depth)\n                        covered = covered.prev;\n                }\n            }\n        }\n    }\n}\nfunction checkCover(covered, from, to) {\n    for (let range of covered) {\n        if (range.from >= to)\n            break;\n        if (range.to > from)\n            return range.from <= from && range.to >= to ? 2 /* Cover.Full */ : 1 /* Cover.Partial */;\n    }\n    return 0 /* Cover.None */;\n}\n// Take a piece of buffer and convert it into a stand-alone\n// TreeBuffer.\nfunction sliceBuf(buf, startI, endI, nodes, positions, off) {\n    if (startI < endI) {\n        let from = buf.buffer[startI + 1];\n        nodes.push(buf.slice(startI, endI, from));\n        positions.push(from - off);\n    }\n}\n// This function takes a node that's in a buffer, and converts it, and\n// its parent buffer nodes, into a Tree. This is again acting on the\n// assumption that the trees and buffers have been constructed by the\n// parse that was ran via the mix parser, and thus aren't shared with\n// any other code, making violations of the immutability safe.\nfunction materialize(cursor) {\n    let { node } = cursor, depth = 0;\n    // Scan up to the nearest tree\n    do {\n        cursor.parent();\n        depth++;\n    } while (!cursor.tree);\n    // Find the index of the buffer in that tree\n    let i = 0, base = cursor.tree, off = 0;\n    for (;; i++) {\n        off = base.positions[i] + cursor.from;\n        if (off <= node.from && off + base.children[i].length >= node.to)\n            break;\n    }\n    let buf = base.children[i], b = buf.buffer;\n    // Split a level in the buffer, putting the nodes before and after\n    // the child that contains `node` into new buffers.\n    function split(startI, endI, type, innerOffset, length) {\n        let i = startI;\n        while (b[i + 2] + off <= node.from)\n            i = b[i + 3];\n        let children = [], positions = [];\n        sliceBuf(buf, startI, i, children, positions, innerOffset);\n        let from = b[i + 1], to = b[i + 2];\n        let isTarget = from + off == node.from && to + off == node.to && b[i] == node.type.id;\n        children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], from, to - from));\n        positions.push(from - innerOffset);\n        sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);\n        return new Tree(type, children, positions, length);\n    }\n    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);\n    // Move the cursor back to the target node\n    for (let d = 0; d <= depth; d++)\n        cursor.childAfter(node.from);\n}\nclass StructureCursor {\n    constructor(root, offset) {\n        this.offset = offset;\n        this.done = false;\n        this.cursor = root.cursor(IterMode.IncludeAnonymous | IterMode.IgnoreMounts);\n    }\n    // Move to the first node (in pre-order) that starts at or after `pos`.\n    moveTo(pos) {\n        let { cursor } = this, p = pos - this.offset;\n        while (!this.done && cursor.from < p) {\n            if (cursor.to >= pos && cursor.enter(p, 1, IterMode.IgnoreOverlays | IterMode.ExcludeBuffers)) ;\n            else if (!cursor.next(false))\n                this.done = true;\n        }\n    }\n    hasNode(cursor) {\n        this.moveTo(cursor.from);\n        if (!this.done && this.cursor.from + this.offset == cursor.from && this.cursor.tree) {\n            for (let tree = this.cursor.tree;;) {\n                if (tree == cursor.tree)\n                    return true;\n                if (tree.children.length && tree.positions[0] == 0 && tree.children[0] instanceof Tree)\n                    tree = tree.children[0];\n                else\n                    break;\n            }\n        }\n        return false;\n    }\n}\nclass FragmentCursor {\n    constructor(fragments) {\n        var _a;\n        this.fragments = fragments;\n        this.curTo = 0;\n        this.fragI = 0;\n        if (fragments.length) {\n            let first = this.curFrag = fragments[0];\n            this.curTo = (_a = first.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : first.to;\n            this.inner = new StructureCursor(first.tree, -first.offset);\n        }\n        else {\n            this.curFrag = this.inner = null;\n        }\n    }\n    hasNode(node) {\n        while (this.curFrag && node.from >= this.curTo)\n            this.nextFrag();\n        return this.curFrag && this.curFrag.from <= node.from && this.curTo >= node.to && this.inner.hasNode(node);\n    }\n    nextFrag() {\n        var _a;\n        this.fragI++;\n        if (this.fragI == this.fragments.length) {\n            this.curFrag = this.inner = null;\n        }\n        else {\n            let frag = this.curFrag = this.fragments[this.fragI];\n            this.curTo = (_a = frag.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : frag.to;\n            this.inner = new StructureCursor(frag.tree, -frag.offset);\n        }\n    }\n    findMounts(pos, parser) {\n        var _a;\n        let result = [];\n        if (this.inner) {\n            this.inner.cursor.moveTo(pos, 1);\n            for (let pos = this.inner.cursor.node; pos; pos = pos.parent) {\n                let mount = (_a = pos.tree) === null || _a === void 0 ? void 0 : _a.prop(NodeProp.mounted);\n                if (mount && mount.parser == parser) {\n                    for (let i = this.fragI; i < this.fragments.length; i++) {\n                        let frag = this.fragments[i];\n                        if (frag.from >= pos.to)\n                            break;\n                        if (frag.tree == this.curFrag.tree)\n                            result.push({\n                                frag,\n                                pos: pos.from - frag.offset,\n                                mount\n                            });\n                    }\n                }\n            }\n        }\n        return result;\n    }\n}\nfunction punchRanges(outer, ranges) {\n    let copy = null, current = ranges;\n    for (let i = 1, j = 0; i < outer.length; i++) {\n        let gapFrom = outer[i - 1].to, gapTo = outer[i].from;\n        for (; j < current.length; j++) {\n            let r = current[j];\n            if (r.from >= gapTo)\n                break;\n            if (r.to <= gapFrom)\n                continue;\n            if (!copy)\n                current = copy = ranges.slice();\n            if (r.from < gapFrom) {\n                copy[j] = new Range(r.from, gapFrom);\n                if (r.to > gapTo)\n                    copy.splice(j + 1, 0, new Range(gapTo, r.to));\n            }\n            else if (r.to > gapTo) {\n                copy[j--] = new Range(gapTo, r.to);\n            }\n            else {\n                copy.splice(j--, 1);\n            }\n        }\n    }\n    return current;\n}\nfunction findCoverChanges(a, b, from, to) {\n    let iA = 0, iB = 0, inA = false, inB = false, pos = -1e9;\n    let result = [];\n    for (;;) {\n        let nextA = iA == a.length ? 1e9 : inA ? a[iA].to : a[iA].from;\n        let nextB = iB == b.length ? 1e9 : inB ? b[iB].to : b[iB].from;\n        if (inA != inB) {\n            let start = Math.max(pos, from), end = Math.min(nextA, nextB, to);\n            if (start < end)\n                result.push(new Range(start, end));\n        }\n        pos = Math.min(nextA, nextB);\n        if (pos == 1e9)\n            break;\n        if (nextA == pos) {\n            if (!inA)\n                inA = true;\n            else {\n                inA = false;\n                iA++;\n            }\n        }\n        if (nextB == pos) {\n            if (!inB)\n                inB = true;\n            else {\n                inB = false;\n                iB++;\n            }\n        }\n    }\n    return result;\n}\n// Given a number of fragments for the outer tree, and a set of ranges\n// to parse, find fragments for inner trees mounted around those\n// ranges, if any.\nfunction enterFragments(mounts, ranges) {\n    let result = [];\n    for (let { pos, mount, frag } of mounts) {\n        let startPos = pos + (mount.overlay ? mount.overlay[0].from : 0), endPos = startPos + mount.tree.length;\n        let from = Math.max(frag.from, startPos), to = Math.min(frag.to, endPos);\n        if (mount.overlay) {\n            let overlay = mount.overlay.map(r => new Range(r.from + pos, r.to + pos));\n            let changes = findCoverChanges(ranges, overlay, from, to);\n            for (let i = 0, pos = from;; i++) {\n                let last = i == changes.length, end = last ? to : changes[i].from;\n                if (end > pos)\n                    result.push(new TreeFragment(pos, end, mount.tree, -startPos, frag.from >= pos || frag.openStart, frag.to <= end || frag.openEnd));\n                if (last)\n                    break;\n                pos = changes[i].to;\n            }\n        }\n        else {\n            result.push(new TreeFragment(from, to, mount.tree, -startPos, frag.from >= startPos || frag.openStart, frag.to <= endPos || frag.openEnd));\n        }\n    }\n    return result;\n}\n\nexport { DefaultBufferLength, IterMode, MountedTree, NodeProp, NodeSet, NodeType, NodeWeakMap, Parser, Tree, TreeBuffer, TreeCursor, TreeFragment, parseMixed };\n", "import {\n  NodeWeakMap,\n  type SyntaxNodeRef,\n  type SyntaxNode,\n  IterMode,\n} from \"@lezer/common\";\nimport {\n  type Completion,\n  type CompletionContext,\n  type CompletionResult,\n  completeFromList,\n  ifNotIn,\n} from \"@codemirror/autocomplete\";\nimport { type Text } from \"@codemirror/state\";\n\nconst cache = new NodeWeakMap<readonly Completion[]>();\n\nconst ScopeNodes = new Set([\n  \"Script\",\n  \"Body\",\n  \"FunctionNode\",\n  \"ClassNode\",\n  \"LambdaExpressionNode\",\n  \"ForNode\",\n  \"MatchBranchNode\",\n]);\n\nfunction defID(type: string) {\n  return (\n    node: SyntaxNodeRef,\n    def: (node: SyntaxNodeRef, type: string) => void,\n    outer: boolean\n  ) => {\n    if (outer) return false;\n    const id = node.node.getChild(\"VariableName\");\n    if (id != null) def(id, type);\n    return true;\n  };\n}\n\nconst gatherCompletions: Record<\n  string,\n  (\n    node: SyntaxNodeRef,\n    def: (node: SyntaxNodeRef, type: string) => void,\n    outer: boolean\n  ) => undefined | boolean\n> = {\n  FunctionNode: defID(\"function\"),\n  // ClassDefinition: defID(\"class\"),\n  // ForStatement(node, def, outer) {\n  //   if (outer)\n  //     for (let child = node.node.firstChild; child; child = child.nextSibling) {\n  //       if (child.name == \"VariableName\") def(child, \"variable\");\n  //       else if (child.name == \"in\") break;\n  //     }\n  // },\n  // ImportStatement(_node, def) {\n  //   let { node } = _node;\n  //   let isFrom = node.firstChild?.name == \"from\";\n  //   for (let ch = node.getChild(\"import\"); ch; ch = ch.nextSibling) {\n  //     if (ch.name == \"VariableName\" && ch.nextSibling?.name != \"as\")\n  //       def(ch, isFrom ? \"variable\" : \"namespace\");\n  //   }\n  // },\n  // AssignStatement(node, def) {\n  //   for (let child = node.node.firstChild; child; child = child.nextSibling) {\n  //     if (child.name == \"VariableName\") def(child, \"variable\");\n  //     else if (child.name == \":\" || child.name == \"AssignOp\") break;\n  //   }\n  // },\n  // ParamList(node, def) {\n  //   for (\n  //     let prev = null, child = node.node.firstChild;\n  //     child;\n  //     child = child.nextSibling\n  //   ) {\n  //     if (\n  //       child.name == \"VariableName\" &&\n  //       (!prev || !/\\*|AssignOp/.test(prev.name))\n  //     )\n  //       def(child, \"variable\");\n  //     prev = child;\n  //   }\n  // },\n  // CapturePattern: defID(\"variable\"),\n  // AsPattern: defID(\"variable\"),\n  __proto__: null as any,\n};\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction getScope(doc: Text, node: SyntaxNode): readonly Completion[] {\n  const cached = cache.get(node);\n  if (cached != null) return cached;\n\n  const completions: Completion[] = [];\n  let top = true;\n  function def(node: SyntaxNodeRef, type: string): void {\n    const name = doc.sliceString(node.from, node.to);\n    completions.push({ label: name, type });\n  }\n  node.cursor(IterMode.IncludeAnonymous).iterate((node) => {\n    if (node.name !== \"\") {\n      const gather = gatherCompletions[node.name];\n      if (\n        gather?.(node, def, top) === true ||\n        (!top && ScopeNodes.has(node.name))\n      )\n        return false;\n      top = false;\n    } else if (node.to - node.from > 8192) {\n      // Allow caching for bigger internal nodes\n      for (const c of getScope(doc, node.node)) completions.push(c);\n      return false;\n    }\n  });\n  cache.set(node, completions);\n  return completions;\n}\n\nconst dontComplete = [\"String\", \"Comment\"];\n\nexport function localCompletionSource(\n  context: CompletionContext\n): CompletionResult | null {\n  return null;\n}\n\nconst globals: readonly Completion[] = ([] as Completion[])\n  .concat(\n    [\"true\", \"false\", \"null\", \"PI\", \"TAU\", \"INF\", \"NaN\"].map((n) => ({\n      label: n,\n      type: \"constant\",\n    }))\n  )\n  .concat(\n    [\n      \"AudioServer\",\n      \"CameraServer\",\n      \"ClassDB\",\n      \"DisplayServer\",\n      \"Engine\",\n      \"EngineDebugger\",\n      \"GDExtensionManager\",\n      \"Geometry2D\",\n      \"Geometry3D\",\n      \"GodotSharp\",\n      \"IP\",\n      \"Input\",\n      \"InputMap\",\n      \"JavaClassWrapper\",\n      \"JavaScriptBridge\",\n      \"Marshalls\",\n      \"NavigationMeshGenerator\",\n      \"NavigationServer2D\",\n      \"NavigationServer3D\",\n      \"OS\",\n      \"Performance\",\n      \"PhysicsServer2D\",\n      \"PhysicsServer2DManager\",\n      \"PhysicsServer3D\",\n      \"PhysicsServer3DManager\",\n      \"ProjectSettings\",\n      \"RenderingServer\",\n      \"ResourceLoader\",\n      \"ResourceSaver\",\n      \"ResourceUID\",\n      \"TextServerManager\",\n      \"ThemeDB\",\n      \"Time\",\n      \"TranslationServer\",\n      \"WorkerThreadPool\",\n      \"XRServer\",\n    ].map((n) => ({ label: n, type: \"class\" }))\n  )\n  .concat(\n    [\n      // Variant\n      \"Variant\",\n      // null\n      \"void\",\n      // atomic types\n      \"bool\",\n      \"int\",\n      \"float\",\n      \"String\",\n      // math types\n      \"Vector2\",\n      \"Vector2i\",\n      \"Rect2\",\n      \"Rect2i\",\n      \"Vector3\",\n      \"Vector3i\",\n      \"Transform2D\",\n      \"Vector4\",\n      \"Vector4i\",\n      \"Plane\",\n      \"Quaternion\",\n      \"AABB\",\n      \"Basis\",\n      \"Transform3D\",\n      \"Projection\",\n      // misc types\n      \"Color\",\n      \"StringName\",\n      \"NodePath\",\n      \"RID\",\n      \"Object\",\n      \"Callable\",\n      \"Signal\",\n      \"Dictionary\",\n      \"Array\",\n      // typed arrays\n      \"PackedByteArray\",\n      \"PackedInt32Array\",\n      \"PackedInt64Array\",\n      \"PackedFloat32Array\",\n      \"PackedFloat64Array\",\n      \"PackedStringArray\",\n      \"PackedVector2Array\",\n      \"PackedVector3Array\",\n      \"PackedColorArray\",\n    ].map((n) => ({\n      label: n,\n      type: \"class\",\n    }))\n  )\n  .concat(\n    [\n      \"abs\",\n      \"absf\",\n      \"absi\",\n      \"acos\",\n      \"asin\",\n      \"atan\",\n      \"atan2\",\n      \"bezier_derivative\",\n      \"bezier_interpolate\",\n      \"bytes_to_var\",\n      \"bytes_to_var_with_objects\",\n      \"ceil\",\n      \"ceilf\",\n      \"ceili\",\n      \"clamp\",\n      \"clampf\",\n      \"clampi\",\n      \"cos\",\n      \"cosh\",\n      \"cubic_interpolate\",\n      \"cubic_interpolate_angle\",\n      \"cubic_interpolate_angle_in_time\",\n      \"cubic_interpolate_in_time\",\n      \"db_to_linear\",\n      \"deg_to_rad\",\n      \"ease\",\n      \"error_string\",\n      \"exp\",\n      \"floor\",\n      \"floorf\",\n      \"floori\",\n      \"fmod\",\n      \"fposmod\",\n      \"hash\",\n      \"instance_from_id\",\n      \"inverse_lerp\",\n      \"is_equal_approx\",\n      \"is_finite\",\n      \"is_inf\",\n      \"is_instance_id_valid\",\n      \"is_instance_valid\",\n      \"is_nan\",\n      \"is_same\",\n      \"is_zero_approx\",\n      \"lerp\",\n      \"lerp_angle\",\n      \"lerpf\",\n      \"linear_to_db\",\n      \"log\",\n      \"max\",\n      \"maxf\",\n      \"maxi\",\n      \"min\",\n      \"minf\",\n      \"mini\",\n      \"move_toward\",\n      \"nearest_po2\",\n      \"pingpong\",\n      \"posmod\",\n      \"pow\",\n      \"print\",\n      \"print_rich\",\n      \"print_verbose\",\n      \"printerr\",\n      \"printraw\",\n      \"prints\",\n      \"printt\",\n      \"push_error\",\n      \"push_warning\",\n      \"rad_to_deg\",\n      \"rand_from_seed\",\n      \"randf\",\n      \"randf_range\",\n      \"randfn\",\n      \"randi\",\n      \"randi_range\",\n      \"randomize\",\n      \"remap\",\n      \"rid_allocate_id\",\n      \"rid_from_int64\",\n      \"round\",\n      \"roundf\",\n      \"roundi\",\n      \"seed\",\n      \"sign\",\n      \"signf\",\n      \"signi\",\n      \"sin\",\n      \"sinh\",\n      \"smoothstep\",\n      \"snapped\",\n      \"snappedf\",\n      \"snappedi\",\n      \"sqrt\",\n      \"step_decimals\",\n      \"str\",\n      \"str_to_var\",\n      \"tan\",\n      \"tanh\",\n      \"typeof\",\n      \"var_to_bytes\",\n      \"var_to_bytes_with_objects\",\n      \"var_to_str\",\n      \"weakref\",\n      \"wrap\",\n      \"wrapf\",\n      \"wrapi\",\n    ].map((n) => ({ label: n, type: \"function\" }))\n  );\nexport const snippets: readonly Completion[] = [];\n\nexport const globalCompletion = ifNotIn(\n  dontComplete,\n  completeFromList(globals.concat(snippets))\n);\n"],
  "mappings": "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AIA,EAAO,IAAI,CACxG,CACJ,EA2JA,IAAM6H,GAAe,IAAIC,EAAS,CAAE,QAAS,EAAK,CAAC,EC56CnD,IAAAC,GAMO,oCAGDC,GAAQ,IAAIC,GAYlB,SAASC,GAAMC,EAAc,CAC3B,MAAO,CACLC,EACAC,EACAC,IACG,CACH,GAAIA,EAAO,MAAO,GAClB,IAAMC,EAAKH,EAAK,KAAK,SAAS,cAAc,EAC5C,OAAIG,GAAM,MAAMF,EAAIE,EAAIJ,CAAI,EACrB,EACT,CACF,CAEA,IAAMK,GAOF,CACF,aAAcN,GAAM,UAAU,EAuC9B,UAAW,IACb,EAgCA,IAAMO,GAAe,CAAC,SAAU,SAAS,EAElC,SAASC,GACdC,EACyB,CACzB,OAAO,IACT,CAEA,IAAMC,GAAkC,CAAC,EACtC,OACC,CAAC,OAAQ,QAAS,OAAQ,KAAM,MAAO,MAAO,KAAK,EAAE,IAAKC,IAAO,CAC/D,MAAOA,EACP,KAAM,UACR,EAAE,CACJ,EACC,OACC,CACE,cACA,eACA,UACA,gBACA,SACA,iBACA,qBACA,aACA,aACA,aACA,KACA,QACA,WACA,mBACA,mBACA,YACA,0BACA,qBACA,qBACA,KACA,cACA,kBACA,yBACA,kBACA,yBACA,kBACA,kBACA,iBACA,gBACA,cACA,oBACA,UACA,OACA,oBACA,mBACA,UACF,EAAE,IAAKA,IAAO,CAAE,MAAOA,EAAG,KAAM,OAAQ,EAAE,CAC5C,EACC,OACC,CAEE,UAEA,OAEA,OACA,MACA,QACA,SAEA,UACA,WACA,QACA,SACA,UACA,WACA,cACA,UACA,WACA,QACA,aACA,OACA,QACA,cACA,aAEA,QACA,aACA,WACA,MACA,SACA,WACA,SACA,aACA,QAEA,kBACA,mBACA,mBACA,qBACA,qBACA,oBACA,qBACA,qBACA,kBACF,EAAE,IAAKA,IAAO,CACZ,MAAOA,EACP,KAAM,OACR,EAAE,CACJ,EACC,OACC,CACE,MACA,OACA,OACA,OACA,OACA,OACA,QACA,oBACA,qBACA,eACA,4BACA,OACA,QACA,QACA,QACA,SACA,SACA,MACA,OACA,oBACA,0BACA,kC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",
  "names": ["src_exports", "__export", "gdscript", "gdscriptLanguage", "globalCompletion", "localCompletionSource", "__toCommonJS", "import_language", "import_lr", "import_highlight", "indent", "dedent", "newline", "blankLineStart", "newlineBracketed", "eof", "ParenL", "CallParamsLiteralExpressionNode", "CallParamsExpressionNode", "ArrayExpressionNode", "BracketL", "CallExpressionNode", "DictionaryExpressionNode", "BraceL", "GroupedExpressionNode", "CallParamsParameterNode", "bracketed", "carriageReturn", "space", "tab", "hash", "IndentLevel", "parent", "depth", "topIndent", "isLineBreak", "ch", "newlines", "input", "stack", "prev", "spaces", "countIndent", "i", "trackIndent", "context", "term", "indentation", "contextDepth", "chars", "gdscriptHighlighting", "t", "spec_Identifier", "parser", "value", "nextPropID", "NodeProp", "config", "nextPropID", "match", "NodeType", "type", "result", "str", "noProps", "NodeType", "_NodeType", "name", "props", "id", "flags", "spec", "type", "src", "prop", "group", "NodeProp", "map", "direct", "node", "groups", "i", "found", "CachedNode", "CachedInnerNode", "IterMode", "Tree", "_Tree", "type", "children", "positions", "length", "props", "prop", "value", "mounted", "NodeProp", "ch", "str", "mode", "TreeCursor", "pos", "side", "scope", "cursor", "TreeNode", "node", "resolveNode", "spec", "enter", "leave", "from", "to", "anon", "c", "entered", "result", "id", "config", "balanceRange", "NodeType", "data", "buildTree", "FlatBufferCursor", "_FlatBufferCursor", "buffer", "index", "TreeBuffer", "_TreeBuffer", "set", "endIndex", "startIndex", "dir", "pick", "i", "checkSide", "startI", "endI", "b", "copy", "len", "j", "enterUnfinishedNodesBefore", "scan", "last", "overlays", "_a", "parent", "inner", "_TreeNode", "_tree", "_parent", "e", "next", "start", "BufferNode", "BufferContext", "hasChild", "rPos", "val", "before", "after", "r", "getChildren", "context", "matchNodeContext", "cur", "p", "_BufferNode", "parentStart", "n", "d", "child", "cache", "depth", "mustLeave", "types", "tree", "nodeSet", "maxBufferLength", "reused", "minRepeatType", "contextHash", "lookAhead", "takeNode", "minPos", "inRepeat", "end", "size", "lookAheadAtStart", "startPos", "findBufferSize", "endPos", "copyToBuffer", "localChildren", "localPositions", "localInRepeat", "lastGroup", "lastEnd", "makeRepeatLeaf", "make", "makeBalanced", "makeTree", "lastI", "lookAheadProp", "base", "pair", "maxSize", "fork", "skip", "minStart", "nodeSize", "localSkipped", "nodeStart", "bufferStart", "nodeSizeCache", "balanceType", "mkTop", "mkTree", "total", "maxChild", "divide", "offset", "groupFrom", "groupStart", "groupSize", "nextSize", "only", "NodeWeakMap", "stoppedInner", "NodeProp", "import_autocomplete", "cache", "NodeWeakMap", "defID", "type", "node", "def", "outer", "id", "gatherCompletions", "dontComplete", "localCompletionSource", "context", "globals", "n", "snippets", "globalCompletion", "indentBody", "context", "node", "base", "line", "to", "gdscriptLanguage", "parser", "endBody", "cur", "bodyIndent", "state", "gdscript", "localCompletionSource", "globalCompletion"]
}