@gdquest/codemirror-gdscript
Version:
Enables Codemirror to parse GDScript (ie. highlight and indent automatically).
1,130 lines (1,128 loc) • 71.3 kB
JavaScript
// src/index.mts
import {
foldNodeProp,
foldInside,
indentNodeProp,
LRLanguage,
LanguageSupport
} from "@codemirror/language";
// ../lezer-gdscript/dist/index.mjs
import { LRParser } from "@lezer/lr";
import { ContextTracker, ExternalTokenizer } from "@lezer/lr";
import { styleTags, tags as t } from "@lezer/highlight";
var indent = 140;
var dedent = 141;
var newline = 142;
var blankLineStart = 143;
var newlineBracketed = 144;
var eof = 145;
var ParenL = 10;
var CallParamsLiteralExpressionNode = 11;
var CallParamsExpressionNode = 25;
var ArrayExpressionNode = 27;
var BracketL = 32;
var CallExpressionNode = 59;
var DictionaryExpressionNode = 63;
var BraceL = 64;
var GroupedExpressionNode = 66;
var CallParamsParameterNode = 70;
var bracketed = /* @__PURE__ */ new Set([
GroupedExpressionNode,
ArrayExpressionNode,
DictionaryExpressionNode,
CallExpressionNode,
CallParamsExpressionNode,
CallParamsLiteralExpressionNode,
CallParamsParameterNode
]);
var newline2 = "\n".charCodeAt(0);
var carriageReturn = "\r".charCodeAt(0);
var space = " ".charCodeAt(0);
var tab = " ".charCodeAt(0);
var hash = "#".charCodeAt(0);
var IndentLevel = class {
constructor(parent, depth) {
this.parent = parent;
this.depth = depth;
this.hash = (parent ? parent.hash + parent.hash << 8 : 0) + depth + (depth << 4);
}
};
var topIndent = new IndentLevel(null, 0);
function isLineBreak(ch) {
return ch === newline2 || ch === carriageReturn;
}
var newlines = new ExternalTokenizer(
(input, stack) => {
let prev;
if (input.next < 0) {
input.acceptToken(eof);
} else if (stack.context.depth < 0) {
if (isLineBreak(input.next)) {
input.acceptToken(newlineBracketed, 1);
}
} else if (((prev = input.peek(-1)) < 0 || isLineBreak(prev)) && stack.canShift(blankLineStart)) {
let spaces = 0;
while (input.next === space || input.next === tab) {
input.advance();
spaces++;
}
if (input.next === newline2 || input.next === carriageReturn || input.next === hash) {
input.acceptToken(blankLineStart, -spaces);
}
} else if (isLineBreak(input.next)) {
input.acceptToken(newline, 1);
}
},
{ contextual: true }
);
function countIndent(space2) {
let depth = 0;
for (let i = 0; i < space2.length; i++)
depth += space2.charCodeAt(i) === tab ? 8 - depth % 8 : 1;
return depth;
}
var trackIndent = new ContextTracker({
start: topIndent,
reduce(context, term) {
return context.depth < 0 && bracketed.has(term) ? context.parent : context;
},
shift(context, term, stack, input) {
switch (term) {
case indent:
return new IndentLevel(
context,
countIndent(input.read(input.pos, stack.pos))
);
case dedent:
return context.parent;
case ParenL:
case BracketL:
case BraceL:
return new IndentLevel(context, -1);
default:
return context;
}
},
hash(context) {
return context.hash;
}
});
var indentation = new ExternalTokenizer((input, stack) => {
const contextDepth = stack.context.depth;
if (contextDepth < 0)
return;
const prev = input.peek(-1);
if (!(prev === newline2 || prev === carriageReturn)) {
return;
}
let chars = 0;
let depth = 0;
while (true) {
if (input.next === space) {
depth++;
} else if (input.next === tab) {
depth += 8 - depth % 8;
} else {
break;
}
input.advance();
chars += 1;
}
if (depth !== contextDepth && input.next !== newline2 && input.next !== carriageReturn && input.next !== hash) {
if (depth < contextDepth) {
input.acceptToken(dedent, -chars);
} else {
input.acceptToken(indent);
}
}
});
var gdscriptHighlighting = styleTags({
"for while if elif else return break continue pass assert await match case": t.controlKeyword,
"in not and or is del": t.operatorKeyword,
"func class class_name extends const var": t.definitionKeyword,
"preload load": t.moduleKeyword,
"as PI TAU INF NaN": t.keyword,
True: t.bool,
False: t.bool,
Null: t.bool,
Comment: t.lineComment,
Number: t.number,
String: t.string,
UpdateOp: t.updateOperator,
ArithOp: t.arithmeticOperator,
BitOp: t.bitwiseOperator,
CompareOp: t.compareOperator,
AssignOp: t.definitionOperator,
"ClassNode/Identifier ClassNode/ExtendsStatement/Identifier VariableNode/TypeCast/Type/Identifier": t.definition(t.className),
"( )": t.paren,
"[ ]": t.squareBracket,
"{ }": t.brace,
".": t.derefOperator,
", ;": t.separator
});
var 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 };
var parser = LRParser.deserialize({
version: 14,
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",
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~",
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",
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",
maxTerm: 166,
context: trackIndent,
nodeProps: [
["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"],
["openedBy", 9, "("],
["closedBy", 10, ")"]
],
propSources: [gdscriptHighlighting],
skippedNodes: [0, 1],
repeatNodeCount: 11,
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!QQQ)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!`~",
tokenizers: [indentation, newlines, 0, 1, 2],
topRules: { "Script": [0, 2] },
specialized: [{ term: 8, get: (value) => spec_Identifier[value] || -1 }],
tokenPrec: 3645
});
// ../../node_modules/.pnpm/@lezer+common@1.0.3/node_modules/@lezer/common/dist/index.js
var DefaultBufferLength = 1024;
var nextPropID = 0;
var NodeProp = class {
/// Create a new node prop type.
constructor(config = {}) {
this.id = nextPropID++;
this.perNode = !!config.perNode;
this.deserialize = config.deserialize || (() => {
throw new Error("This node type doesn't define a deserialize function");
});
}
/// This is meant to be used with
/// [`NodeSet.extend`](#common.NodeSet.extend) or
/// [`LRParser.configure`](#lr.ParserConfig.props) to compute
/// prop values for each node type in the set. Takes a [match
/// object](#common.NodeType^match) or function that returns undefined
/// if the node type doesn't get this prop, and the prop's value if
/// it does.
add(match) {
if (this.perNode)
throw new RangeError("Can't add per-node props to node types");
if (typeof match != "function")
match = NodeType.match(match);
return (type) => {
let result = match(type);
return result === void 0 ? null : [this, result];
};
}
};
NodeProp.closedBy = new NodeProp({ deserialize: (str) => str.split(" ") });
NodeProp.openedBy = new NodeProp({ deserialize: (str) => str.split(" ") });
NodeProp.group = new NodeProp({ deserialize: (str) => str.split(" ") });
NodeProp.contextHash = new NodeProp({ perNode: true });
NodeProp.lookAhead = new NodeProp({ perNode: true });
NodeProp.mounted = new NodeProp({ perNode: true });
var noProps = /* @__PURE__ */ Object.create(null);
var NodeType = class _NodeType {
/// @internal
constructor(name, props, id, flags = 0) {
this.name = name;
this.props = props;
this.id = id;
this.flags = flags;
}
/// Define a node type.
static define(spec) {
let props = spec.props && spec.props.length ? /* @__PURE__ */ Object.create(null) : noProps;
let flags = (spec.top ? 1 : 0) | (spec.skipped ? 2 : 0) | (spec.error ? 4 : 0) | (spec.name == null ? 8 : 0);
let type = new _NodeType(spec.name || "", props, spec.id, flags);
if (spec.props)
for (let src of spec.props) {
if (!Array.isArray(src))
src = src(type);
if (src) {
if (src[0].perNode)
throw new RangeError("Can't store a per-node prop on a node type");
props[src[0].id] = src[1];
}
}
return type;
}
/// Retrieves a node prop for this type. Will return `undefined` if
/// the prop isn't present on this node.
prop(prop) {
return this.props[prop.id];
}
/// True when this is the top node of a grammar.
get isTop() {
return (this.flags & 1) > 0;
}
/// True when this node is produced by a skip rule.
get isSkipped() {
return (this.flags & 2) > 0;
}
/// Indicates whether this is an error node.
get isError() {
return (this.flags & 4) > 0;
}
/// When true, this node type doesn't correspond to a user-declared
/// named node, for example because it is used to cache repetition.
get isAnonymous() {
return (this.flags & 8) > 0;
}
/// Returns true when this node's name or one of its
/// [groups](#common.NodeProp^group) matches the given string.
is(name) {
if (typeof name == "string") {
if (this.name == name)
return true;
let group = this.prop(NodeProp.group);
return group ? group.indexOf(name) > -1 : false;
}
return this.id == name;
}
/// Create a function from node types to arbitrary values by
/// specifying an object whose property names are node or
/// [group](#common.NodeProp^group) names. Often useful with
/// [`NodeProp.add`](#common.NodeProp.add). You can put multiple
/// names, separated by spaces, in a single property name to map
/// multiple node names to a single value.
static match(map) {
let direct = /* @__PURE__ */ Object.create(null);
for (let prop in map)
for (let name of prop.split(" "))
direct[name] = map[prop];
return (node) => {
for (let groups = node.prop(NodeProp.group), i = -1; i < (groups ? groups.length : 0); i++) {
let found = direct[i < 0 ? node.name : groups[i]];
if (found)
return found;
}
};
}
};
NodeType.none = new NodeType(
"",
/* @__PURE__ */ Object.create(null),
0,
8
/* NodeFlag.Anonymous */
);
var CachedNode = /* @__PURE__ */ new WeakMap();
var CachedInnerNode = /* @__PURE__ */ new WeakMap();
var IterMode;
(function(IterMode2) {
IterMode2[IterMode2["ExcludeBuffers"] = 1] = "ExcludeBuffers";
IterMode2[IterMode2["IncludeAnonymous"] = 2] = "IncludeAnonymous";
IterMode2[IterMode2["IgnoreMounts"] = 4] = "IgnoreMounts";
IterMode2[IterMode2["IgnoreOverlays"] = 8] = "IgnoreOverlays";
})(IterMode || (IterMode = {}));
var Tree = class _Tree {
/// Construct a new tree. See also [`Tree.build`](#common.Tree^build).
constructor(type, children, positions, length, props) {
this.type = type;
this.children = children;
this.positions = positions;
this.length = length;
this.props = null;
if (props && props.length) {
this.props = /* @__PURE__ */ Object.create(null);
for (let [prop, value] of props)
this.props[typeof prop == "number" ? prop : prop.id] = value;
}
}
/// @internal
toString() {
let mounted = this.prop(NodeProp.mounted);
if (mounted && !mounted.overlay)
return mounted.tree.toString();
let children = "";
for (let ch of this.children) {
let str = ch.toString();
if (str) {
if (children)
children += ",";
children += str;
}
}
return !this.type.name ? children : (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (children.length ? "(" + children + ")" : "");
}
/// Get a [tree cursor](#common.TreeCursor) positioned at the top of
/// the tree. Mode can be used to [control](#common.IterMode) which
/// nodes the cursor visits.
cursor(mode = 0) {
return new TreeCursor(this.topNode, mode);
}
/// Get a [tree cursor](#common.TreeCursor) pointing into this tree
/// at the given position and side (see
/// [`moveTo`](#common.TreeCursor.moveTo).
cursorAt(pos, side = 0, mode = 0) {
let scope = CachedNode.get(this) || this.topNode;
let cursor = new TreeCursor(scope);
cursor.moveTo(pos, side);
CachedNode.set(this, cursor._tree);
return cursor;
}
/// Get a [syntax node](#common.SyntaxNode) object for the top of the
/// tree.
get topNode() {
return new TreeNode(this, 0, 0, null);
}
/// Get the [syntax node](#common.SyntaxNode) at the given position.
/// If `side` is -1, this will move into nodes that end at the
/// position. If 1, it'll move into nodes that start at the
/// position. With 0, it'll only enter nodes that cover the position
/// from both sides.
///
/// Note that this will not enter
/// [overlays](#common.MountedTree.overlay), and you often want
/// [`resolveInner`](#common.Tree.resolveInner) instead.
resolve(pos, side = 0) {
let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
CachedNode.set(this, node);
return node;
}
/// Like [`resolve`](#common.Tree.resolve), but will enter
/// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
/// pointing into the innermost overlaid tree at the given position
/// (with parent links going through all parent structure, including
/// the host trees).
resolveInner(pos, side = 0) {
let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
CachedInnerNode.set(this, node);
return node;
}
/// Iterate over the tree and its children, calling `enter` for any
/// node that touches the `from`/`to` region (if given) before
/// running over such a node's children, and `leave` (if given) when
/// leaving the node. When `enter` returns `false`, that node will
/// not have its children iterated over (or `leave` called).
iterate(spec) {
let { enter, leave, from = 0, to = this.length } = spec;
let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0;
for (let c = this.cursor(mode | IterMode.IncludeAnonymous); ; ) {
let entered = false;
if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== false)) {
if (c.firstChild())
continue;
entered = true;
}
for (; ; ) {
if (entered && leave && (anon || !c.type.isAnonymous))
leave(c);
if (c.nextSibling())
break;
if (!c.parent())
return;
entered = true;
}
}
}
/// Get the value of the given [node prop](#common.NodeProp) for this
/// node. Works with both per-node and per-type props.
prop(prop) {
return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : void 0;
}
/// Returns the node's [per-node props](#common.NodeProp.perNode) in a
/// format that can be passed to the [`Tree`](#common.Tree)
/// constructor.
get propValues() {
let result = [];
if (this.props)
for (let id in this.props)
result.push([+id, this.props[id]]);
return result;
}
/// Balance the direct children of this tree, producing a copy of
/// which may have children grouped into subtrees with type
/// [`NodeType.none`](#common.NodeType^none).
balance(config = {}) {
return this.children.length <= 8 ? this : 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)));
}
/// Build a tree from a postfix-ordered buffer of node information,
/// or a cursor over such a buffer.
static build(data) {
return buildTree(data);
}
};
Tree.empty = new Tree(NodeType.none, [], [], 0);
var FlatBufferCursor = class _FlatBufferCursor {
constructor(buffer, index) {
this.buffer = buffer;
this.index = index;
}
get id() {
return this.buffer[this.index - 4];
}
get start() {
return this.buffer[this.index - 3];
}
get end() {
return this.buffer[this.index - 2];
}
get size() {
return this.buffer[this.index - 1];
}
get pos() {
return this.index;
}
next() {
this.index -= 4;
}
fork() {
return new _FlatBufferCursor(this.buffer, this.index);
}
};
var TreeBuffer = class _TreeBuffer {
/// Create a tree buffer.
constructor(buffer, length, set) {
this.buffer = buffer;
this.length = length;
this.set = set;
}
/// @internal
get type() {
return NodeType.none;
}
/// @internal
toString() {
let result = [];
for (let index = 0; index < this.buffer.length; ) {
result.push(this.childString(index));
index = this.buffer[index + 3];
}
return result.join(",");
}
/// @internal
childString(index) {
let id = this.buffer[index], endIndex = this.buffer[index + 3];
let type = this.set.types[id], result = type.name;
if (/\W/.test(result) && !type.isError)
result = JSON.stringify(result);
index += 4;
if (endIndex == index)
return result;
let children = [];
while (index < endIndex) {
children.push(this.childString(index));
index = this.buffer[index + 3];
}
return result + "(" + children.join(",") + ")";
}
/// @internal
findChild(startIndex, endIndex, dir, pos, side) {
let { buffer } = this, pick = -1;
for (let i = startIndex; i != endIndex; i = buffer[i + 3]) {
if (checkSide(side, pos, buffer[i + 1], buffer[i + 2])) {
pick = i;
if (dir > 0)
break;
}
}
return pick;
}
/// @internal
slice(startI, endI, from) {
let b = this.buffer;
let copy = new Uint16Array(endI - startI), len = 0;
for (let i = startI, j = 0; i < endI; ) {
copy[j++] = b[i++];
copy[j++] = b[i++] - from;
let to = copy[j++] = b[i++] - from;
copy[j++] = b[i++] - startI;
len = Math.max(len, to);
}
return new _TreeBuffer(copy, len, this.set);
}
};
function checkSide(side, pos, from, to) {
switch (side) {
case -2:
return from < pos;
case -1:
return to >= pos && from < pos;
case 0:
return from < pos && to > pos;
case 1:
return from <= pos && to > pos;
case 2:
return to > pos;
case 4:
return true;
}
}
function enterUnfinishedNodesBefore(node, pos) {
let scan = node.childBefore(pos);
while (scan) {
let last = scan.lastChild;
if (!last || last.to != scan.to)
break;
if (last.type.isError && last.from == last.to) {
node = scan;
scan = last.prevSibling;
} else {
scan = last;
}
}
return node;
}
function resolveNode(node, pos, side, overlays) {
var _a;
while (node.from == node.to || (side < 1 ? node.from >= pos : node.from > pos) || (side > -1 ? node.to <= pos : node.to < pos)) {
let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
if (!parent)
return node;
node = parent;
}
let mode = overlays ? 0 : IterMode.IgnoreOverlays;
if (overlays)
for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
node = parent;
}
for (; ; ) {
let inner = node.enter(pos, side, mode);
if (!inner)
return node;
node = inner;
}
}
var TreeNode = class _TreeNode {
constructor(_tree, from, index, _parent) {
this._tree = _tree;
this.from = from;
this.index = index;
this._parent = _parent;
}
get type() {
return this._tree.type;
}
get name() {
return this._tree.type.name;
}
get to() {
return this.from + this._tree.length;
}
nextChild(i, dir, pos, side, mode = 0) {
for (let parent = this; ; ) {
for (let { children, positions } = parent._tree, e = dir > 0 ? children.length : -1; i != e; i += dir) {
let next = children[i], start = positions[i] + parent.from;
if (!checkSide(side, pos, start, start + next.length))
continue;
if (next instanceof TreeBuffer) {
if (mode & IterMode.ExcludeBuffers)
continue;
let index = next.findChild(0, next.buffer.length, dir, pos - start, side);
if (index > -1)
return new BufferNode(new BufferContext(parent, next, i, start), null, index);
} else if (mode & IterMode.IncludeAnonymous || (!next.type.isAnonymous || hasChild(next))) {
let mounted;
if (!(mode & IterMode.IgnoreMounts) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
return new _TreeNode(mounted.tree, start, i, parent);
let inner = new _TreeNode(next, start, i, parent);
return mode & IterMode.IncludeAnonymous || !inner.type.isAnonymous ? inner : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
}
}
if (mode & IterMode.IncludeAnonymous || !parent.type.isAnonymous)
return null;
if (parent.index >= 0)
i = parent.index + dir;
else
i = dir < 0 ? -1 : parent._parent._tree.children.length;
parent = parent._parent;
if (!parent)
return null;
}
}
get firstChild() {
return this.nextChild(
0,
1,
0,
4
/* Side.DontCare */
);
}
get lastChild() {
return this.nextChild(
this._tree.children.length - 1,
-1,
0,
4
/* Side.DontCare */
);
}
childAfter(pos) {
return this.nextChild(
0,
1,
pos,
2
/* Side.After */
);
}
childBefore(pos) {
return this.nextChild(
this._tree.children.length - 1,
-1,
pos,
-2
/* Side.Before */
);
}
enter(pos, side, mode = 0) {
let mounted;
if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {
let rPos = pos - this.from;
for (let { from, to } of mounted.overlay) {
if ((side > 0 ? from <= rPos : from < rPos) && (side < 0 ? to >= rPos : to > rPos))
return new _TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);
}
}
return this.nextChild(0, 1, pos, side, mode);
}
nextSignificantParent() {
let val = this;
while (val.type.isAnonymous && val._parent)
val = val._parent;
return val;
}
get parent() {
return this._parent ? this._parent.nextSignificantParent() : null;
}
get nextSibling() {
return this._parent && this.index >= 0 ? this._parent.nextChild(
this.index + 1,
1,
0,
4
/* Side.DontCare */
) : null;
}
get prevSibling() {
return this._parent && this.index >= 0 ? this._parent.nextChild(
this.index - 1,
-1,
0,
4
/* Side.DontCare */
) : null;
}
cursor(mode = 0) {
return new TreeCursor(this, mode);
}
get tree() {
return this._tree;
}
toTree() {
return this._tree;
}
resolve(pos, side = 0) {
return resolveNode(this, pos, side, false);
}
resolveInner(pos, side = 0) {
return resolveNode(this, pos, side, true);
}
enterUnfinishedNodesBefore(pos) {
return enterUnfinishedNodesBefore(this, pos);
}
getChild(type, before = null, after = null) {
let r = getChildren(this, type, before, after);
return r.length ? r[0] : null;
}
getChildren(type, before = null, after = null) {
return getChildren(this, type, before, after);
}
/// @internal
toString() {
return this._tree.toString();
}
get node() {
return this;
}
matchContext(context) {
return matchNodeContext(this, context);
}
};
function getChildren(node, type, before, after) {
let cur = node.cursor(), result = [];
if (!cur.firstChild())
return result;
if (before != null) {
while (!cur.type.is(before))
if (!cur.nextSibling())
return result;
}
for (; ; ) {
if (after != null && cur.type.is(after))
return result;
if (cur.type.is(type))
result.push(cur.node);
if (!cur.nextSibling())
return after == null ? result : [];
}
}
function matchNodeContext(node, context, i = context.length - 1) {
for (let p = node.parent; i >= 0; p = p.parent) {
if (!p)
return false;
if (!p.type.isAnonymous) {
if (context[i] && context[i] != p.name)
return false;
i--;
}
}
return true;
}
var BufferContext = class {
constructor(parent, buffer, index, start) {
this.parent = parent;
this.buffer = buffer;
this.index = index;
this.start = start;
}
};
var BufferNode = class _BufferNode {
get name() {
return this.type.name;
}
get from() {
return this.context.start + this.context.buffer.buffer[this.index + 1];
}
get to() {
return this.context.start + this.context.buffer.buffer[this.index + 2];
}
constructor(context, _parent, index) {
this.context = context;
this._parent = _parent;
this.index = index;
this.type = context.buffer.set.types[context.buffer.buffer[index]];
}
child(dir, pos, side) {
let { buffer } = this.context;
let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.context.start, side);
return index < 0 ? null : new _BufferNode(this.context, this, index);
}
get firstChild() {
return this.child(
1,
0,
4
/* Side.DontCare */
);
}
get lastChild() {
return this.child(
-1,
0,
4
/* Side.DontCare */
);
}
childAfter(pos) {
return this.child(
1,
pos,
2
/* Side.After */
);
}
childBefore(pos) {
return this.child(
-1,
pos,
-2
/* Side.Before */
);
}
enter(pos, side, mode = 0) {
if (mode & IterMode.ExcludeBuffers)
return null;
let { buffer } = this.context;
let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);
return index < 0 ? null : new _BufferNode(this.context, this, index);
}
get parent() {
return this._parent || this.context.parent.nextSignificantParent();
}
externalSibling(dir) {
return this._parent ? null : this.context.parent.nextChild(
this.context.index + dir,
dir,
0,
4
/* Side.DontCare */
);
}
get nextSibling() {
let { buffer } = this.context;
let after = buffer.buffer[this.index + 3];
if (after < (this._parent ? buffer.buffer[this._parent.index + 3] : buffer.buffer.length))
return new _BufferNode(this.context, this._parent, after);
return this.externalSibling(1);
}
get prevSibling() {
let { buffer } = this.context;
let parentStart = this._parent ? this._parent.index + 4 : 0;
if (this.index == parentStart)
return this.externalSibling(-1);
return new _BufferNode(this.context, this._parent, buffer.findChild(
parentStart,
this.index,
-1,
0,
4
/* Side.DontCare */
));
}
cursor(mode = 0) {
return new TreeCursor(this, mode);
}
get tree() {
return null;
}
toTree() {
let children = [], positions = [];
let { buffer } = this.context;
let startI = this.index + 4, endI = buffer.buffer[this.index + 3];
if (endI > startI) {
let from = buffer.buffer[this.index + 1];
children.push(buffer.slice(startI, endI, from));
positions.push(0);
}
return new Tree(this.type, children, positions, this.to - this.from);
}
resolve(pos, side = 0) {
return resolveNode(this, pos, side, false);
}
resolveInner(pos, side = 0) {
return resolveNode(this, pos, side, true);
}
enterUnfinishedNodesBefore(pos) {
return enterUnfinishedNodesBefore(this, pos);
}
/// @internal
toString() {
return this.context.buffer.childString(this.index);
}
getChild(type, before = null, after = null) {
let r = getChildren(this, type, before, after);
return r.length ? r[0] : null;
}
getChildren(type, before = null, after = null) {
return getChildren(this, type, before, after);
}
get node() {
return this;
}
matchContext(context) {
return matchNodeContext(this, context);
}
};
var TreeCursor = class {
/// Shorthand for `.type.name`.
get name() {
return this.type.name;
}
/// @internal
constructor(node, mode = 0) {
this.mode = mode;
this.buffer = null;
this.stack = [];
this.index = 0;
this.bufferNode = null;
if (node instanceof TreeNode) {
this.yieldNode(node);
} else {
this._tree = node.context.parent;
this.buffer = node.context;
for (let n = node._parent; n; n = n._parent)
this.stack.unshift(n.index);
this.bufferNode = node;
this.yieldBuf(node.index);
}
}
yieldNode(node) {
if (!node)
return false;
this._tree = node;
this.type = node.type;
this.from = node.from;
this.to = node.to;
return true;
}
yieldBuf(index, type) {
this.index = index;
let { start, buffer } = this.buffer;
this.type = type || buffer.set.types[buffer.buffer[index]];
this.from = start + buffer.buffer[index + 1];
this.to = start + buffer.buffer[index + 2];
return true;
}
yield(node) {
if (!node)
return false;
if (node instanceof TreeNode) {
this.buffer = null;
return this.yieldNode(node);
}
this.buffer = node.context;
return this.yieldBuf(node.index, node.type);
}
/// @internal
toString() {
return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
}
/// @internal
enterChild(dir, pos, side) {
if (!this.buffer)
return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode));
let { buffer } = this.buffer;
let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);
if (index < 0)
return false;
this.stack.push(this.index);
return this.yieldBuf(index);
}
/// Move the cursor to this node's first child. When this returns
/// false, the node has no child, and the cursor has not been moved.
firstChild() {
return this.enterChild(
1,
0,
4
/* Side.DontCare */
);
}
/// Move the cursor to this node's last child.
lastChild() {
return this.enterChild(
-1,
0,
4
/* Side.DontCare */
);
}
/// Move the cursor to the first child that ends after `pos`.
childAfter(pos) {
return this.enterChild(
1,
pos,
2
/* Side.After */
);
}
/// Move to the last child that starts before `pos`.
childBefore(pos) {
return this.enterChild(
-1,
pos,
-2
/* Side.Before */
);
}
/// Move the cursor to the child around `pos`. If side is -1 the
/// child may end at that position, when 1 it may start there. This
/// will also enter [overlaid](#common.MountedTree.overlay)
/// [mounted](#common.NodeProp^mounted) trees unless `overlays` is
/// set to false.
enter(pos, side, mode = this.mode) {
if (!this.buffer)
return this.yield(this._tree.enter(pos, side, mode));
return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);
}
/// Move to the node's parent node, if this isn't the top node.
parent() {
if (!this.buffer)
return this.yieldNode(this.mode & IterMode.IncludeAnonymous ? this._tree._parent : this._tree.parent);
if (this.stack.length)
return this.yieldBuf(this.stack.pop());
let parent = this.mode & IterMode.IncludeAnonymous ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
this.buffer = null;
return this.yieldNode(parent);
}
/// @internal
sibling(dir) {
if (!this.buffer)
return !this._tree._parent ? false : this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4, this.mode));
let { buffer } = this.buffer, d = this.stack.length - 1;
if (dir < 0) {
let parentStart = d < 0 ? 0 : this.stack[d] + 4;
if (this.index != parentStart)
return this.yieldBuf(buffer.findChild(
parentStart,
this.index,
-1,
0,
4
/* Side.DontCare */
));
} else {
let after = buffer.buffer[this.index + 3];
if (after < (d < 0 ? buffer.buffer.length : buffer.buffer[this.stack[d] + 3]))
return this.yieldBuf(after);
}
return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4, this.mode)) : false;
}
/// Move to this node's next sibling, if any.
nextSibling() {
return this.sibling(1);
}
/// Move to this node's previous sibling, if any.
prevSibling() {
return this.sibling(-1);
}
atLastNode(dir) {
let index, parent, { buffer } = this;
if (buffer) {
if (dir > 0) {
if (this.index < buffer.buffer.buffer.length)
return false;
} else {
for (let i = 0; i < this.index; i++)
if (buffer.buffer.buffer[i + 3] < this.index)
return false;
}
({ index, parent } = buffer);
} else {
({ index, _parent: parent } = this._tree);
}
for (; parent; { index, _parent: parent } = parent) {
if (index > -1)
for (let i = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i != e; i += dir) {
let child = parent._tree.children[i];
if (this.mode & IterMode.IncludeAnonymous || child instanceof TreeBuffer || !child.type.isAnonymous || hasChild(child))
return false;
}
}
return true;
}
move(dir, enter) {
if (enter && this.enterChild(
dir,
0,
4
/* Side.DontCare */
))
return true;
for (; ; ) {
if (this.sibling(dir))
return true;
if (this.atLastNode(dir) || !this.parent())
return false;
}
}
/// Move to the next node in a
/// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
/// traversal, going from a node to its first child or, if the
/// current node is empty or `enter` is false, its next sibling or
/// the next sibling of the first parent node that has one.
next(enter = true) {
return this.move(1, enter);
}
/// Move to the next node in a last-to-first pre-order traveral. A
/// node is followed by its last child or, if it has none, its
/// previous sibling or the previous sibling of the first parent
/// node that has one.
prev(enter = true) {
return this.move(-1, enter);
}
/// Move the cursor to the innermost node that covers `pos`. If
/// `side` is -1, it will enter