@kerebron/legacy-compat 0.7.6 → 0.7.7

package/dist/index-gJXS1DPx.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-gJXS1DPx.cjs","sources":["../../../node_modules/.deno/@lezer+css@1.3.0/node_modules/@lezer/css/dist/index.js","../../../node_modules/.deno/@codemirror+lang-css@6.3.1/node_modules/@codemirror/lang-css/dist/index.js"],"sourcesContent":["import { ExternalTokenizer, LRParser, LocalTokenGroup } from '@lezer/lr';\nimport { styleTags, tags } from '@lezer/highlight';\n\n// This file was generated by lezer-generator. You probably shouldn't edit it.\nconst descendantOp = 122,\n  Unit = 1,\n  identifier = 123,\n  callee = 124,\n  VariableName = 2,\n  queryIdentifier = 125,\n  queryVariableName = 3,\n  QueryCallee = 4;\n\n/* Hand-written tokenizers for CSS tokens that can't be\n   expressed by Lezer's built-in tokenizer. */\n\nconst space = [9, 10, 11, 12, 13, 32, 133, 160, 5760, 8192, 8193, 8194, 8195, 8196, 8197,\n               8198, 8199, 8200, 8201, 8202, 8232, 8233, 8239, 8287, 12288];\nconst colon = 58, parenL = 40, underscore = 95, bracketL = 91, dash = 45, period = 46,\n      hash = 35, percent = 37, ampersand = 38, backslash = 92, newline = 10, asterisk = 42;\n\nfunction isAlpha(ch) { return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch >= 161 }\n\nfunction isDigit(ch) { return ch >= 48 && ch <= 57 }\n\nfunction isHex(ch) { return isDigit(ch) || ch >= 97 && ch <= 102 || ch >= 65 && ch <= 70 }\n\nconst identifierTokens = (id, varName, callee) => (input, stack) => {\n  for (let inside = false, dashes = 0, i = 0;; i++) {\n    let {next} = input;\n    if (isAlpha(next) || next == dash || next == underscore || (inside && isDigit(next))) {\n      if (!inside && (next != dash || i > 0)) inside = true;\n      if (dashes === i && next == dash) dashes++;\n      input.advance();\n    } else if (next == backslash && input.peek(1) != newline) {\n      input.advance();\n      if (isHex(input.next)) {\n        do { input.advance(); } while (isHex(input.next))\n        if (input.next == 32) input.advance();\n      } else if (input.next > -1) {\n        input.advance();\n      }\n      inside = true;\n    } else {\n      if (inside) input.acceptToken(\n        dashes == 2 && stack.canShift(VariableName) ? varName : next == parenL ? callee : id\n      );\n      break\n    }\n  }\n};\n\nconst identifiers = new ExternalTokenizer(\n  identifierTokens(identifier, VariableName, callee)\n);\nconst queryIdentifiers = new ExternalTokenizer(\n  identifierTokens(queryIdentifier, queryVariableName, QueryCallee)\n);\n\nconst descendant = new ExternalTokenizer(input => {\n  if (space.includes(input.peek(-1))) {\n    let {next} = input;\n    if (isAlpha(next) || next == underscore || next == hash || next == period ||\n        next == asterisk || next == bracketL || next == colon && isAlpha(input.peek(1)) ||\n        next == dash || next == ampersand)\n      input.acceptToken(descendantOp);\n  }\n});\n\nconst unitToken = new ExternalTokenizer(input => {\n  if (!space.includes(input.peek(-1))) {\n    let {next} = input;\n    if (next == percent) { input.advance(); input.acceptToken(Unit); }\n    if (isAlpha(next)) {\n      do { input.advance(); } while (isAlpha(input.next) || isDigit(input.next))\n      input.acceptToken(Unit);\n    }\n  }\n});\n\nconst cssHighlighting = styleTags({\n  \"AtKeyword import charset namespace keyframes media supports\": tags.definitionKeyword,\n  \"from to selector\": tags.keyword,\n  NamespaceName: tags.namespace,\n  KeyframeName: tags.labelName,\n  KeyframeRangeName: tags.operatorKeyword,\n  TagName: tags.tagName,\n  ClassName: tags.className,\n  PseudoClassName: tags.constant(tags.className),\n  IdName: tags.labelName,\n  \"FeatureName PropertyName\": tags.propertyName,\n  AttributeName: tags.attributeName,\n  NumberLiteral: tags.number,\n  KeywordQuery: tags.keyword,\n  UnaryQueryOp: tags.operatorKeyword,\n  \"CallTag ValueName\": tags.atom,\n  VariableName: tags.variableName,\n  Callee: tags.operatorKeyword,\n  Unit: tags.unit,\n  \"UniversalSelector NestingSelector\": tags.definitionOperator,\n  \"MatchOp CompareOp\": tags.compareOperator,\n  \"ChildOp SiblingOp, LogicOp\": tags.logicOperator,\n  BinOp: tags.arithmeticOperator,\n  Important: tags.modifier,\n  Comment: tags.blockComment,\n  ColorLiteral: tags.color,\n  \"ParenthesizedContent StringLiteral\": tags.string,\n  \":\": tags.punctuation,\n  \"PseudoOp #\": tags.derefOperator,\n  \"; ,\": tags.separator,\n  \"( )\": tags.paren,\n  \"[ ]\": tags.squareBracket,\n  \"{ }\": tags.brace\n});\n\n// This file was generated by lezer-generator. You probably shouldn't edit it.\nconst spec_callee = {__proto__:null,lang:38, \"nth-child\":38, \"nth-last-child\":38, \"nth-of-type\":38, \"nth-last-of-type\":38, dir:38, \"host-context\":38, if:84, url:124, \"url-prefix\":124, domain:124, regexp:124};\nconst spec_queryIdentifier = {__proto__:null,or:98, and:98, not:106, only:106, layer:170};\nconst spec_QueryCallee = {__proto__:null,selector:112, layer:166};\nconst spec_AtKeyword = {__proto__:null,\"@import\":162, \"@media\":174, \"@charset\":178, \"@namespace\":182, \"@keyframes\":188, \"@supports\":200, \"@scope\":204};\nconst spec_identifier = {__proto__:null,to:207};\nconst parser = LRParser.deserialize({\n  version: 14,\n  states: \"EbQYQdOOO#qQdOOP#xO`OOOOQP'#Cf'#CfOOQP'#Ce'#CeO#}QdO'#ChO$nQaO'#CcO$xQdO'#CkO%TQdO'#DpO%YQdO'#DrO%_QdO'#DuO%_QdO'#DxOOQP'#FV'#FVO&eQhO'#EhOOQS'#FU'#FUOOQS'#Ek'#EkQYQdOOO&lQdO'#EOO&PQhO'#EUO&lQdO'#EWO'aQdO'#EYO'lQdO'#E]O'tQhO'#EcO(VQdO'#EeO(bQaO'#CfO)VQ`O'#D{O)[Q`O'#F`O)gQdO'#F`QOQ`OOP)qO&jO'#CaPOOO)C@t)C@tOOQP'#Cj'#CjOOQP,59S,59SO#}QdO,59SO)|QdO,59VO%TQdO,5:[O%YQdO,5:^O%_QdO,5:aO%_QdO,5:cO%_QdO,5:dO%_QdO'#ErO*XQ`O,58}O*aQdO'#DzOOQS,58},58}OOQP'#Cn'#CnOOQO'#Dn'#DnOOQP,59V,59VO*hQ`O,59VO*mQ`O,59VOOQP'#Dq'#DqOOQP,5:[,5:[OOQO'#Ds'#DsO*rQpO,5:^O+]QaO,5:aO+sQaO,5:dOOQW'#DZ'#DZO,ZQhO'#DdO,xQhO'#FaO'tQhO'#DbO-WQ`O'#DhOOQW'#F['#F[O-]Q`O,5;SO-eQ`O'#DeOOQS-E8i-E8iOOQ['#Cs'#CsO-jQdO'#CtO.QQdO'#CzO.hQdO'#C}O/OQ!pO'#DPO1RQ!jO,5:jOOQO'#DU'#DUO*mQ`O'#DTO1cQ!nO'#FXO3`Q`O'#DVO3eQ`O'#DkOOQ['#FX'#FXO-`Q`O,5:pO3jQ!bO,5:rOOQS'#E['#E[O3rQ`O,5:tO3wQdO,5:tOOQO'#E_'#E_O4PQ`O,5:wO4UQhO,5:}O%_QdO'#DgOOQS,5;P,5;PO-eQ`O,5;PO4^QdO,5;PO4fQdO,5:gO4vQdO'#EtO5TQ`O,5;zO5TQ`O,5;zPOOO'#Ej'#EjP5`O&jO,58{POOO,58{,58{OOQP1G.n1G.nOOQP1G.q1G.qO*hQ`O1G.qO*mQ`O1G.qOOQP1G/v1G/vO5kQpO1G/xO5sQaO1G/{O6ZQaO1G/}O6qQaO1G0OO7XQaO,5;^OOQO-E8p-E8pOOQS1G.i1G.iO7cQ`O,5:fO7hQdO'#DoO7oQdO'#CrOOQP1G/x1G/xO&lQdO1G/xO7vQ!jO'#DZO8UQ!bO,59vO8^QhO,5:OOOQO'#F]'#F]O8XQ!bO,59zO'tQhO,59xO8fQhO'#EvO8sQ`O,5;{O9OQhO,59|O9uQhO'#DiOOQW,5:S,5:SOOQS1G0n1G0nOOQW,5:P,5:PO9|Q!fO'#FYOOQS'#FY'#FYOOQS'#Em'#EmO;^QdO,59`OOQ[,59`,59`O;tQdO,59fOOQ[,59f,59fO<[QdO,59iOOQ[,59i,59iOOQ[,59k,59kO&lQdO,59mO<rQhO'#EQOOQW'#EQ'#EQO=WQ`O1G0UO1[QhO1G0UOOQ[,59o,59oO'tQhO'#DXOOQ[,59q,59qO=]Q#tO,5:VOOQS1G0[1G0[OOQS1G0^1G0^OOQS1G0`1G0`O=hQ`O1G0`O=mQdO'#E`OOQS1G0c1G0cOOQS1G0i1G0iO=xQaO,5:RO-`Q`O1G0kOOQS1G0k1G0kO-eQ`O1G0kO>PQ!fO1G0ROOQO1G0R1G0ROOQO,5;`,5;`O>gQdO,5;`OOQO-E8r-E8rO>tQ`O1G1fPOOO-E8h-E8hPOOO1G.g1G.gOOQP7+$]7+$]OOQP7+%d7+%dO&lQdO7+%dOOQS1G0Q1G0QO?PQaO'#F_O?ZQ`O,5:ZO?`Q!fO'#ElO@^QdO'#FWO@hQ`O,59^O@mQ!bO7+%dO&lQdO1G/bO@uQhO1G/fOOQW1G/j1G/jOOQW1G/d1G/dOAWQhO,5;bOOQO-E8t-E8tOAfQhO'#DZOAtQhO'#F^OBPQ`O'#F^OBUQ`O,5:TOOQS-E8k-E8kOOQ[1G.z1G.zOOQ[1G/Q1G/QOOQ[1G/T1G/TOOQ[1G/X1G/XOBZQdO,5:lOOQS7+%p7+%pOB`Q`O7+%pOBeQhO'#DYOBmQ`O,59sO'tQhO,59sOOQ[1G/q1G/qOBuQ`O1G/qOOQS7+%z7+%zOBzQbO'#DPOOQO'#Eb'#EbOCYQ`O'#EaOOQO'#Ea'#EaOCeQ`O'#EwOCmQdO,5:zOOQS,5:z,5:zOOQ[1G/m1G/mOOQS7+&V7+&VO-`Q`O7+&VOCxQ!fO'#EsO&lQdO'#EsOEPQdO7+%mOOQO7+%m7+%mOOQO1G0z1G0zOEdQ!bO<<IOOElQdO'#EqOEvQ`O,5;yOOQP1G/u1G/uOOQS-E8j-E8jOFOQdO'#EpOFYQ`O,5;rOOQ]1G.x1G.xOOQP<<IO<<IOOFbQdO7+$|OOQO'#D]'#D]OFiQ!bO7+%QOFqQhO'#EoOF{Q`O,5;xO&lQdO,5;xOOQW1G/o1G/oOOQO'#ES'#ESOGTQ`O1G0WOOQS<<I[<<I[O&lQdO,59tOGnQhO1G/_OOQ[1G/_1G/_OGuQ`O1G/_OOQW-E8l-E8lOOQ[7+%]7+%]OOQO,5:{,5:{O=pQdO'#ExOCeQ`O,5;cOOQS,5;c,5;cOOQS-E8u-E8uOOQS1G0f1G0fOOQS<<Iq<<IqOG}Q!fO,5;_OOQS-E8q-E8qOOQO<<IX<<IXOOQPAN>jAN>jOIUQaO,5;]OOQO-E8o-E8oOI`QdO,5;[OOQO-E8n-E8nOOQW<<Hh<<HhOOQW<<Hl<<HlOIjQhO<<HlOI{QhO,5;ZOJWQ`O,5;ZOOQO-E8m-E8mOJ]QdO1G1dOBZQdO'#EuOJgQ`O7+%rOOQW7+%r7+%rOJoQ!bO1G/`OOQ[7+$y7+$yOJzQhO7+$yPKRQ`O'#EnOOQO,5;d,5;dOOQO-E8v-E8vOOQS1G0}1G0}OKWQ`OAN>WO&lQdO1G0uOK]Q`O7+'OOOQO,5;a,5;aOOQO-E8s-E8sOOQW<<I^<<I^OOQ[<<He<<HePOQW,5;Y,5;YOOQWG23rG23rOKeQdO7+&a\",\n  stateData: \"Kx~O#sOS#tQQ~OW[OZ[O]TO`VOaVOi]OjWOmXO!jYO!mZO!saO!ybO!{cO!}dO#QeO#WfO#YgO#oRO~OQiOW[OZ[O]TO`VOaVOi]OjWOmXO!jYO!mZO!saO!ybO!{cO!}dO#QeO#WfO#YgO#ohO~O#m$SP~P!dO#tmO~O#ooO~O]qO`rOarOjsOmtO!juO!mwO#nvO~OpzO!^xO~P$SOc!QO#o|O#p}O~O#o!RO~O#o!TO~OW[OZ[O]TO`VOaVOjWOmXO!jYO!mZO#oRO~OS!]Oe!YO!V![O!Y!`O#q!XOp$TP~Ok$TP~P&POQ!jOe!cOm!dOp!eOr!mOt!mOz!kO!`!lO#o!bO#p!hO#}!fO~Ot!qO!`!lO#o!pO~Ot!sO#o!sO~OS!]Oe!YO!V![O!Y!`O#q!XO~Oe!vOpzO#Z!xO~O]YX`YX`!pXaYXjYXmYXpYX!^YX!jYX!mYX#nYX~O`!zO~Ok!{O#m$SXo$SX~O#m$SXo$SX~P!dO#u#OO#v#OO#w#QO~Oc#UO#o|O#p}O~OpzO!^xO~Oo$SP~P!dOe#`O~Oe#aO~Ol#bO!h#cO~O]qO`rOarOjsOmtO~Op!ia!^!ia!j!ia!m!ia#n!iad!ia~P*zOp!la!^!la!j!la!m!la#n!lad!la~P*zOR#gOS!]Oe!YOr#gOt#gO!V![O!Y!`O#q#dO#}!fO~O!R#iO!^#jOk$TXp$TX~Oe#mO~Ok#oOpzO~Oe!vO~O]#rO`#rOd#uOi#rOj#rOk#rO~P&lO]#rO`#rOi#rOj#rOk#rOl#wO~P&lO]#rO`#rOi#rOj#rOk#rOo#yO~P&lOP#zOSsXesXksXvsX!VsX!YsX!usX!wsX#qsX!TsXQsX]sX`sXdsXisXjsXmsXpsXrsXtsXzsX!`sX#osX#psX#}sXlsXosX!^sX!qsX#msX~Ov#{O!u#|O!w#}Ok$TP~P'tOe#aOS#{Xk#{Xv#{X!V#{X!Y#{X!u#{X!w#{X#q#{XQ#{X]#{X`#{Xd#{Xi#{Xj#{Xm#{Xp#{Xr#{Xt#{Xz#{X!`#{X#o#{X#p#{X#}#{Xl#{Xo#{X!^#{X!q#{X#m#{X~Oe$RO~Oe$TO~Ok$VOv#{O~Ok$WO~Ot$XO!`!lO~Op$YO~OpzO!R#iO~OpzO#Z$`O~O!q$bOk!oa#m!oao!oa~P&lOk#hX#m#hXo#hX~P!dOk!{O#m$Sao$Sa~O#u#OO#v#OO#w$hO~Ol$jO!h$kO~Op!ii!^!ii!j!ii!m!ii#n!iid!ii~P*zOp!ki!^!ki!j!ki!m!ki#n!kid!ki~P*zOp!li!^!li!j!li!m!li#n!lid!li~P*zOp#fa!^#fa~P$SOo$lO~Od$RP~P%_Od#zP~P&lO`!PXd}X!R}X!T!PX~O`$sO!T$tO~Od$uO!R#iO~Ok#jXp#jX!^#jX~P'tO!^#jOk$Tap$Ta~O!R#iOk!Uap!Ua!^!Uad!Ua`!Ua~OS!]Oe!YO!V![O!Y!`O#q$yO~Od$QP~P9dOv#{OQ#|X]#|X`#|Xd#|Xe#|Xi#|Xj#|Xk#|Xm#|Xp#|Xr#|Xt#|Xz#|X!`#|X#o#|X#p#|X#}#|Xl#|Xo#|X~O]#rO`#rOd%OOi#rOj#rOk#rO~P&lO]#rO`#rOi#rOj#rOk#rOl%PO~P&lO]#rO`#rOi#rOj#rOk#rOo%QO~P&lOe%SOS!tXk!tX!V!tX!Y!tX#q!tX~Ok%TO~Od%YOt%ZO!a%ZO~Ok%[O~Oo%cO#o%^O#}%]O~Od%dO~P$SOv#{O!^%hO!q%jOk!oi#m!oio!oi~P&lOk#ha#m#hao#ha~P!dOk!{O#m$Sio$Si~O!^%mOd$RX~P$SOd%oO~Ov#{OQ#`Xd#`Xe#`Xm#`Xp#`Xr#`Xt#`Xz#`X!^#`X!`#`X#o#`X#p#`X#}#`X~O!^%qOd#zX~P&lOd%sO~Ol%tOv#{O~OR#gOr#gOt#gO#q%vO#}!fO~O!R#iOk#jap#ja!^#ja~O`!PXd}X!R}X!^}X~O!R#iO!^%xOd$QX~O`%zO~Od%{O~O#o%|O~Ok&OO~O`&PO!R#iO~Od&ROk&QO~Od&UO~OP#zOpsX!^sXdsX~O#}%]Op#TX!^#TX~OpzO!^&WO~Oo&[O#o%^O#}%]O~Ov#{OQ#gXe#gXk#gXm#gXp#gXr#gXt#gXz#gX!^#gX!`#gX!q#gX#m#gX#o#gX#p#gX#}#gXo#gX~O!^%hO!q&`Ok!oq#m!oqo!oq~P&lOl&aOv#{O~Od#eX!^#eX~P%_O!^%mOd$Ra~Od#dX!^#dX~P&lO!^%qOd#za~Od&fO~P&lOd&gO!T&hO~Od#cX!^#cX~P9dO!^%xOd$Qa~O]&mOd&oO~OS#bae#ba!V#ba!Y#ba#q#ba~Od&qO~PG]Od&qOk&rO~Ov#{OQ#gae#gak#gam#gap#gar#gat#gaz#ga!^#ga!`#ga!q#ga#m#ga#o#ga#p#ga#}#gao#ga~Od#ea!^#ea~P$SOd#da!^#da~P&lOR#gOr#gOt#gO#q%vO#}%]O~O!R#iOd#ca!^#ca~O`&xO~O!^%xOd$Qi~P&lO]&mOd&|O~Ov#{Od|ik|i~Od&}O~PG]Ok'OO~Od'PO~O!^%xOd$Qq~Od#cq!^#cq~P&lO#s!a#t#}]#}v!m~\",\n  goto: \"2h$UPPPPP$VP$YP$c$uP$cP%X$cPP%_PPP%e%o%oPPPPP%oPP%oP&]P%oP%o'W%oP't'w'}'}(^'}P'}P'}P'}'}P(m'}(yP(|PP)p)v$c)|$c*SP$cP$c$cP*Y*{+YP$YP+aP+dP$YP$YP$YP+j$YP+m+p+s+z$YP$YPP$YP,P,V,f,|-[-b-l-r-x.O.U.`.f.l.rPPPPPPPPPPP.x/R/w/z0|P1U1u2O2R2U2[RnQ_^OP`kz!{$dq[OPYZ`kuvwxz!v!{#`$d%mqSOPYZ`kuvwxz!v!{#`$d%mQpTR#RqQ!OVR#SrQ#S!QS$Q!i!jR$i#U!V!mac!c!d!e!z#a#c#t#v#x#{$a$k$p$s%h%i%q%u%z&P&d&l&x'Q!U!mac!c!d!e!z#a#c#t#v#x#{$a$k$p$s%h%i%q%u%z&P&d&l&x'QU#g!Y$t&hU%`$Y%b&WR&V%_!V!iac!c!d!e!z#a#c#t#v#x#{$a$k$p$s%h%i%q%u%z&P&d&l&x'QR$S!kQ%W$RR&S%Xk!^]bf!Y![!g#i#j#m$P$R%X%xQ#e!YQ${#mQ%w$tQ&j%xR&w&hQ!ygQ#p!`Q$^!xR%f$`R#n!]!U!mac!c!d!e!z#a#c#t#v#x#{$a$k$p$s%h%i%q%u%z&P&d&l&x'QQ!qdR$X!rQ!PVR#TrQ#S!PR$i#TQ!SWR#VsQ!UXR#WtQ{UQ!wgQ#^yQ#o!_Q$U!nQ$[!uQ$_!yQ%e$^Q&Y%aQ&]%fR&v&XSjPzQ!}kQ$c!{R%k$dZiPkz!{$dR$P!gQ%}%SR&z&mR!rdR!teR$Z!tS%a$Y%bR&t&WV%_$Y%b&WQ#PmR$g#PQ`OSkPzU!a`k$dR$d!{Q$p#aY%p$p%u&d&l'QQ%u$sQ&d%qQ&l%zR'Q&xQ#t!cQ#v!dQ#x!eV$}#t#v#xQ%X$RR&T%XQ%y$zS&k%y&yR&y&lQ%r$pR&e%rQ%n$mR&c%nQyUR#]yQ%i$aR&_%iQ!|jS$e!|$fR$f!}Q&n%}R&{&nQ#k!ZR$x#kQ%b$YR&Z%bQ&X%aR&u&X__OP`kz!{$d^UOP`kz!{$dQ!VYQ!WZQ#XuQ#YvQ#ZwQ#[xQ$]!vQ$m#`R&b%mR$q#aQ!gaQ!oc[#q!c!d!e#t#v#xQ$a!zd$o#a$p$s%q%u%z&d&l&x'QQ$r#cQ%R#{S%g$a%iQ%l$kQ&^%hR&p&P]#s!c!d!e#t#v#xW!Z]b!g$PQ!ufQ#f!YQ#l![Q$v#iQ$w#jQ$z#mS%V$R%XR&i%xQ#h!YQ%w$tR&w&hR$|#mR$n#`QlPR#_zQ!_]Q!nbQ$O!gR%U$P\",\n  nodeNames: \"⚠ Unit VariableName VariableName QueryCallee Comment StyleSheet RuleSet UniversalSelector TagSelector TagName NestingSelector ClassSelector . ClassName PseudoClassSelector : :: PseudoClassName PseudoClassName ) ( ArgList ValueName ParenthesizedValue AtKeyword # ; ] [ BracketedValue } { BracedValue ColorLiteral NumberLiteral StringLiteral BinaryExpression BinOp CallExpression Callee IfExpression if ArgList IfBranch KeywordQuery FeatureQuery FeatureName BinaryQuery LogicOp ComparisonQuery CompareOp UnaryQuery UnaryQueryOp ParenthesizedQuery SelectorQuery selector ParenthesizedSelector CallQuery ArgList , CallLiteral CallTag ParenthesizedContent PseudoClassName ArgList IdSelector IdName AttributeSelector AttributeName MatchOp ChildSelector ChildOp DescendantSelector SiblingSelector SiblingOp Block Declaration PropertyName Important ImportStatement import Layer layer LayerName layer MediaStatement media CharsetStatement charset NamespaceStatement namespace NamespaceName KeyframesStatement keyframes KeyframeName KeyframeList KeyframeSelector KeyframeRangeName SupportsStatement supports ScopeStatement scope to AtRule Styles\",\n  maxTerm: 143,\n  nodeProps: [\n    [\"isolate\", -2,5,36,\"\"],\n    [\"openedBy\", 20,\"(\",28,\"[\",31,\"{\"],\n    [\"closedBy\", 21,\")\",29,\"]\",32,\"}\"]\n  ],\n  propSources: [cssHighlighting],\n  skippedNodes: [0,5,106],\n  repeatNodeCount: 15,\n  tokenData: \"JQ~R!YOX$qX^%i^p$qpq%iqr({rs-ust/itu6Wuv$qvw7Qwx7cxy9Qyz9cz{9h{|:R|}>t}!O?V!O!P?t!P!Q@]!Q![AU![!]BP!]!^B{!^!_C^!_!`DY!`!aDm!a!b$q!b!cEn!c!}$q!}#OG{#O#P$q#P#QH^#Q#R6W#R#o$q#o#pHo#p#q6W#q#rIQ#r#sIc#s#y$q#y#z%i#z$f$q$f$g%i$g#BY$q#BY#BZ%i#BZ$IS$q$IS$I_%i$I_$I|$q$I|$JO%i$JO$JT$q$JT$JU%i$JU$KV$q$KV$KW%i$KW&FU$q&FU&FV%i&FV;'S$q;'S;=`Iz<%lO$q`$tSOy%Qz;'S%Q;'S;=`%c<%lO%Q`%VS!a`Oy%Qz;'S%Q;'S;=`%c<%lO%Q`%fP;=`<%l%Q~%nh#s~OX%QX^'Y^p%Qpq'Yqy%Qz#y%Q#y#z'Y#z$f%Q$f$g'Y$g#BY%Q#BY#BZ'Y#BZ$IS%Q$IS$I_'Y$I_$I|%Q$I|$JO'Y$JO$JT%Q$JT$JU'Y$JU$KV%Q$KV$KW'Y$KW&FU%Q&FU&FV'Y&FV;'S%Q;'S;=`%c<%lO%Q~'ah#s~!a`OX%QX^'Y^p%Qpq'Yqy%Qz#y%Q#y#z'Y#z$f%Q$f$g'Y$g#BY%Q#BY#BZ'Y#BZ$IS%Q$IS$I_'Y$I_$I|%Q$I|$JO'Y$JO$JT%Q$JT$JU'Y$JU$KV%Q$KV$KW'Y$KW&FU%Q&FU&FV'Y&FV;'S%Q;'S;=`%c<%lO%Qj)OUOy%Qz#]%Q#]#^)b#^;'S%Q;'S;=`%c<%lO%Qj)gU!a`Oy%Qz#a%Q#a#b)y#b;'S%Q;'S;=`%c<%lO%Qj*OU!a`Oy%Qz#d%Q#d#e*b#e;'S%Q;'S;=`%c<%lO%Qj*gU!a`Oy%Qz#c%Q#c#d*y#d;'S%Q;'S;=`%c<%lO%Qj+OU!a`Oy%Qz#f%Q#f#g+b#g;'S%Q;'S;=`%c<%lO%Qj+gU!a`Oy%Qz#h%Q#h#i+y#i;'S%Q;'S;=`%c<%lO%Qj,OU!a`Oy%Qz#T%Q#T#U,b#U;'S%Q;'S;=`%c<%lO%Qj,gU!a`Oy%Qz#b%Q#b#c,y#c;'S%Q;'S;=`%c<%lO%Qj-OU!a`Oy%Qz#h%Q#h#i-b#i;'S%Q;'S;=`%c<%lO%Qj-iS!qY!a`Oy%Qz;'S%Q;'S;=`%c<%lO%Q~-xWOY-uZr-urs.bs#O-u#O#P.g#P;'S-u;'S;=`/c<%lO-u~.gOt~~.jRO;'S-u;'S;=`.s;=`O-u~.vXOY-uZr-urs.bs#O-u#O#P.g#P;'S-u;'S;=`/c;=`<%l-u<%lO-u~/fP;=`<%l-uj/nYjYOy%Qz!Q%Q!Q![0^![!c%Q!c!i0^!i#T%Q#T#Z0^#Z;'S%Q;'S;=`%c<%lO%Qj0cY!a`Oy%Qz!Q%Q!Q![1R![!c%Q!c!i1R!i#T%Q#T#Z1R#Z;'S%Q;'S;=`%c<%lO%Qj1WY!a`Oy%Qz!Q%Q!Q![1v![!c%Q!c!i1v!i#T%Q#T#Z1v#Z;'S%Q;'S;=`%c<%lO%Qj1}YrY!a`Oy%Qz!Q%Q!Q![2m![!c%Q!c!i2m!i#T%Q#T#Z2m#Z;'S%Q;'S;=`%c<%lO%Qj2tYrY!a`Oy%Qz!Q%Q!Q![3d![!c%Q!c!i3d!i#T%Q#T#Z3d#Z;'S%Q;'S;=`%c<%lO%Qj3iY!a`Oy%Qz!Q%Q!Q![4X![!c%Q!c!i4X!i#T%Q#T#Z4X#Z;'S%Q;'S;=`%c<%lO%Qj4`YrY!a`Oy%Qz!Q%Q!Q![5O![!c%Q!c!i5O!i#T%Q#T#Z5O#Z;'S%Q;'S;=`%c<%lO%Qj5TY!a`Oy%Qz!Q%Q!Q![5s![!c%Q!c!i5s!i#T%Q#T#Z5s#Z;'S%Q;'S;=`%c<%lO%Qj5zSrY!a`Oy%Qz;'S%Q;'S;=`%c<%lO%Qd6ZUOy%Qz!_%Q!_!`6m!`;'S%Q;'S;=`%c<%lO%Qd6tS!hS!a`Oy%Qz;'S%Q;'S;=`%c<%lO%Qb7VSZQOy%Qz;'S%Q;'S;=`%c<%lO%Q~7fWOY7cZw7cwx.bx#O7c#O#P8O#P;'S7c;'S;=`8z<%lO7c~8RRO;'S7c;'S;=`8[;=`O7c~8_XOY7cZw7cwx.bx#O7c#O#P8O#P;'S7c;'S;=`8z;=`<%l7c<%lO7c~8}P;=`<%l7cj9VSeYOy%Qz;'S%Q;'S;=`%c<%lO%Q~9hOd~n9oUWQvWOy%Qz!_%Q!_!`6m!`;'S%Q;'S;=`%c<%lO%Qj:YWvW!mQOy%Qz!O%Q!O!P:r!P!Q%Q!Q![=w![;'S%Q;'S;=`%c<%lO%Qj:wU!a`Oy%Qz!Q%Q!Q![;Z![;'S%Q;'S;=`%c<%lO%Qj;bY!a`#}YOy%Qz!Q%Q!Q![;Z![!g%Q!g!h<Q!h#X%Q#X#Y<Q#Y;'S%Q;'S;=`%c<%lO%Qj<VY!a`Oy%Qz{%Q{|<u|}%Q}!O<u!O!Q%Q!Q![=^![;'S%Q;'S;=`%c<%lO%Qj<zU!a`Oy%Qz!Q%Q!Q![=^![;'S%Q;'S;=`%c<%lO%Qj=eU!a`#}YOy%Qz!Q%Q!Q![=^![;'S%Q;'S;=`%c<%lO%Qj>O[!a`#}YOy%Qz!O%Q!O!P;Z!P!Q%Q!Q![=w![!g%Q!g!h<Q!h#X%Q#X#Y<Q#Y;'S%Q;'S;=`%c<%lO%Qj>yS!^YOy%Qz;'S%Q;'S;=`%c<%lO%Qj?[WvWOy%Qz!O%Q!O!P:r!P!Q%Q!Q![=w![;'S%Q;'S;=`%c<%lO%Qj?yU]YOy%Qz!Q%Q!Q![;Z![;'S%Q;'S;=`%c<%lO%Q~@bTvWOy%Qz{@q{;'S%Q;'S;=`%c<%lO%Q~@xS!a`#t~Oy%Qz;'S%Q;'S;=`%c<%lO%QjAZ[#}YOy%Qz!O%Q!O!P;Z!P!Q%Q!Q![=w![!g%Q!g!h<Q!h#X%Q#X#Y<Q#Y;'S%Q;'S;=`%c<%lO%QjBUU`YOy%Qz![%Q![!]Bh!];'S%Q;'S;=`%c<%lO%QbBoSaQ!a`Oy%Qz;'S%Q;'S;=`%c<%lO%QjCQSkYOy%Qz;'S%Q;'S;=`%c<%lO%QhCcU!TWOy%Qz!_%Q!_!`Cu!`;'S%Q;'S;=`%c<%lO%QhC|S!TW!a`Oy%Qz;'S%Q;'S;=`%c<%lO%QlDaS!TW!hSOy%Qz;'S%Q;'S;=`%c<%lO%QjDtV!jQ!TWOy%Qz!_%Q!_!`Cu!`!aEZ!a;'S%Q;'S;=`%c<%lO%QbEbS!jQ!a`Oy%Qz;'S%Q;'S;=`%c<%lO%QjEqYOy%Qz}%Q}!OFa!O!c%Q!c!}GO!}#T%Q#T#oGO#o;'S%Q;'S;=`%c<%lO%QjFfW!a`Oy%Qz!c%Q!c!}GO!}#T%Q#T#oGO#o;'S%Q;'S;=`%c<%lO%QjGV[iY!a`Oy%Qz}%Q}!OGO!O!Q%Q!Q![GO![!c%Q!c!}GO!}#T%Q#T#oGO#o;'S%Q;'S;=`%c<%lO%QjHQSmYOy%Qz;'S%Q;'S;=`%c<%lO%QnHcSl^Oy%Qz;'S%Q;'S;=`%c<%lO%QjHtSpYOy%Qz;'S%Q;'S;=`%c<%lO%QjIVSoYOy%Qz;'S%Q;'S;=`%c<%lO%QfIhU!mQOy%Qz!_%Q!_!`6m!`;'S%Q;'S;=`%c<%lO%Q`I}P;=`<%l$q\",\n  tokenizers: [descendant, unitToken, identifiers, queryIdentifiers, 1, 2, 3, 4, new LocalTokenGroup(\"m~RRYZ[z{a~~g~aO#v~~dP!P!Qg~lO#w~~\", 28, 129)],\n  topRules: {\"StyleSheet\":[0,6],\"Styles\":[1,105]},\n  specialized: [{term: 124, get: (value) => spec_callee[value] || -1},{term: 125, get: (value) => spec_queryIdentifier[value] || -1},{term: 4, get: (value) => spec_QueryCallee[value] || -1},{term: 25, get: (value) => spec_AtKeyword[value] || -1},{term: 123, get: (value) => spec_identifier[value] || -1}],\n  tokenPrec: 1963\n});\n\nexport { parser };\n","import { parser } from '@lezer/css';\nimport { syntaxTree, LRLanguage, indentNodeProp, continuedIndent, foldNodeProp, foldInside, LanguageSupport } from '@codemirror/language';\nimport { NodeWeakMap, IterMode } from '@lezer/common';\n\nlet _properties = null;\nfunction properties() {\n    if (!_properties && typeof document == \"object\" && document.body) {\n        let { style } = document.body, names = [], seen = new Set;\n        for (let prop in style)\n            if (prop != \"cssText\" && prop != \"cssFloat\") {\n                if (typeof style[prop] == \"string\") {\n                    if (/[A-Z]/.test(prop))\n                        prop = prop.replace(/[A-Z]/g, ch => \"-\" + ch.toLowerCase());\n                    if (!seen.has(prop)) {\n                        names.push(prop);\n                        seen.add(prop);\n                    }\n                }\n            }\n        _properties = names.sort().map(name => ({ type: \"property\", label: name, apply: name + \": \" }));\n    }\n    return _properties || [];\n}\nconst pseudoClasses = /*@__PURE__*/[\n    \"active\", \"after\", \"any-link\", \"autofill\", \"backdrop\", \"before\",\n    \"checked\", \"cue\", \"default\", \"defined\", \"disabled\", \"empty\",\n    \"enabled\", \"file-selector-button\", \"first\", \"first-child\",\n    \"first-letter\", \"first-line\", \"first-of-type\", \"focus\",\n    \"focus-visible\", \"focus-within\", \"fullscreen\", \"has\", \"host\",\n    \"host-context\", \"hover\", \"in-range\", \"indeterminate\", \"invalid\",\n    \"is\", \"lang\", \"last-child\", \"last-of-type\", \"left\", \"link\", \"marker\",\n    \"modal\", \"not\", \"nth-child\", \"nth-last-child\", \"nth-last-of-type\",\n    \"nth-of-type\", \"only-child\", \"only-of-type\", \"optional\", \"out-of-range\",\n    \"part\", \"placeholder\", \"placeholder-shown\", \"read-only\", \"read-write\",\n    \"required\", \"right\", \"root\", \"scope\", \"selection\", \"slotted\", \"target\",\n    \"target-text\", \"valid\", \"visited\", \"where\"\n].map(name => ({ type: \"class\", label: name }));\nconst values = /*@__PURE__*/[\n    \"above\", \"absolute\", \"activeborder\", \"additive\", \"activecaption\", \"after-white-space\",\n    \"ahead\", \"alias\", \"all\", \"all-scroll\", \"alphabetic\", \"alternate\", \"always\",\n    \"antialiased\", \"appworkspace\", \"asterisks\", \"attr\", \"auto\", \"auto-flow\", \"avoid\", \"avoid-column\",\n    \"avoid-page\", \"avoid-region\", \"axis-pan\", \"background\", \"backwards\", \"baseline\", \"below\",\n    \"bidi-override\", \"blink\", \"block\", \"block-axis\", \"bold\", \"bolder\", \"border\", \"border-box\",\n    \"both\", \"bottom\", \"break\", \"break-all\", \"break-word\", \"bullets\", \"button\", \"button-bevel\",\n    \"buttonface\", \"buttonhighlight\", \"buttonshadow\", \"buttontext\", \"calc\", \"capitalize\",\n    \"caps-lock-indicator\", \"caption\", \"captiontext\", \"caret\", \"cell\", \"center\", \"checkbox\", \"circle\",\n    \"cjk-decimal\", \"clear\", \"clip\", \"close-quote\", \"col-resize\", \"collapse\", \"color\", \"color-burn\",\n    \"color-dodge\", \"column\", \"column-reverse\", \"compact\", \"condensed\", \"contain\", \"content\",\n    \"contents\", \"content-box\", \"context-menu\", \"continuous\", \"copy\", \"counter\", \"counters\", \"cover\",\n    \"crop\", \"cross\", \"crosshair\", \"currentcolor\", \"cursive\", \"cyclic\", \"darken\", \"dashed\", \"decimal\",\n    \"decimal-leading-zero\", \"default\", \"default-button\", \"dense\", \"destination-atop\", \"destination-in\",\n    \"destination-out\", \"destination-over\", \"difference\", \"disc\", \"discard\", \"disclosure-closed\",\n    \"disclosure-open\", \"document\", \"dot-dash\", \"dot-dot-dash\", \"dotted\", \"double\", \"down\", \"e-resize\",\n    \"ease\", \"ease-in\", \"ease-in-out\", \"ease-out\", \"element\", \"ellipse\", \"ellipsis\", \"embed\", \"end\",\n    \"ethiopic-abegede-gez\", \"ethiopic-halehame-aa-er\", \"ethiopic-halehame-gez\", \"ew-resize\", \"exclusion\",\n    \"expanded\", \"extends\", \"extra-condensed\", \"extra-expanded\", \"fantasy\", \"fast\", \"fill\", \"fill-box\",\n    \"fixed\", \"flat\", \"flex\", \"flex-end\", \"flex-start\", \"footnotes\", \"forwards\", \"from\",\n    \"geometricPrecision\", \"graytext\", \"grid\", \"groove\", \"hand\", \"hard-light\", \"help\", \"hidden\", \"hide\",\n    \"higher\", \"highlight\", \"highlighttext\", \"horizontal\", \"hsl\", \"hsla\", \"hue\", \"icon\", \"ignore\",\n    \"inactiveborder\", \"inactivecaption\", \"inactivecaptiontext\", \"infinite\", \"infobackground\", \"infotext\",\n    \"inherit\", \"initial\", \"inline\", \"inline-axis\", \"inline-block\", \"inline-flex\", \"inline-grid\",\n    \"inline-table\", \"inset\", \"inside\", \"intrinsic\", \"invert\", \"italic\", \"justify\", \"keep-all\",\n    \"landscape\", \"large\", \"larger\", \"left\", \"level\", \"lighter\", \"lighten\", \"line-through\", \"linear\",\n    \"linear-gradient\", \"lines\", \"list-item\", \"listbox\", \"listitem\", \"local\", \"logical\", \"loud\", \"lower\",\n    \"lower-hexadecimal\", \"lower-latin\", \"lower-norwegian\", \"lowercase\", \"ltr\", \"luminosity\", \"manipulation\",\n    \"match\", \"matrix\", \"matrix3d\", \"medium\", \"menu\", \"menutext\", \"message-box\", \"middle\", \"min-intrinsic\",\n    \"mix\", \"monospace\", \"move\", \"multiple\", \"multiple_mask_images\", \"multiply\", \"n-resize\", \"narrower\",\n    \"ne-resize\", \"nesw-resize\", \"no-close-quote\", \"no-drop\", \"no-open-quote\", \"no-repeat\", \"none\",\n    \"normal\", \"not-allowed\", \"nowrap\", \"ns-resize\", \"numbers\", \"numeric\", \"nw-resize\", \"nwse-resize\",\n    \"oblique\", \"opacity\", \"open-quote\", \"optimizeLegibility\", \"optimizeSpeed\", \"outset\", \"outside\",\n    \"outside-shape\", \"overlay\", \"overline\", \"padding\", \"padding-box\", \"painted\", \"page\", \"paused\",\n    \"perspective\", \"pinch-zoom\", \"plus-darker\", \"plus-lighter\", \"pointer\", \"polygon\", \"portrait\",\n    \"pre\", \"pre-line\", \"pre-wrap\", \"preserve-3d\", \"progress\", \"push-button\", \"radial-gradient\", \"radio\",\n    \"read-only\", \"read-write\", \"read-write-plaintext-only\", \"rectangle\", \"region\", \"relative\", \"repeat\",\n    \"repeating-linear-gradient\", \"repeating-radial-gradient\", \"repeat-x\", \"repeat-y\", \"reset\", \"reverse\",\n    \"rgb\", \"rgba\", \"ridge\", \"right\", \"rotate\", \"rotate3d\", \"rotateX\", \"rotateY\", \"rotateZ\", \"round\",\n    \"row\", \"row-resize\", \"row-reverse\", \"rtl\", \"run-in\", \"running\", \"s-resize\", \"sans-serif\", \"saturation\",\n    \"scale\", \"scale3d\", \"scaleX\", \"scaleY\", \"scaleZ\", \"screen\", \"scroll\", \"scrollbar\", \"scroll-position\",\n    \"se-resize\", \"self-start\", \"self-end\", \"semi-condensed\", \"semi-expanded\", \"separate\", \"serif\", \"show\",\n    \"single\", \"skew\", \"skewX\", \"skewY\", \"skip-white-space\", \"slide\", \"slider-horizontal\",\n    \"slider-vertical\", \"sliderthumb-horizontal\", \"sliderthumb-vertical\", \"slow\", \"small\", \"small-caps\",\n    \"small-caption\", \"smaller\", \"soft-light\", \"solid\", \"source-atop\", \"source-in\", \"source-out\",\n    \"source-over\", \"space\", \"space-around\", \"space-between\", \"space-evenly\", \"spell-out\", \"square\", \"start\",\n    \"static\", \"status-bar\", \"stretch\", \"stroke\", \"stroke-box\", \"sub\", \"subpixel-antialiased\", \"svg_masks\",\n    \"super\", \"sw-resize\", \"symbolic\", \"symbols\", \"system-ui\", \"table\", \"table-caption\", \"table-cell\",\n    \"table-column\", \"table-column-group\", \"table-footer-group\", \"table-header-group\", \"table-row\",\n    \"table-row-group\", \"text\", \"text-bottom\", \"text-top\", \"textarea\", \"textfield\", \"thick\", \"thin\",\n    \"threeddarkshadow\", \"threedface\", \"threedhighlight\", \"threedlightshadow\", \"threedshadow\", \"to\", \"top\",\n    \"transform\", \"translate\", \"translate3d\", \"translateX\", \"translateY\", \"translateZ\", \"transparent\",\n    \"ultra-condensed\", \"ultra-expanded\", \"underline\", \"unidirectional-pan\", \"unset\", \"up\", \"upper-latin\",\n    \"uppercase\", \"url\", \"var\", \"vertical\", \"vertical-text\", \"view-box\", \"visible\", \"visibleFill\",\n    \"visiblePainted\", \"visibleStroke\", \"visual\", \"w-resize\", \"wait\", \"wave\", \"wider\", \"window\", \"windowframe\",\n    \"windowtext\", \"words\", \"wrap\", \"wrap-reverse\", \"x-large\", \"x-small\", \"xor\", \"xx-large\", \"xx-small\"\n].map(name => ({ type: \"keyword\", label: name })).concat(/*@__PURE__*/[\n    \"aliceblue\", \"antiquewhite\", \"aqua\", \"aquamarine\", \"azure\", \"beige\",\n    \"bisque\", \"black\", \"blanchedalmond\", \"blue\", \"blueviolet\", \"brown\",\n    \"burlywood\", \"cadetblue\", \"chartreuse\", \"chocolate\", \"coral\", \"cornflowerblue\",\n    \"cornsilk\", \"crimson\", \"cyan\", \"darkblue\", \"darkcyan\", \"darkgoldenrod\",\n    \"darkgray\", \"darkgreen\", \"darkkhaki\", \"darkmagenta\", \"darkolivegreen\",\n    \"darkorange\", \"darkorchid\", \"darkred\", \"darksalmon\", \"darkseagreen\",\n    \"darkslateblue\", \"darkslategray\", \"darkturquoise\", \"darkviolet\",\n    \"deeppink\", \"deepskyblue\", \"dimgray\", \"dodgerblue\", \"firebrick\",\n    \"floralwhite\", \"forestgreen\", \"fuchsia\", \"gainsboro\", \"ghostwhite\",\n    \"gold\", \"goldenrod\", \"gray\", \"grey\", \"green\", \"greenyellow\", \"honeydew\",\n    \"hotpink\", \"indianred\", \"indigo\", \"ivory\", \"khaki\", \"lavender\",\n    \"lavenderblush\", \"lawngreen\", \"lemonchiffon\", \"lightblue\", \"lightcoral\",\n    \"lightcyan\", \"lightgoldenrodyellow\", \"lightgray\", \"lightgreen\", \"lightpink\",\n    \"lightsalmon\", \"lightseagreen\", \"lightskyblue\", \"lightslategray\",\n    \"lightsteelblue\", \"lightyellow\", \"lime\", \"limegreen\", \"linen\", \"magenta\",\n    \"maroon\", \"mediumaquamarine\", \"mediumblue\", \"mediumorchid\", \"mediumpurple\",\n    \"mediumseagreen\", \"mediumslateblue\", \"mediumspringgreen\", \"mediumturquoise\",\n    \"mediumvioletred\", \"midnightblue\", \"mintcream\", \"mistyrose\", \"moccasin\",\n    \"navajowhite\", \"navy\", \"oldlace\", \"olive\", \"olivedrab\", \"orange\", \"orangered\",\n    \"orchid\", \"palegoldenrod\", \"palegreen\", \"paleturquoise\", \"palevioletred\",\n    \"papayawhip\", \"peachpuff\", \"peru\", \"pink\", \"plum\", \"powderblue\",\n    \"purple\", \"rebeccapurple\", \"red\", \"rosybrown\", \"royalblue\", \"saddlebrown\",\n    \"salmon\", \"sandybrown\", \"seagreen\", \"seashell\", \"sienna\", \"silver\", \"skyblue\",\n    \"slateblue\", \"slategray\", \"snow\", \"springgreen\", \"steelblue\", \"tan\",\n    \"teal\", \"thistle\", \"tomato\", \"turquoise\", \"violet\", \"wheat\", \"white\",\n    \"whitesmoke\", \"yellow\", \"yellowgreen\"\n].map(name => ({ type: \"constant\", label: name })));\nconst tags = /*@__PURE__*/[\n    \"a\", \"abbr\", \"address\", \"article\", \"aside\", \"b\", \"bdi\", \"bdo\", \"blockquote\", \"body\",\n    \"br\", \"button\", \"canvas\", \"caption\", \"cite\", \"code\", \"col\", \"colgroup\", \"dd\", \"del\",\n    \"details\", \"dfn\", \"dialog\", \"div\", \"dl\", \"dt\", \"em\", \"figcaption\", \"figure\", \"footer\",\n    \"form\", \"header\", \"hgroup\", \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"hr\", \"html\", \"i\", \"iframe\",\n    \"img\", \"input\", \"ins\", \"kbd\", \"label\", \"legend\", \"li\", \"main\", \"meter\", \"nav\", \"ol\", \"output\",\n    \"p\", \"pre\", \"ruby\", \"section\", \"select\", \"small\", \"source\", \"span\", \"strong\", \"sub\", \"summary\",\n    \"sup\", \"table\", \"tbody\", \"td\", \"template\", \"textarea\", \"tfoot\", \"th\", \"thead\", \"tr\", \"u\", \"ul\"\n].map(name => ({ type: \"type\", label: name }));\nconst atRules = /*@__PURE__*/[\n    \"@charset\", \"@color-profile\", \"@container\", \"@counter-style\", \"@font-face\", \"@font-feature-values\",\n    \"@font-palette-values\", \"@import\", \"@keyframes\", \"@layer\", \"@media\", \"@namespace\", \"@page\",\n    \"@position-try\", \"@property\", \"@scope\", \"@starting-style\", \"@supports\", \"@view-transition\"\n].map(label => ({ type: \"keyword\", label }));\nconst identifier = /^(\\w[\\w-]*|-\\w[\\w-]*|)$/, variable = /^-(-[\\w-]*)?$/;\nfunction isVarArg(node, doc) {\n    var _a;\n    if (node.name == \"(\" || node.type.isError)\n        node = node.parent || node;\n    if (node.name != \"ArgList\")\n        return false;\n    let callee = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.firstChild;\n    if ((callee === null || callee === void 0 ? void 0 : callee.name) != \"Callee\")\n        return false;\n    return doc.sliceString(callee.from, callee.to) == \"var\";\n}\nconst VariablesByNode = /*@__PURE__*/new NodeWeakMap();\nconst declSelector = [\"Declaration\"];\nfunction astTop(node) {\n    for (let cur = node;;) {\n        if (cur.type.isTop)\n            return cur;\n        if (!(cur = cur.parent))\n            return node;\n    }\n}\nfunction variableNames(doc, node, isVariable) {\n    if (node.to - node.from > 4096) {\n        let known = VariablesByNode.get(node);\n        if (known)\n            return known;\n        let result = [], seen = new Set, cursor = node.cursor(IterMode.IncludeAnonymous);\n        if (cursor.firstChild())\n            do {\n                for (let option of variableNames(doc, cursor.node, isVariable))\n                    if (!seen.has(option.label)) {\n                        seen.add(option.label);\n                        result.push(option);\n                    }\n            } while (cursor.nextSibling());\n        VariablesByNode.set(node, result);\n        return result;\n    }\n    else {\n        let result = [], seen = new Set;\n        node.cursor().iterate(node => {\n            var _a;\n            if (isVariable(node) && node.matchContext(declSelector) && ((_a = node.node.nextSibling) === null || _a === void 0 ? void 0 : _a.name) == \":\") {\n                let name = doc.sliceString(node.from, node.to);\n                if (!seen.has(name)) {\n                    seen.add(name);\n                    result.push({ label: name, type: \"variable\" });\n                }\n            }\n        });\n        return result;\n    }\n}\n/**\nCreate a completion source for a CSS dialect, providing a\npredicate for determining what kind of syntax node can act as a\ncompletable variable. This is used by language modes like Sass and\nLess to reuse this package's completion logic.\n*/\nconst defineCSSCompletionSource = (isVariable) => context => {\n    let { state, pos } = context, node = syntaxTree(state).resolveInner(pos, -1);\n    let isDash = node.type.isError && node.from == node.to - 1 && state.doc.sliceString(node.from, node.to) == \"-\";\n    if (node.name == \"PropertyName\" ||\n        (isDash || node.name == \"TagName\") && /^(Block|Styles)$/.test(node.resolve(node.to).name))\n        return { from: node.from, options: properties(), validFor: identifier };\n    if (node.name == \"ValueName\")\n        return { from: node.from, options: values, validFor: identifier };\n    if (node.name == \"PseudoClassName\")\n        return { from: node.from, options: pseudoClasses, validFor: identifier };\n    if (isVariable(node) || (context.explicit || isDash) && isVarArg(node, state.doc))\n        return { from: isVariable(node) || isDash ? node.from : pos,\n            options: variableNames(state.doc, astTop(node), isVariable),\n            validFor: variable };\n    if (node.name == \"TagName\") {\n        for (let { parent } = node; parent; parent = parent.parent)\n            if (parent.name == \"Block\")\n                return { from: node.from, options: properties(), validFor: identifier };\n        return { from: node.from, options: tags, validFor: identifier };\n    }\n    if (node.name == \"AtKeyword\")\n        return { from: node.from, options: atRules, validFor: identifier };\n    if (!context.explicit)\n        return null;\n    let above = node.resolve(pos), before = above.childBefore(pos);\n    if (before && before.name == \":\" && above.name == \"PseudoClassSelector\")\n        return { from: pos, options: pseudoClasses, validFor: identifier };\n    if (before && before.name == \":\" && above.name == \"Declaration\" || above.name == \"ArgList\")\n        return { from: pos, options: values, validFor: identifier };\n    if (above.name == \"Block\" || above.name == \"Styles\")\n        return { from: pos, options: properties(), validFor: identifier };\n    return null;\n};\n/**\nCSS property, variable, and value keyword completion source.\n*/\nconst cssCompletionSource = /*@__PURE__*/defineCSSCompletionSource(n => n.name == \"VariableName\");\n\n/**\nA language provider based on the [Lezer CSS\nparser](https://github.com/lezer-parser/css), extended with\nhighlighting and indentation information.\n*/\nconst cssLanguage = /*@__PURE__*/LRLanguage.define({\n    name: \"css\",\n    parser: /*@__PURE__*/parser.configure({\n        props: [\n            /*@__PURE__*/indentNodeProp.add({\n                Declaration: /*@__PURE__*/continuedIndent()\n            }),\n            /*@__PURE__*/foldNodeProp.add({\n                \"Block KeyframeList\": foldInside\n            })\n        ]\n    }),\n    languageData: {\n        commentTokens: { block: { open: \"/*\", close: \"*/\" } },\n        indentOnInput: /^\\s*\\}$/,\n        wordChars: \"-\"\n    }\n});\n/**\nLanguage support for CSS.\n*/\nfunction css() {\n    return new LanguageSupport(cssLanguage, cssLanguage.data.of({ autocomplete: cssCompletionSource }));\n}\n\nexport { css, cssCompletionSource, cssLanguage, defineCSSCompletionSource };\n"],"names":["descendantOp","Unit","identifier","callee","VariableName","queryIdentifier","queryVariableName","QueryCallee","space","colon","parenL","underscore","bracketL","dash","period","hash","percent","ampersand","backslash","newline","asterisk","isAlpha","ch","isDigit","isHex","identifierTokens","id","varName","input","stack","inside","dashes","i","next","identifiers","ExternalTokenizer","queryIdentifiers","descendant","unitToken","cssHighlighting","styleTags","tags","spec_callee","spec_queryIdentifier","spec_QueryCallee","spec_AtKeyword","spec_identifier","parser","LRParser","LocalTokenGroup","value","_properties","properties","style","names","seen","prop","name","pseudoClasses","values","atRules","label","variable","isVarArg","node","doc","_a","VariablesByNode","NodeWeakMap","declSelector","astTop","cur","variableNames","isVariable","known","result","cursor","IterMode","option","defineCSSCompletionSource","context","state","pos","syntaxTree","isDash","parent","above","before","cssCompletionSource","n","cssLanguage","LRLanguage","indentNodeProp","continuedIndent","foldNodeProp","foldInside","css","LanguageSupport"],"mappings":"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","x_google_ignoreList":[0,1]}

package/dist/index-osDEQbsO.cjs

@@ -1,2 +0,0 @@
-"use strict";const k=require("./__vite-browser-external-P9g2kRCo.cjs");class v{constructor(t,e,s,i,h,r,n,o,a,u=0,f){this.p=t,this.stack=e,this.state=s,this.reducePos=i,this.pos=h,this.score=r,this.buffer=n,this.bufferBase=o,this.curContext=a,this.lookAhead=u,this.parent=f}toString(){return`[${this.stack.filter((t,e)=>e%3==0).concat(this.state)}]@${this.pos}${this.score?"!"+this.score:""}`}static start(t,e,s=0){let i=t.parser.context;return new v(t,[],e,s,s,0,[],0,i?new y(i,i.start):null,0,null)}get context(){return this.curContext?this.curContext.context:null}pushState(t,e){this.stack.push(this.state,e,this.bufferBase+this.buffer.length),this.state=t}reduce(t){var e;let s=t>>19,i=t&65535,{parser:h}=this.p,r=this.reducePos<this.pos-25&&this.setLookAhead(this.pos),n=h.dynamicPrecedence(i);if(n&&(this.score+=n),s==0){this.pushState(h.getGoto(this.state,i,!0),this.reducePos),i<h.minRepeatTerm&&this.storeNode(i,this.reducePos,this.reducePos,r?8:4,!0),this.reduceContext(i,this.reducePos);return}let o=this.stack.length-(s-1)*3-(t&262144?6:0),a=o?this.stack[o-2]:this.p.ranges[0].from,u=this.reducePos-a;u>=2e3&&!(!((e=this.p.parser.nodeSet.types[i])===null||e===void 0)&&e.isAnonymous)&&(a==this.p.lastBigReductionStart?(this.p.bigReductionCount++,this.p.lastBigReductionSize=u):this.p.lastBigReductionSize<u&&(this.p.bigReductionCount=1,this.p.lastBigReductionStart=a,this.p.lastBigReductionSize=u));let f=o?this.stack[o-1]:0,p=this.bufferBase+this.buffer.length-f;if(i<h.minRepeatTerm||t&131072){let c=h.stateFlag(this.state,1)?this.pos:this.reducePos;this.storeNode(i,a,c,p+4,!0)}if(t&262144)this.state=this.stack[o];else{let c=this.stack[o-3];this.state=h.getGoto(c,i,!0)}for(;this.stack.length>o;)this.stack.pop();this.reduceContext(i,a)}storeNode(t,e,s,i=4,h=!1){if(t==0&&(!this.stack.length||this.stack[this.stack.length-1]<this.buffer.length+this.bufferBase)){let r=this,n=this.buffer.length;if(n==0&&r.parent&&(n=r.bufferBase-r.parent.bufferBase,r=r.parent),n>0&&r.buffer[n-4]==0&&r.buffer[n-1]>-1){if(e==s)return;if(r.buffer[n-2]>=e){r.buffer[n-2]=s;return}}}if(!h||this.pos==s)this.buffer.push(t,e,s,i);else{let r=this.buffer.length;if(r>0&&(this.buffer[r-4]!=0||this.buffer[r-1]<0)){let n=!1;for(let o=r;o>0&&this.buffer[o-2]>s;o-=4)if(this.buffer[o-1]>=0){n=!0;break}if(n)for(;r>0&&this.buffer[r-2]>s;)this.buffer[r]=this.buffer[r-4],this.buffer[r+1]=this.buffer[r-3],this.buffer[r+2]=this.buffer[r-2],this.buffer[r+3]=this.buffer[r-1],r-=4,i>4&&(i-=4)}this.buffer[r]=t,this.buffer[r+1]=e,this.buffer[r+2]=s,this.buffer[r+3]=i}}shift(t,e,s,i){if(t&131072)this.pushState(t&65535,this.pos);else if((t&262144)==0){let h=t,{parser:r}=this.p;(i>this.pos||e<=r.maxNode)&&(this.pos=i,r.stateFlag(h,1)||(this.reducePos=i)),this.pushState(h,s),this.shiftContext(e,s),e<=r.maxNode&&this.buffer.push(e,s,i,4)}else this.pos=i,this.shiftContext(e,s),e<=this.p.parser.maxNode&&this.buffer.push(e,s,i,4)}apply(t,e,s,i){t&65536?this.reduce(t):this.shift(t,e,s,i)}useNode(t,e){let s=this.p.reused.length-1;(s<0||this.p.reused[s]!=t)&&(this.p.reused.push(t),s++);let i=this.pos;this.reducePos=this.pos=i+t.length,this.pushState(e,i),this.buffer.push(s,i,this.reducePos,-1),this.curContext&&this.updateContext(this.curContext.tracker.reuse(this.curContext.context,t,this,this.p.stream.reset(this.pos-t.length)))}split(){let t=this,e=t.buffer.length;for(;e>0&&t.buffer[e-2]>t.reducePos;)e-=4;let s=t.buffer.slice(e),i=t.bufferBase+e;for(;t&&i==t.bufferBase;)t=t.parent;return new v(this.p,this.stack.slice(),this.state,this.reducePos,this.pos,this.score,s,i,this.curContext,this.lookAhead,t)}recoverByDelete(t,e){let s=t<=this.p.parser.maxNode;s&&this.storeNode(t,this.pos,e,4),this.storeNode(0,this.pos,e,s?8:4),this.pos=this.reducePos=e,this.score-=190}canShift(t){for(let e=new L(this);;){let s=this.p.parser.stateSlot(e.state,4)||this.p.parser.hasAction(e.state,t);if(s==0)return!1;if((s&65536)==0)return!0;e.reduce(s)}}recoverByInsert(t){if(this.stack.length>=300)return[];let e=this.p.parser.nextStates(this.state);if(e.length>8||this.stack.length>=120){let i=[];for(let h=0,r;h<e.length;h+=2)(r=e[h+1])!=this.state&&this.p.parser.hasAction(r,t)&&i.push(e[h],r);if(this.stack.length<120)for(let h=0;i.length<8&&h<e.length;h+=2){let r=e[h+1];i.some((n,o)=>o&1&&n==r)||i.push(e[h],r)}e=i}let s=[];for(let i=0;i<e.length&&s.length<4;i+=2){let h=e[i+1];if(h==this.state)continue;let r=this.split();r.pushState(h,this.pos),r.storeNode(0,r.pos,r.pos,4,!0),r.shiftContext(e[i],this.pos),r.reducePos=this.pos,r.score-=200,s.push(r)}return s}forceReduce(){let{parser:t}=this.p,e=t.stateSlot(this.state,5);if((e&65536)==0)return!1;if(!t.validAction(this.state,e)){let s=e>>19,i=e&65535,h=this.stack.length-s*3;if(h<0||t.getGoto(this.stack[h],i,!1)<0){let r=this.findForcedReduction();if(r==null)return!1;e=r}this.storeNode(0,this.pos,this.pos,4,!0),this.score-=100}return this.reducePos=this.pos,this.reduce(e),!0}findForcedReduction(){let{parser:t}=this.p,e=[],s=(i,h)=>{if(!e.includes(i))return e.push(i),t.allActions(i,r=>{if(!(r&393216))if(r&65536){let n=(r>>19)-h;if(n>1){let o=r&65535,a=this.stack.length-n*3;if(a>=0&&t.getGoto(this.stack[a],o,!1)>=0)return n<<19|65536|o}}else{let n=s(r,h+1);if(n!=null)return n}})};return s(this.state,0)}forceAll(){for(;!this.p.parser.stateFlag(this.state,2);)if(!this.forceReduce()){this.storeNode(0,this.pos,this.pos,4,!0);break}return this}get deadEnd(){if(this.stack.length!=3)return!1;let{parser:t}=this.p;return t.data[t.stateSlot(this.state,1)]==65535&&!t.stateSlot(this.state,4)}restart(){this.storeNode(0,this.pos,this.pos,4,!0),this.state=this.stack[0],this.stack.length=0}sameState(t){if(this.state!=t.state||this.stack.length!=t.stack.length)return!1;for(let e=0;e<this.stack.length;e+=3)if(this.stack[e]!=t.stack[e])return!1;return!0}get parser(){return this.p.parser}dialectEnabled(t){return this.p.parser.dialect.flags[t]}shiftContext(t,e){this.curContext&&this.updateContext(this.curContext.tracker.shift(this.curContext.context,t,this,this.p.stream.reset(e)))}reduceContext(t,e){this.curContext&&this.updateContext(this.curContext.tracker.reduce(this.curContext.context,t,this,this.p.stream.reset(e)))}emitContext(){let t=this.buffer.length-1;(t<0||this.buffer[t]!=-3)&&this.buffer.push(this.curContext.hash,this.pos,this.pos,-3)}emitLookAhead(){let t=this.buffer.length-1;(t<0||this.buffer[t]!=-4)&&this.buffer.push(this.lookAhead,this.pos,this.pos,-4)}updateContext(t){if(t!=this.curContext.context){let e=new y(this.curContext.tracker,t);e.hash!=this.curContext.hash&&this.emitContext(),this.curContext=e}}setLookAhead(t){return t<=this.lookAhead?!1:(this.emitLookAhead(),this.lookAhead=t,!0)}close(){this.curContext&&this.curContext.tracker.strict&&this.emitContext(),this.lookAhead>0&&this.emitLookAhead()}}class y{constructor(t,e){this.tracker=t,this.context=e,this.hash=t.strict?t.hash(e):0}}class L{constructor(t){this.start=t,this.state=t.state,this.stack=t.stack,this.base=this.stack.length}reduce(t){let e=t&65535,s=t>>19;s==0?(this.stack==this.start.stack&&(this.stack=this.stack.slice()),this.stack.push(this.state,0,0),this.base+=3):this.base-=(s-1)*3;let i=this.start.p.parser.getGoto(this.stack[this.base-3],e,!0);this.state=i}}class T{constructor(t,e,s){this.stack=t,this.pos=e,this.index=s,this.buffer=t.buffer,this.index==0&&this.maybeNext()}static create(t,e=t.bufferBase+t.buffer.length){return new T(t,e,e-t.bufferBase)}maybeNext(){let t=this.stack.parent;t!=null&&(this.index=this.stack.bufferBase-t.bufferBase,this.stack=t,this.buffer=t.buffer)}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]}next(){this.index-=4,this.pos-=4,this.index==0&&this.maybeNext()}fork(){return new T(this.stack,this.pos,this.index)}}function b(l,t=Uint16Array){if(typeof l!="string")return l;let e=null;for(let s=0,i=0;s<l.length;){let h=0;for(;;){let r=l.charCodeAt(s++),n=!1;if(r==126){h=65535;break}r>=92&&r--,r>=34&&r--;let o=r-32;if(o>=46&&(o-=46,n=!0),h+=o,n)break;h*=46}e?e[i++]=h:e=new t(h)}return e}class P{constructor(){this.start=-1,this.value=-1,this.end=-1,this.extended=-1,this.lookAhead=0,this.mask=0,this.context=0}}const N=new P;class M{constructor(t,e){this.input=t,this.ranges=e,this.chunk="",this.chunkOff=0,this.chunk2="",this.chunk2Pos=0,this.next=-1,this.token=N,this.rangeIndex=0,this.pos=this.chunkPos=e[0].from,this.range=e[0],this.end=e[e.length-1].to,this.readNext()}resolveOffset(t,e){let s=this.range,i=this.rangeIndex,h=this.pos+t;for(;h<s.from;){if(!i)return null;let r=this.ranges[--i];h-=s.from-r.to,s=r}for(;e<0?h>s.to:h>=s.to;){if(i==this.ranges.length-1)return null;let r=this.ranges[++i];h+=r.from-s.to,s=r}return h}clipPos(t){if(t>=this.range.from&&t<this.range.to)return t;for(let e of this.ranges)if(e.to>t)return Math.max(t,e.from);return this.end}peek(t){let e=this.chunkOff+t,s,i;if(e>=0&&e<this.chunk.length)s=this.pos+t,i=this.chunk.charCodeAt(e);else{let h=this.resolveOffset(t,1);if(h==null)return-1;if(s=h,s>=this.chunk2Pos&&s<this.chunk2Pos+this.chunk2.length)i=this.chunk2.charCodeAt(s-this.chunk2Pos);else{let r=this.rangeIndex,n=this.range;for(;n.to<=s;)n=this.ranges[++r];this.chunk2=this.input.chunk(this.chunk2Pos=s),s+this.chunk2.length>n.to&&(this.chunk2=this.chunk2.slice(0,n.to-s)),i=this.chunk2.charCodeAt(0)}}return s>=this.token.lookAhead&&(this.token.lookAhead=s+1),i}acceptToken(t,e=0){let s=e?this.resolveOffset(e,-1):this.pos;if(s==null||s<this.token.start)throw new RangeError("Token end out of bounds");this.token.value=t,this.token.end=s}acceptTokenTo(t,e){this.token.value=t,this.token.end=e}getChunk(){if(this.pos>=this.chunk2Pos&&this.pos<this.chunk2Pos+this.chunk2.length){let{chunk:t,chunkPos:e}=this;this.chunk=this.chunk2,this.chunkPos=this.chunk2Pos,this.chunk2=t,this.chunk2Pos=e,this.chunkOff=this.pos-this.chunkPos}else{this.chunk2=this.chunk,this.chunk2Pos=this.chunkPos;let t=this.input.chunk(this.pos),e=this.pos+t.length;this.chunk=e>this.range.to?t.slice(0,this.range.to-this.pos):t,this.chunkPos=this.pos,this.chunkOff=0}}readNext(){return this.chunkOff>=this.chunk.length&&(this.getChunk(),this.chunkOff==this.chunk.length)?this.next=-1:this.next=this.chunk.charCodeAt(this.chunkOff)}advance(t=1){for(this.chunkOff+=t;this.pos+t>=this.range.to;){if(this.rangeIndex==this.ranges.length-1)return this.setDone();t-=this.range.to-this.pos,this.range=this.ranges[++this.rangeIndex],this.pos=this.range.from}return this.pos+=t,this.pos>=this.token.lookAhead&&(this.token.lookAhead=this.pos+1),this.readNext()}setDone(){return this.pos=this.chunkPos=this.end,this.range=this.ranges[this.rangeIndex=this.ranges.length-1],this.chunk="",this.next=-1}reset(t,e){if(e?(this.token=e,e.start=t,e.lookAhead=t+1,e.value=e.extended=-1):this.token=N,this.pos!=t){if(this.pos=t,t==this.end)return this.setDone(),this;for(;t<this.range.from;)this.range=this.ranges[--this.rangeIndex];for(;t>=this.range.to;)this.range=this.ranges[++this.rangeIndex];t>=this.chunkPos&&t<this.chunkPos+this.chunk.length?this.chunkOff=t-this.chunkPos:(this.chunk="",this.chunkOff=0),this.readNext()}return this}read(t,e){if(t>=this.chunkPos&&e<=this.chunkPos+this.chunk.length)return this.chunk.slice(t-this.chunkPos,e-this.chunkPos);if(t>=this.chunk2Pos&&e<=this.chunk2Pos+this.chunk2.length)return this.chunk2.slice(t-this.chunk2Pos,e-this.chunk2Pos);if(t>=this.range.from&&e<=this.range.to)return this.input.read(t,e);let s="";for(let i of this.ranges){if(i.from>=e)break;i.to>t&&(s+=this.input.read(Math.max(i.from,t),Math.min(i.to,e)))}return s}}class x{constructor(t,e){this.data=t,this.id=e}token(t,e){let{parser:s}=e.p;F(this.data,t,e,this.id,s.data,s.tokenPrecTable)}}x.prototype.contextual=x.prototype.fallback=x.prototype.extend=!1;class B{constructor(t,e,s){this.precTable=e,this.elseToken=s,this.data=typeof t=="string"?b(t):t}token(t,e){let s=t.pos,i=0;for(;;){let h=t.next<0,r=t.resolveOffset(1,1);if(F(this.data,t,e,0,this.data,this.precTable),t.token.value>-1)break;if(this.elseToken==null)return;if(h||i++,r==null)break;t.reset(r,t.token)}i&&(t.reset(s,t.token),t.acceptToken(this.elseToken,i))}}B.prototype.contextual=x.prototype.fallback=x.prototype.extend=!1;class ${constructor(t,e={}){this.token=t,this.contextual=!!e.contextual,this.fallback=!!e.fallback,this.extend=!!e.extend}}function F(l,t,e,s,i,h){let r=0,n=1<<s,{dialect:o}=e.p.parser;t:for(;(n&l[r])!=0;){let a=l[r+1];for(let c=r+3;c<a;c+=2)if((l[c+1]&n)>0){let d=l[c];if(o.allows(d)&&(t.token.value==-1||t.token.value==d||E(d,t.token.value,i,h))){t.acceptToken(d);break}}let u=t.next,f=0,p=l[r+2];if(t.next<0&&p>f&&l[a+p*3-3]==65535){r=l[a+p*3-1];continue t}for(;f<p;){let c=f+p>>1,d=a+c+(c<<1),S=l[d],O=l[d+1]||65536;if(u<S)p=c;else if(u>=O)f=c+1;else{r=l[d+2],t.advance();continue t}}break}}function R(l,t,e){for(let s=t,i;(i=l[s])!=65535;s++)if(i==e)return s-t;return-1}function E(l,t,e,s){let i=R(e,s,t);return i<0||R(e,s,l)<i}const g=typeof process<"u"&&process.env&&/\bparse\b/.test(process.env.LOG);let C=null;function z(l,t,e){let s=l.cursor(k.IterMode.IncludeAnonymous);for(s.moveTo(t);;)if(!(e<0?s.childBefore(t):s.childAfter(t)))for(;;){if((e<0?s.to<t:s.from>t)&&!s.type.isError)return e<0?Math.max(0,Math.min(s.to-1,t-25)):Math.min(l.length,Math.max(s.from+1,t+25));if(e<0?s.prevSibling():s.nextSibling())break;if(!s.parent())return e<0?0:l.length}}class j{constructor(t,e){this.fragments=t,this.nodeSet=e,this.i=0,this.fragment=null,this.safeFrom=-1,this.safeTo=-1,this.trees=[],this.start=[],this.index=[],this.nextFragment()}nextFragment(){let t=this.fragment=this.i==this.fragments.length?null:this.fragments[this.i++];if(t){for(this.safeFrom=t.openStart?z(t.tree,t.from+t.offset,1)-t.offset:t.from,this.safeTo=t.openEnd?z(t.tree,t.to+t.offset,-1)-t.offset:t.to;this.trees.length;)this.trees.pop(),this.start.pop(),this.index.pop();this.trees.push(t.tree),this.start.push(-t.offset),this.index.push(0),this.nextStart=this.safeFrom}else this.nextStart=1e9}nodeAt(t){if(t<this.nextStart)return null;for(;this.fragment&&this.safeTo<=t;)this.nextFragment();if(!this.fragment)return null;for(;;){let e=this.trees.length-1;if(e<0)return this.nextFragment(),null;let s=this.trees[e],i=this.index[e];if(i==s.children.length){this.trees.pop(),this.start.pop(),this.index.pop();continue}let h=s.children[i],r=this.start[e]+s.positions[i];if(r>t)return this.nextStart=r,null;if(h instanceof k.Tree){if(r==t){if(r<this.safeFrom)return null;let n=r+h.length;if(n<=this.safeTo){let o=h.prop(k.NodeProp.lookAhead);if(!o||n+o<this.fragment.to)return h}}this.index[e]++,r+h.length>=Math.max(this.safeFrom,t)&&(this.trees.push(h),this.start.push(r),this.index.push(0))}else this.index[e]++,this.nextStart=r+h.length}}}class G{constructor(t,e){this.stream=e,this.tokens=[],this.mainToken=null,this.actions=[],this.tokens=t.tokenizers.map(s=>new P)}getActions(t){let e=0,s=null,{parser:i}=t.p,{tokenizers:h}=i,r=i.stateSlot(t.state,3),n=t.curContext?t.curContext.hash:0,o=0;for(let a=0;a<h.length;a++){if((1<<a&r)==0)continue;let u=h[a],f=this.tokens[a];if(!(s&&!u.fallback)&&((u.contextual||f.start!=t.pos||f.mask!=r||f.context!=n)&&(this.updateCachedToken(f,u,t),f.mask=r,f.context=n),f.lookAhead>f.end+25&&(o=Math.max(f.lookAhead,o)),f.value!=0)){let p=e;if(f.extended>-1&&(e=this.addActions(t,f.extended,f.end,e)),e=this.addActions(t,f.value,f.end,e),!u.extend&&(s=f,e>p))break}}for(;this.actions.length>e;)this.actions.pop();return o&&t.setLookAhead(o),!s&&t.pos==this.stream.end&&(s=new P,s.value=t.p.parser.eofTerm,s.start=s.end=t.pos,e=this.addActions(t,s.value,s.end,e)),this.mainToken=s,this.actions}getMainToken(t){if(this.mainToken)return this.mainToken;let e=new P,{pos:s,p:i}=t;return e.start=s,e.end=Math.min(s+1,i.stream.end),e.value=s==i.stream.end?i.parser.eofTerm:0,e}updateCachedToken(t,e,s){let i=this.stream.clipPos(s.pos);if(e.token(this.stream.reset(i,t),s),t.value>-1){let{parser:h}=s.p;for(let r=0;r<h.specialized.length;r++)if(h.specialized[r]==t.value){let n=h.specializers[r](this.stream.read(t.start,t.end),s);if(n>=0&&s.p.parser.dialect.allows(n>>1)){(n&1)==0?t.value=n>>1:t.extended=n>>1;break}}}else t.value=0,t.end=this.stream.clipPos(i+1)}putAction(t,e,s,i){for(let h=0;h<i;h+=3)if(this.actions[h]==t)return i;return this.actions[i++]=t,this.actions[i++]=e,this.actions[i++]=s,i}addActions(t,e,s,i){let{state:h}=t,{parser:r}=t.p,{data:n}=r;for(let o=0;o<2;o++)for(let a=r.stateSlot(h,o?2:1);;a+=3){if(n[a]==65535)if(n[a+1]==1)a=m(n,a+2);else{i==0&&n[a+1]==2&&(i=this.putAction(m(n,a+2),e,s,i));break}n[a]==e&&(i=this.putAction(m(n,a+1),e,s,i))}return i}}class U{constructor(t,e,s,i){this.parser=t,this.input=e,this.ranges=i,this.recovering=0,this.nextStackID=9812,this.minStackPos=0,this.reused=[],this.stoppedAt=null,this.lastBigReductionStart=-1,this.lastBigReductionSize=0,this.bigReductionCount=0,this.stream=new M(e,i),this.tokens=new G(t,this.stream),this.topTerm=t.top[1];let{from:h}=i[0];this.stacks=[v.start(this,t.top[0],h)],this.fragments=s.length&&this.stream.end-h>t.bufferLength*4?new j(s,t.nodeSet):null}get parsedPos(){return this.minStackPos}advance(){let t=this.stacks,e=this.minStackPos,s=this.stacks=[],i,h;if(this.bigReductionCount>300&&t.length==1){let[r]=t;for(;r.forceReduce()&&r.stack.length&&r.stack[r.stack.length-2]>=this.lastBigReductionStart;);this.bigReductionCount=this.lastBigReductionSize=0}for(let r=0;r<t.length;r++){let n=t[r];for(;;){if(this.tokens.mainToken=null,n.pos>e)s.push(n);else{if(this.advanceStack(n,s,t))continue;{i||(i=[],h=[]),i.push(n);let o=this.tokens.getMainToken(n);h.push(o.value,o.end)}}break}}if(!s.length){let r=i&&q(i);if(r)return g&&console.log("Finish with "+this.stackID(r)),this.stackToTree(r);if(this.parser.strict)throw g&&i&&console.log("Stuck with token "+(this.tokens.mainToken?this.parser.getName(this.tokens.mainToken.value):"none")),new SyntaxError("No parse at "+e);this.recovering||(this.recovering=5)}if(this.recovering&&i){let r=this.stoppedAt!=null&&i[0].pos>this.stoppedAt?i[0]:this.runRecovery(i,h,s);if(r)return g&&console.log("Force-finish "+this.stackID(r)),this.stackToTree(r.forceAll())}if(this.recovering){let r=this.recovering==1?1:this.recovering*3;if(s.length>r)for(s.sort((n,o)=>o.score-n.score);s.length>r;)s.pop();s.some(n=>n.reducePos>e)&&this.recovering--}else if(s.length>1){t:for(let r=0;r<s.length-1;r++){let n=s[r];for(let o=r+1;o<s.length;o++){let a=s[o];if(n.sameState(a)||n.buffer.length>500&&a.buffer.length>500)if((n.score-a.score||n.buffer.length-a.buffer.length)>0)s.splice(o--,1);else{s.splice(r--,1);continue t}}}s.length>12&&s.splice(12,s.length-12)}this.minStackPos=s[0].pos;for(let r=1;r<s.length;r++)s[r].pos<this.minStackPos&&(this.minStackPos=s[r].pos);return null}stopAt(t){if(this.stoppedAt!=null&&this.stoppedAt<t)throw new RangeError("Can't move stoppedAt forward");this.stoppedAt=t}advanceStack(t,e,s){let i=t.pos,{parser:h}=this,r=g?this.stackID(t)+" -> ":"";if(this.stoppedAt!=null&&i>this.stoppedAt)return t.forceReduce()?t:null;if(this.fragments){let a=t.curContext&&t.curContext.tracker.strict,u=a?t.curContext.hash:0;for(let f=this.fragments.nodeAt(i);f;){let p=this.parser.nodeSet.types[f.type.id]==f.type?h.getGoto(t.state,f.type.id):-1;if(p>-1&&f.length&&(!a||(f.prop(k.NodeProp.contextHash)||0)==u))return t.useNode(f,p),g&&console.log(r+this.stackID(t)+` (via reuse of ${h.getName(f.type.id)})`),!0;if(!(f instanceof k.Tree)||f.children.length==0||f.positions[0]>0)break;let c=f.children[0];if(c instanceof k.Tree&&f.positions[0]==0)f=c;else break}}let n=h.stateSlot(t.state,4);if(n>0)return t.reduce(n),g&&console.log(r+this.stackID(t)+` (via always-reduce ${h.getName(n&65535)})`),!0;if(t.stack.length>=8400)for(;t.stack.length>6e3&&t.forceReduce(););let o=this.tokens.getActions(t);for(let a=0;a<o.length;){let u=o[a++],f=o[a++],p=o[a++],c=a==o.length||!s,d=c?t:t.split(),S=this.tokens.mainToken;if(d.apply(u,f,S?S.start:d.pos,p),g&&console.log(r+this.stackID(d)+` (via ${(u&65536)==0?"shift":`reduce of ${h.getName(u&65535)}`} for ${h.getName(f)} @ ${i}${d==t?"":", split"})`),c)return!0;d.pos>i?e.push(d):s.push(d)}return!1}advanceFully(t,e){let s=t.pos;for(;;){if(!this.advanceStack(t,null,null))return!1;if(t.pos>s)return I(t,e),!0}}runRecovery(t,e,s){let i=null,h=!1;for(let r=0;r<t.length;r++){let n=t[r],o=e[r<<1],a=e[(r<<1)+1],u=g?this.stackID(n)+" -> ":"";if(n.deadEnd&&(h||(h=!0,n.restart(),g&&console.log(u+this.stackID(n)+" (restarted)"),this.advanceFully(n,s))))continue;let f=n.split(),p=u;for(let c=0;c<10&&f.forceReduce()&&(g&&console.log(p+this.stackID(f)+" (via force-reduce)"),!this.advanceFully(f,s));c++)g&&(p=this.stackID(f)+" -> ");for(let c of n.recoverByInsert(o))g&&console.log(u+this.stackID(c)+" (via recover-insert)"),this.advanceFully(c,s);this.stream.end>n.pos?(a==n.pos&&(a++,o=0),n.recoverByDelete(o,a),g&&console.log(u+this.stackID(n)+` (via recover-delete ${this.parser.getName(o)})`),I(n,s)):(!i||i.score<n.score)&&(i=n)}return i}stackToTree(t){return t.close(),k.Tree.build({buffer:T.create(t),nodeSet:this.parser.nodeSet,topID:this.topTerm,maxBufferLength:this.parser.bufferLength,reused:this.reused,start:this.ranges[0].from,length:t.pos-this.ranges[0].from,minRepeatType:this.parser.minRepeatTerm})}stackID(t){let e=(C||(C=new WeakMap)).get(t);return e||C.set(t,e=String.fromCodePoint(this.nextStackID++)),e+t}}function I(l,t){for(let e=0;e<t.length;e++){let s=t[e];if(s.pos==l.pos&&s.sameState(l)){t[e].score<l.score&&(t[e]=l);return}}t.push(l)}class H{constructor(t,e,s){this.source=t,this.flags=e,this.disabled=s}allows(t){return!this.disabled||this.disabled[t]==0}}const w=l=>l;class W{constructor(t){this.start=t.start,this.shift=t.shift||w,this.reduce=t.reduce||w,this.reuse=t.reuse||w,this.hash=t.hash||(()=>0),this.strict=t.strict!==!1}}class A extends k.Parser{constructor(t){if(super(),this.wrappers=[],t.version!=14)throw new RangeError(`Parser version (${t.version}) doesn't match runtime version (14)`);let e=t.nodeNames.split(" ");this.minRepeatTerm=e.length;for(let n=0;n<t.repeatNodeCount;n++)e.push("");let s=Object.keys(t.topRules).map(n=>t.topRules[n][1]),i=[];for(let n=0;n<e.length;n++)i.push([]);function h(n,o,a){i[n].push([o,o.deserialize(String(a))])}if(t.nodeProps)for(let n of t.nodeProps){let o=n[0];typeof o=="string"&&(o=k.NodeProp[o]);for(let a=1;a<n.length;){let u=n[a++];if(u>=0)h(u,o,n[a++]);else{let f=n[a+-u];for(let p=-u;p>0;p--)h(n[a++],o,f);a++}}}this.nodeSet=new k.NodeSet(e.map((n,o)=>k.NodeType.define({name:o>=this.minRepeatTerm?void 0:n,id:o,props:i[o],top:s.indexOf(o)>-1,error:o==0,skipped:t.skippedNodes&&t.skippedNodes.indexOf(o)>-1}))),t.propSources&&(this.nodeSet=this.nodeSet.extend(...t.propSources)),this.strict=!1,this.bufferLength=k.DefaultBufferLength;let r=b(t.tokenData);this.context=t.context,this.specializerSpecs=t.specialized||[],this.specialized=new Uint16Array(this.specializerSpecs.length);for(let n=0;n<this.specializerSpecs.length;n++)this.specialized[n]=this.specializerSpecs[n].term;this.specializers=this.specializerSpecs.map(D),this.states=b(t.states,Uint32Array),this.data=b(t.stateData),this.goto=b(t.goto),this.maxTerm=t.maxTerm,this.tokenizers=t.tokenizers.map(n=>typeof n=="number"?new x(r,n):n),this.topRules=t.topRules,this.dialects=t.dialects||{},this.dynamicPrecedences=t.dynamicPrecedences||null,this.tokenPrecTable=t.tokenPrec,this.termNames=t.termNames||null,this.maxNode=this.nodeSet.types.length-1,this.dialect=this.parseDialect(),this.top=this.topRules[Object.keys(this.topRules)[0]]}createParse(t,e,s){let i=new U(this,t,e,s);for(let h of this.wrappers)i=h(i,t,e,s);return i}getGoto(t,e,s=!1){let i=this.goto;if(e>=i[0])return-1;for(let h=i[e+1];;){let r=i[h++],n=r&1,o=i[h++];if(n&&s)return o;for(let a=h+(r>>1);h<a;h++)if(i[h]==t)return o;if(n)return-1}}hasAction(t,e){let s=this.data;for(let i=0;i<2;i++)for(let h=this.stateSlot(t,i?2:1),r;;h+=3){if((r=s[h])==65535)if(s[h+1]==1)r=s[h=m(s,h+2)];else{if(s[h+1]==2)return m(s,h+2);break}if(r==e||r==0)return m(s,h+1)}return 0}stateSlot(t,e){return this.states[t*6+e]}stateFlag(t,e){return(this.stateSlot(t,0)&e)>0}validAction(t,e){return!!this.allActions(t,s=>s==e?!0:null)}allActions(t,e){let s=this.stateSlot(t,4),i=s?e(s):void 0;for(let h=this.stateSlot(t,1);i==null;h+=3){if(this.data[h]==65535)if(this.data[h+1]==1)h=m(this.data,h+2);else break;i=e(m(this.data,h+1))}return i}nextStates(t){let e=[];for(let s=this.stateSlot(t,1);;s+=3){if(this.data[s]==65535)if(this.data[s+1]==1)s=m(this.data,s+2);else break;if((this.data[s+2]&1)==0){let i=this.data[s+1];e.some((h,r)=>r&1&&h==i)||e.push(this.data[s],i)}}return e}configure(t){let e=Object.assign(Object.create(A.prototype),this);if(t.props&&(e.nodeSet=this.nodeSet.extend(...t.props)),t.top){let s=this.topRules[t.top];if(!s)throw new RangeError(`Invalid top rule name ${t.top}`);e.top=s}return t.tokenizers&&(e.tokenizers=this.tokenizers.map(s=>{let i=t.tokenizers.find(h=>h.from==s);return i?i.to:s})),t.specializers&&(e.specializers=this.specializers.slice(),e.specializerSpecs=this.specializerSpecs.map((s,i)=>{let h=t.specializers.find(n=>n.from==s.external);if(!h)return s;let r=Object.assign(Object.assign({},s),{external:h.to});return e.specializers[i]=D(r),r})),t.contextTracker&&(e.context=t.contextTracker),t.dialect&&(e.dialect=this.parseDialect(t.dialect)),t.strict!=null&&(e.strict=t.strict),t.wrap&&(e.wrappers=e.wrappers.concat(t.wrap)),t.bufferLength!=null&&(e.bufferLength=t.bufferLength),e}hasWrappers(){return this.wrappers.length>0}getName(t){return this.termNames?this.termNames[t]:String(t<=this.maxNode&&this.nodeSet.types[t].name||t)}get eofTerm(){return this.maxNode+1}get topNode(){return this.nodeSet.types[this.top[1]]}dynamicPrecedence(t){let e=this.dynamicPrecedences;return e==null?0:e[t]||0}parseDialect(t){let e=Object.keys(this.dialects),s=e.map(()=>!1);if(t)for(let h of t.split(" ")){let r=e.indexOf(h);r>=0&&(s[r]=!0)}let i=null;for(let h=0;h<e.length;h++)if(!s[h])for(let r=this.dialects[e[h]],n;(n=this.data[r++])!=65535;)(i||(i=new Uint8Array(this.maxTerm+1)))[n]=1;return new H(t,s,i)}static deserialize(t){return new A(t)}}function m(l,t){return l[t]|l[t+1]<<16}function q(l){let t=null;for(let e of l){let s=e.p.stoppedAt;(e.pos==e.p.stream.end||s!=null&&e.pos>s)&&e.p.parser.stateFlag(e.state,2)&&(!t||t.score<e.score)&&(t=e)}return t}function D(l){if(l.external){let t=l.extend?1:0;return(e,s)=>l.external(e,s)<<1|t}return l.get}exports.ContextTracker=W;exports.ExternalTokenizer=$;exports.LRParser=A;exports.LocalTokenGroup=B;
-//# sourceMappingURL=index-osDEQbsO.cjs.map

package/dist/index-osDEQbsO.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-osDEQbsO.cjs","sources":["../../../node_modules/.deno/@lezer+lr@1.4.4/node_modules/@lezer/lr/dist/index.js"],"sourcesContent":["import { Parser, NodeProp, NodeSet, NodeType, DefaultBufferLength, Tree, IterMode } from '@lezer/common';\n\n/**\nA parse stack. These are used internally by the parser to track\nparsing progress. They also provide some properties and methods\nthat external code such as a tokenizer can use to get information\nabout the parse state.\n*/\nclass Stack {\n    /**\n    @internal\n    */\n    constructor(\n    /**\n    The parse that this stack is part of @internal\n    */\n    p, \n    /**\n    Holds state, input pos, buffer index triplets for all but the\n    top state @internal\n    */\n    stack, \n    /**\n    The current parse state @internal\n    */\n    state, \n    // The position at which the next reduce should take place. This\n    // can be less than `this.pos` when skipped expressions have been\n    // added to the stack (which should be moved outside of the next\n    // reduction)\n    /**\n    @internal\n    */\n    reducePos, \n    /**\n    The input position up to which this stack has parsed.\n    */\n    pos, \n    /**\n    The dynamic score of the stack, including dynamic precedence\n    and error-recovery penalties\n    @internal\n    */\n    score, \n    // The output buffer. Holds (type, start, end, size) quads\n    // representing nodes created by the parser, where `size` is\n    // amount of buffer array entries covered by this node.\n    /**\n    @internal\n    */\n    buffer, \n    // The base offset of the buffer. When stacks are split, the split\n    // instance shared the buffer history with its parent up to\n    // `bufferBase`, which is the absolute offset (including the\n    // offset of previous splits) into the buffer at which this stack\n    // starts writing.\n    /**\n    @internal\n    */\n    bufferBase, \n    /**\n    @internal\n    */\n    curContext, \n    /**\n    @internal\n    */\n    lookAhead = 0, \n    // A parent stack from which this was split off, if any. This is\n    // set up so that it always points to a stack that has some\n    // additional buffer content, never to a stack with an equal\n    // `bufferBase`.\n    /**\n    @internal\n    */\n    parent) {\n        this.p = p;\n        this.stack = stack;\n        this.state = state;\n        this.reducePos = reducePos;\n        this.pos = pos;\n        this.score = score;\n        this.buffer = buffer;\n        this.bufferBase = bufferBase;\n        this.curContext = curContext;\n        this.lookAhead = lookAhead;\n        this.parent = parent;\n    }\n    /**\n    @internal\n    */\n    toString() {\n        return `[${this.stack.filter((_, i) => i % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? \"!\" + this.score : \"\"}`;\n    }\n    // Start an empty stack\n    /**\n    @internal\n    */\n    static start(p, state, pos = 0) {\n        let cx = p.parser.context;\n        return new Stack(p, [], state, pos, pos, 0, [], 0, cx ? new StackContext(cx, cx.start) : null, 0, null);\n    }\n    /**\n    The stack's current [context](#lr.ContextTracker) value, if\n    any. Its type will depend on the context tracker's type\n    parameter, or it will be `null` if there is no context\n    tracker.\n    */\n    get context() { return this.curContext ? this.curContext.context : null; }\n    // Push a state onto the stack, tracking its start position as well\n    // as the buffer base at that point.\n    /**\n    @internal\n    */\n    pushState(state, start) {\n        this.stack.push(this.state, start, this.bufferBase + this.buffer.length);\n        this.state = state;\n    }\n    // Apply a reduce action\n    /**\n    @internal\n    */\n    reduce(action) {\n        var _a;\n        let depth = action >> 19 /* Action.ReduceDepthShift */, type = action & 65535 /* Action.ValueMask */;\n        let { parser } = this.p;\n        let lookaheadRecord = this.reducePos < this.pos - 25 /* Lookahead.Margin */ && this.setLookAhead(this.pos);\n        let dPrec = parser.dynamicPrecedence(type);\n        if (dPrec)\n            this.score += dPrec;\n        if (depth == 0) {\n            this.pushState(parser.getGoto(this.state, type, true), this.reducePos);\n            // Zero-depth reductions are a special case—they add stuff to\n            // the stack without popping anything off.\n            if (type < parser.minRepeatTerm)\n                this.storeNode(type, this.reducePos, this.reducePos, lookaheadRecord ? 8 : 4, true);\n            this.reduceContext(type, this.reducePos);\n            return;\n        }\n        // Find the base index into `this.stack`, content after which will\n        // be dropped. Note that with `StayFlag` reductions we need to\n        // consume two extra frames (the dummy parent node for the skipped\n        // expression and the state that we'll be staying in, which should\n        // be moved to `this.state`).\n        let base = this.stack.length - ((depth - 1) * 3) - (action & 262144 /* Action.StayFlag */ ? 6 : 0);\n        let start = base ? this.stack[base - 2] : this.p.ranges[0].from, size = this.reducePos - start;\n        // This is a kludge to try and detect overly deep left-associative\n        // trees, which will not increase the parse stack depth and thus\n        // won't be caught by the regular stack-depth limit check.\n        if (size >= 2000 /* Recover.MinBigReduction */ && !((_a = this.p.parser.nodeSet.types[type]) === null || _a === void 0 ? void 0 : _a.isAnonymous)) {\n            if (start == this.p.lastBigReductionStart) {\n                this.p.bigReductionCount++;\n                this.p.lastBigReductionSize = size;\n            }\n            else if (this.p.lastBigReductionSize < size) {\n                this.p.bigReductionCount = 1;\n                this.p.lastBigReductionStart = start;\n                this.p.lastBigReductionSize = size;\n            }\n        }\n        let bufferBase = base ? this.stack[base - 1] : 0, count = this.bufferBase + this.buffer.length - bufferBase;\n        // Store normal terms or `R -> R R` repeat reductions\n        if (type < parser.minRepeatTerm || (action & 131072 /* Action.RepeatFlag */)) {\n            let pos = parser.stateFlag(this.state, 1 /* StateFlag.Skipped */) ? this.pos : this.reducePos;\n            this.storeNode(type, start, pos, count + 4, true);\n        }\n        if (action & 262144 /* Action.StayFlag */) {\n            this.state = this.stack[base];\n        }\n        else {\n            let baseStateID = this.stack[base - 3];\n            this.state = parser.getGoto(baseStateID, type, true);\n        }\n        while (this.stack.length > base)\n            this.stack.pop();\n        this.reduceContext(type, start);\n    }\n    // Shift a value into the buffer\n    /**\n    @internal\n    */\n    storeNode(term, start, end, size = 4, mustSink = false) {\n        if (term == 0 /* Term.Err */ &&\n            (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {\n            // Try to omit/merge adjacent error nodes\n            let cur = this, top = this.buffer.length;\n            if (top == 0 && cur.parent) {\n                top = cur.bufferBase - cur.parent.bufferBase;\n                cur = cur.parent;\n            }\n            if (top > 0 && cur.buffer[top - 4] == 0 /* Term.Err */ && cur.buffer[top - 1] > -1) {\n                if (start == end)\n                    return;\n                if (cur.buffer[top - 2] >= start) {\n                    cur.buffer[top - 2] = end;\n                    return;\n                }\n            }\n        }\n        if (!mustSink || this.pos == end) { // Simple case, just append\n            this.buffer.push(term, start, end, size);\n        }\n        else { // There may be skipped nodes that have to be moved forward\n            let index = this.buffer.length;\n            if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {\n                let mustMove = false;\n                for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {\n                    if (this.buffer[scan - 1] >= 0) {\n                        mustMove = true;\n                        break;\n                    }\n                }\n                if (mustMove)\n                    while (index > 0 && this.buffer[index - 2] > end) {\n                        // Move this record forward\n                        this.buffer[index] = this.buffer[index - 4];\n                        this.buffer[index + 1] = this.buffer[index - 3];\n                        this.buffer[index + 2] = this.buffer[index - 2];\n                        this.buffer[index + 3] = this.buffer[index - 1];\n                        index -= 4;\n                        if (size > 4)\n                            size -= 4;\n                    }\n            }\n            this.buffer[index] = term;\n            this.buffer[index + 1] = start;\n            this.buffer[index + 2] = end;\n            this.buffer[index + 3] = size;\n        }\n    }\n    // Apply a shift action\n    /**\n    @internal\n    */\n    shift(action, type, start, end) {\n        if (action & 131072 /* Action.GotoFlag */) {\n            this.pushState(action & 65535 /* Action.ValueMask */, this.pos);\n        }\n        else if ((action & 262144 /* Action.StayFlag */) == 0) { // Regular shift\n            let nextState = action, { parser } = this.p;\n            if (end > this.pos || type <= parser.maxNode) {\n                this.pos = end;\n                if (!parser.stateFlag(nextState, 1 /* StateFlag.Skipped */))\n                    this.reducePos = end;\n            }\n            this.pushState(nextState, start);\n            this.shiftContext(type, start);\n            if (type <= parser.maxNode)\n                this.buffer.push(type, start, end, 4);\n        }\n        else { // Shift-and-stay, which means this is a skipped token\n            this.pos = end;\n            this.shiftContext(type, start);\n            if (type <= this.p.parser.maxNode)\n                this.buffer.push(type, start, end, 4);\n        }\n    }\n    // Apply an action\n    /**\n    @internal\n    */\n    apply(action, next, nextStart, nextEnd) {\n        if (action & 65536 /* Action.ReduceFlag */)\n            this.reduce(action);\n        else\n            this.shift(action, next, nextStart, nextEnd);\n    }\n    // Add a prebuilt (reused) node into the buffer.\n    /**\n    @internal\n    */\n    useNode(value, next) {\n        let index = this.p.reused.length - 1;\n        if (index < 0 || this.p.reused[index] != value) {\n            this.p.reused.push(value);\n            index++;\n        }\n        let start = this.pos;\n        this.reducePos = this.pos = start + value.length;\n        this.pushState(next, start);\n        this.buffer.push(index, start, this.reducePos, -1 /* size == -1 means this is a reused value */);\n        if (this.curContext)\n            this.updateContext(this.curContext.tracker.reuse(this.curContext.context, value, this, this.p.stream.reset(this.pos - value.length)));\n    }\n    // Split the stack. Due to the buffer sharing and the fact\n    // that `this.stack` tends to stay quite shallow, this isn't very\n    // expensive.\n    /**\n    @internal\n    */\n    split() {\n        let parent = this;\n        let off = parent.buffer.length;\n        // Because the top of the buffer (after this.pos) may be mutated\n        // to reorder reductions and skipped tokens, and shared buffers\n        // should be immutable, this copies any outstanding skipped tokens\n        // to the new buffer, and puts the base pointer before them.\n        while (off > 0 && parent.buffer[off - 2] > parent.reducePos)\n            off -= 4;\n        let buffer = parent.buffer.slice(off), base = parent.bufferBase + off;\n        // Make sure parent points to an actual parent with content, if there is such a parent.\n        while (parent && base == parent.bufferBase)\n            parent = parent.parent;\n        return new Stack(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, buffer, base, this.curContext, this.lookAhead, parent);\n    }\n    // Try to recover from an error by 'deleting' (ignoring) one token.\n    /**\n    @internal\n    */\n    recoverByDelete(next, nextEnd) {\n        let isNode = next <= this.p.parser.maxNode;\n        if (isNode)\n            this.storeNode(next, this.pos, nextEnd, 4);\n        this.storeNode(0 /* Term.Err */, this.pos, nextEnd, isNode ? 8 : 4);\n        this.pos = this.reducePos = nextEnd;\n        this.score -= 190 /* Recover.Delete */;\n    }\n    /**\n    Check if the given term would be able to be shifted (optionally\n    after some reductions) on this stack. This can be useful for\n    external tokenizers that want to make sure they only provide a\n    given token when it applies.\n    */\n    canShift(term) {\n        for (let sim = new SimulatedStack(this);;) {\n            let action = this.p.parser.stateSlot(sim.state, 4 /* ParseState.DefaultReduce */) || this.p.parser.hasAction(sim.state, term);\n            if (action == 0)\n                return false;\n            if ((action & 65536 /* Action.ReduceFlag */) == 0)\n                return true;\n            sim.reduce(action);\n        }\n    }\n    // Apply up to Recover.MaxNext recovery actions that conceptually\n    // inserts some missing token or rule.\n    /**\n    @internal\n    */\n    recoverByInsert(next) {\n        if (this.stack.length >= 300 /* Recover.MaxInsertStackDepth */)\n            return [];\n        let nextStates = this.p.parser.nextStates(this.state);\n        if (nextStates.length > 4 /* Recover.MaxNext */ << 1 || this.stack.length >= 120 /* Recover.DampenInsertStackDepth */) {\n            let best = [];\n            for (let i = 0, s; i < nextStates.length; i += 2) {\n                if ((s = nextStates[i + 1]) != this.state && this.p.parser.hasAction(s, next))\n                    best.push(nextStates[i], s);\n            }\n            if (this.stack.length < 120 /* Recover.DampenInsertStackDepth */)\n                for (let i = 0; best.length < 4 /* Recover.MaxNext */ << 1 && i < nextStates.length; i += 2) {\n                    let s = nextStates[i + 1];\n                    if (!best.some((v, i) => (i & 1) && v == s))\n                        best.push(nextStates[i], s);\n                }\n            nextStates = best;\n        }\n        let result = [];\n        for (let i = 0; i < nextStates.length && result.length < 4 /* Recover.MaxNext */; i += 2) {\n            let s = nextStates[i + 1];\n            if (s == this.state)\n                continue;\n            let stack = this.split();\n            stack.pushState(s, this.pos);\n            stack.storeNode(0 /* Term.Err */, stack.pos, stack.pos, 4, true);\n            stack.shiftContext(nextStates[i], this.pos);\n            stack.reducePos = this.pos;\n            stack.score -= 200 /* Recover.Insert */;\n            result.push(stack);\n        }\n        return result;\n    }\n    // Force a reduce, if possible. Return false if that can't\n    // be done.\n    /**\n    @internal\n    */\n    forceReduce() {\n        let { parser } = this.p;\n        let reduce = parser.stateSlot(this.state, 5 /* ParseState.ForcedReduce */);\n        if ((reduce & 65536 /* Action.ReduceFlag */) == 0)\n            return false;\n        if (!parser.validAction(this.state, reduce)) {\n            let depth = reduce >> 19 /* Action.ReduceDepthShift */, term = reduce & 65535 /* Action.ValueMask */;\n            let target = this.stack.length - depth * 3;\n            if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0) {\n                let backup = this.findForcedReduction();\n                if (backup == null)\n                    return false;\n                reduce = backup;\n            }\n            this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true);\n            this.score -= 100 /* Recover.Reduce */;\n        }\n        this.reducePos = this.pos;\n        this.reduce(reduce);\n        return true;\n    }\n    /**\n    Try to scan through the automaton to find some kind of reduction\n    that can be applied. Used when the regular ForcedReduce field\n    isn't a valid action. @internal\n    */\n    findForcedReduction() {\n        let { parser } = this.p, seen = [];\n        let explore = (state, depth) => {\n            if (seen.includes(state))\n                return;\n            seen.push(state);\n            return parser.allActions(state, (action) => {\n                if (action & (262144 /* Action.StayFlag */ | 131072 /* Action.GotoFlag */)) ;\n                else if (action & 65536 /* Action.ReduceFlag */) {\n                    let rDepth = (action >> 19 /* Action.ReduceDepthShift */) - depth;\n                    if (rDepth > 1) {\n                        let term = action & 65535 /* Action.ValueMask */, target = this.stack.length - rDepth * 3;\n                        if (target >= 0 && parser.getGoto(this.stack[target], term, false) >= 0)\n                            return (rDepth << 19 /* Action.ReduceDepthShift */) | 65536 /* Action.ReduceFlag */ | term;\n                    }\n                }\n                else {\n                    let found = explore(action, depth + 1);\n                    if (found != null)\n                        return found;\n                }\n            });\n        };\n        return explore(this.state, 0);\n    }\n    /**\n    @internal\n    */\n    forceAll() {\n        while (!this.p.parser.stateFlag(this.state, 2 /* StateFlag.Accepting */)) {\n            if (!this.forceReduce()) {\n                this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true);\n                break;\n            }\n        }\n        return this;\n    }\n    /**\n    Check whether this state has no further actions (assumed to be a direct descendant of the\n    top state, since any other states must be able to continue\n    somehow). @internal\n    */\n    get deadEnd() {\n        if (this.stack.length != 3)\n            return false;\n        let { parser } = this.p;\n        return parser.data[parser.stateSlot(this.state, 1 /* ParseState.Actions */)] == 65535 /* Seq.End */ &&\n            !parser.stateSlot(this.state, 4 /* ParseState.DefaultReduce */);\n    }\n    /**\n    Restart the stack (put it back in its start state). Only safe\n    when this.stack.length == 3 (state is directly below the top\n    state). @internal\n    */\n    restart() {\n        this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true);\n        this.state = this.stack[0];\n        this.stack.length = 0;\n    }\n    /**\n    @internal\n    */\n    sameState(other) {\n        if (this.state != other.state || this.stack.length != other.stack.length)\n            return false;\n        for (let i = 0; i < this.stack.length; i += 3)\n            if (this.stack[i] != other.stack[i])\n                return false;\n        return true;\n    }\n    /**\n    Get the parser used by this stack.\n    */\n    get parser() { return this.p.parser; }\n    /**\n    Test whether a given dialect (by numeric ID, as exported from\n    the terms file) is enabled.\n    */\n    dialectEnabled(dialectID) { return this.p.parser.dialect.flags[dialectID]; }\n    shiftContext(term, start) {\n        if (this.curContext)\n            this.updateContext(this.curContext.tracker.shift(this.curContext.context, term, this, this.p.stream.reset(start)));\n    }\n    reduceContext(term, start) {\n        if (this.curContext)\n            this.updateContext(this.curContext.tracker.reduce(this.curContext.context, term, this, this.p.stream.reset(start)));\n    }\n    /**\n    @internal\n    */\n    emitContext() {\n        let last = this.buffer.length - 1;\n        if (last < 0 || this.buffer[last] != -3)\n            this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);\n    }\n    /**\n    @internal\n    */\n    emitLookAhead() {\n        let last = this.buffer.length - 1;\n        if (last < 0 || this.buffer[last] != -4)\n            this.buffer.push(this.lookAhead, this.pos, this.pos, -4);\n    }\n    updateContext(context) {\n        if (context != this.curContext.context) {\n            let newCx = new StackContext(this.curContext.tracker, context);\n            if (newCx.hash != this.curContext.hash)\n                this.emitContext();\n            this.curContext = newCx;\n        }\n    }\n    /**\n    @internal\n    */\n    setLookAhead(lookAhead) {\n        if (lookAhead <= this.lookAhead)\n            return false;\n        this.emitLookAhead();\n        this.lookAhead = lookAhead;\n        return true;\n    }\n    /**\n    @internal\n    */\n    close() {\n        if (this.curContext && this.curContext.tracker.strict)\n            this.emitContext();\n        if (this.lookAhead > 0)\n            this.emitLookAhead();\n    }\n}\nclass StackContext {\n    constructor(tracker, context) {\n        this.tracker = tracker;\n        this.context = context;\n        this.hash = tracker.strict ? tracker.hash(context) : 0;\n    }\n}\n// Used to cheaply run some reductions to scan ahead without mutating\n// an entire stack\nclass SimulatedStack {\n    constructor(start) {\n        this.start = start;\n        this.state = start.state;\n        this.stack = start.stack;\n        this.base = this.stack.length;\n    }\n    reduce(action) {\n        let term = action & 65535 /* Action.ValueMask */, depth = action >> 19 /* Action.ReduceDepthShift */;\n        if (depth == 0) {\n            if (this.stack == this.start.stack)\n                this.stack = this.stack.slice();\n            this.stack.push(this.state, 0, 0);\n            this.base += 3;\n        }\n        else {\n            this.base -= (depth - 1) * 3;\n        }\n        let goto = this.start.p.parser.getGoto(this.stack[this.base - 3], term, true);\n        this.state = goto;\n    }\n}\n// This is given to `Tree.build` to build a buffer, and encapsulates\n// the parent-stack-walking necessary to read the nodes.\nclass StackBufferCursor {\n    constructor(stack, pos, index) {\n        this.stack = stack;\n        this.pos = pos;\n        this.index = index;\n        this.buffer = stack.buffer;\n        if (this.index == 0)\n            this.maybeNext();\n    }\n    static create(stack, pos = stack.bufferBase + stack.buffer.length) {\n        return new StackBufferCursor(stack, pos, pos - stack.bufferBase);\n    }\n    maybeNext() {\n        let next = this.stack.parent;\n        if (next != null) {\n            this.index = this.stack.bufferBase - next.bufferBase;\n            this.stack = next;\n            this.buffer = next.buffer;\n        }\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    next() {\n        this.index -= 4;\n        this.pos -= 4;\n        if (this.index == 0)\n            this.maybeNext();\n    }\n    fork() {\n        return new StackBufferCursor(this.stack, this.pos, this.index);\n    }\n}\n\n// See lezer-generator/src/encode.ts for comments about the encoding\n// used here\nfunction decodeArray(input, Type = Uint16Array) {\n    if (typeof input != \"string\")\n        return input;\n    let array = null;\n    for (let pos = 0, out = 0; pos < input.length;) {\n        let value = 0;\n        for (;;) {\n            let next = input.charCodeAt(pos++), stop = false;\n            if (next == 126 /* Encode.BigValCode */) {\n                value = 65535 /* Encode.BigVal */;\n                break;\n            }\n            if (next >= 92 /* Encode.Gap2 */)\n                next--;\n            if (next >= 34 /* Encode.Gap1 */)\n                next--;\n            let digit = next - 32 /* Encode.Start */;\n            if (digit >= 46 /* Encode.Base */) {\n                digit -= 46 /* Encode.Base */;\n                stop = true;\n            }\n            value += digit;\n            if (stop)\n                break;\n            value *= 46 /* Encode.Base */;\n        }\n        if (array)\n            array[out++] = value;\n        else\n            array = new Type(value);\n    }\n    return array;\n}\n\nclass CachedToken {\n    constructor() {\n        this.start = -1;\n        this.value = -1;\n        this.end = -1;\n        this.extended = -1;\n        this.lookAhead = 0;\n        this.mask = 0;\n        this.context = 0;\n    }\n}\nconst nullToken = new CachedToken;\n/**\n[Tokenizers](#lr.ExternalTokenizer) interact with the input\nthrough this interface. It presents the input as a stream of\ncharacters, tracking lookahead and hiding the complexity of\n[ranges](#common.Parser.parse^ranges) from tokenizer code.\n*/\nclass InputStream {\n    /**\n    @internal\n    */\n    constructor(\n    /**\n    @internal\n    */\n    input, \n    /**\n    @internal\n    */\n    ranges) {\n        this.input = input;\n        this.ranges = ranges;\n        /**\n        @internal\n        */\n        this.chunk = \"\";\n        /**\n        @internal\n        */\n        this.chunkOff = 0;\n        /**\n        Backup chunk\n        */\n        this.chunk2 = \"\";\n        this.chunk2Pos = 0;\n        /**\n        The character code of the next code unit in the input, or -1\n        when the stream is at the end of the input.\n        */\n        this.next = -1;\n        /**\n        @internal\n        */\n        this.token = nullToken;\n        this.rangeIndex = 0;\n        this.pos = this.chunkPos = ranges[0].from;\n        this.range = ranges[0];\n        this.end = ranges[ranges.length - 1].to;\n        this.readNext();\n    }\n    /**\n    @internal\n    */\n    resolveOffset(offset, assoc) {\n        let range = this.range, index = this.rangeIndex;\n        let pos = this.pos + offset;\n        while (pos < range.from) {\n            if (!index)\n                return null;\n            let next = this.ranges[--index];\n            pos -= range.from - next.to;\n            range = next;\n        }\n        while (assoc < 0 ? pos > range.to : pos >= range.to) {\n            if (index == this.ranges.length - 1)\n                return null;\n            let next = this.ranges[++index];\n            pos += next.from - range.to;\n            range = next;\n        }\n        return pos;\n    }\n    /**\n    @internal\n    */\n    clipPos(pos) {\n        if (pos >= this.range.from && pos < this.range.to)\n            return pos;\n        for (let range of this.ranges)\n            if (range.to > pos)\n                return Math.max(pos, range.from);\n        return this.end;\n    }\n    /**\n    Look at a code unit near the stream position. `.peek(0)` equals\n    `.next`, `.peek(-1)` gives you the previous character, and so\n    on.\n    \n    Note that looking around during tokenizing creates dependencies\n    on potentially far-away content, which may reduce the\n    effectiveness incremental parsing—when looking forward—or even\n    cause invalid reparses when looking backward more than 25 code\n    units, since the library does not track lookbehind.\n    */\n    peek(offset) {\n        let idx = this.chunkOff + offset, pos, result;\n        if (idx >= 0 && idx < this.chunk.length) {\n            pos = this.pos + offset;\n            result = this.chunk.charCodeAt(idx);\n        }\n        else {\n            let resolved = this.resolveOffset(offset, 1);\n            if (resolved == null)\n                return -1;\n            pos = resolved;\n            if (pos >= this.chunk2Pos && pos < this.chunk2Pos + this.chunk2.length) {\n                result = this.chunk2.charCodeAt(pos - this.chunk2Pos);\n            }\n            else {\n                let i = this.rangeIndex, range = this.range;\n                while (range.to <= pos)\n                    range = this.ranges[++i];\n                this.chunk2 = this.input.chunk(this.chunk2Pos = pos);\n                if (pos + this.chunk2.length > range.to)\n                    this.chunk2 = this.chunk2.slice(0, range.to - pos);\n                result = this.chunk2.charCodeAt(0);\n            }\n        }\n        if (pos >= this.token.lookAhead)\n            this.token.lookAhead = pos + 1;\n        return result;\n    }\n    /**\n    Accept a token. By default, the end of the token is set to the\n    current stream position, but you can pass an offset (relative to\n    the stream position) to change that.\n    */\n    acceptToken(token, endOffset = 0) {\n        let end = endOffset ? this.resolveOffset(endOffset, -1) : this.pos;\n        if (end == null || end < this.token.start)\n            throw new RangeError(\"Token end out of bounds\");\n        this.token.value = token;\n        this.token.end = end;\n    }\n    /**\n    Accept a token ending at a specific given position.\n    */\n    acceptTokenTo(token, endPos) {\n        this.token.value = token;\n        this.token.end = endPos;\n    }\n    getChunk() {\n        if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {\n            let { chunk, chunkPos } = this;\n            this.chunk = this.chunk2;\n            this.chunkPos = this.chunk2Pos;\n            this.chunk2 = chunk;\n            this.chunk2Pos = chunkPos;\n            this.chunkOff = this.pos - this.chunkPos;\n        }\n        else {\n            this.chunk2 = this.chunk;\n            this.chunk2Pos = this.chunkPos;\n            let nextChunk = this.input.chunk(this.pos);\n            let end = this.pos + nextChunk.length;\n            this.chunk = end > this.range.to ? nextChunk.slice(0, this.range.to - this.pos) : nextChunk;\n            this.chunkPos = this.pos;\n            this.chunkOff = 0;\n        }\n    }\n    readNext() {\n        if (this.chunkOff >= this.chunk.length) {\n            this.getChunk();\n            if (this.chunkOff == this.chunk.length)\n                return this.next = -1;\n        }\n        return this.next = this.chunk.charCodeAt(this.chunkOff);\n    }\n    /**\n    Move the stream forward N (defaults to 1) code units. Returns\n    the new value of [`next`](#lr.InputStream.next).\n    */\n    advance(n = 1) {\n        this.chunkOff += n;\n        while (this.pos + n >= this.range.to) {\n            if (this.rangeIndex == this.ranges.length - 1)\n                return this.setDone();\n            n -= this.range.to - this.pos;\n            this.range = this.ranges[++this.rangeIndex];\n            this.pos = this.range.from;\n        }\n        this.pos += n;\n        if (this.pos >= this.token.lookAhead)\n            this.token.lookAhead = this.pos + 1;\n        return this.readNext();\n    }\n    setDone() {\n        this.pos = this.chunkPos = this.end;\n        this.range = this.ranges[this.rangeIndex = this.ranges.length - 1];\n        this.chunk = \"\";\n        return this.next = -1;\n    }\n    /**\n    @internal\n    */\n    reset(pos, token) {\n        if (token) {\n            this.token = token;\n            token.start = pos;\n            token.lookAhead = pos + 1;\n            token.value = token.extended = -1;\n        }\n        else {\n            this.token = nullToken;\n        }\n        if (this.pos != pos) {\n            this.pos = pos;\n            if (pos == this.end) {\n                this.setDone();\n                return this;\n            }\n            while (pos < this.range.from)\n                this.range = this.ranges[--this.rangeIndex];\n            while (pos >= this.range.to)\n                this.range = this.ranges[++this.rangeIndex];\n            if (pos >= this.chunkPos && pos < this.chunkPos + this.chunk.length) {\n                this.chunkOff = pos - this.chunkPos;\n            }\n            else {\n                this.chunk = \"\";\n                this.chunkOff = 0;\n            }\n            this.readNext();\n        }\n        return this;\n    }\n    /**\n    @internal\n    */\n    read(from, to) {\n        if (from >= this.chunkPos && to <= this.chunkPos + this.chunk.length)\n            return this.chunk.slice(from - this.chunkPos, to - this.chunkPos);\n        if (from >= this.chunk2Pos && to <= this.chunk2Pos + this.chunk2.length)\n            return this.chunk2.slice(from - this.chunk2Pos, to - this.chunk2Pos);\n        if (from >= this.range.from && to <= this.range.to)\n            return this.input.read(from, to);\n        let result = \"\";\n        for (let r of this.ranges) {\n            if (r.from >= to)\n                break;\n            if (r.to > from)\n                result += this.input.read(Math.max(r.from, from), Math.min(r.to, to));\n        }\n        return result;\n    }\n}\n/**\n@internal\n*/\nclass TokenGroup {\n    constructor(data, id) {\n        this.data = data;\n        this.id = id;\n    }\n    token(input, stack) {\n        let { parser } = stack.p;\n        readToken(this.data, input, stack, this.id, parser.data, parser.tokenPrecTable);\n    }\n}\nTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;\n/**\n@hide\n*/\nclass LocalTokenGroup {\n    constructor(data, precTable, elseToken) {\n        this.precTable = precTable;\n        this.elseToken = elseToken;\n        this.data = typeof data == \"string\" ? decodeArray(data) : data;\n    }\n    token(input, stack) {\n        let start = input.pos, skipped = 0;\n        for (;;) {\n            let atEof = input.next < 0, nextPos = input.resolveOffset(1, 1);\n            readToken(this.data, input, stack, 0, this.data, this.precTable);\n            if (input.token.value > -1)\n                break;\n            if (this.elseToken == null)\n                return;\n            if (!atEof)\n                skipped++;\n            if (nextPos == null)\n                break;\n            input.reset(nextPos, input.token);\n        }\n        if (skipped) {\n            input.reset(start, input.token);\n            input.acceptToken(this.elseToken, skipped);\n        }\n    }\n}\nLocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;\n/**\n`@external tokens` declarations in the grammar should resolve to\nan instance of this class.\n*/\nclass ExternalTokenizer {\n    /**\n    Create a tokenizer. The first argument is the function that,\n    given an input stream, scans for the types of tokens it\n    recognizes at the stream's position, and calls\n    [`acceptToken`](#lr.InputStream.acceptToken) when it finds\n    one.\n    */\n    constructor(\n    /**\n    @internal\n    */\n    token, options = {}) {\n        this.token = token;\n        this.contextual = !!options.contextual;\n        this.fallback = !!options.fallback;\n        this.extend = !!options.extend;\n    }\n}\n// Tokenizer data is stored a big uint16 array containing, for each\n// state:\n//\n//  - A group bitmask, indicating what token groups are reachable from\n//    this state, so that paths that can only lead to tokens not in\n//    any of the current groups can be cut off early.\n//\n//  - The position of the end of the state's sequence of accepting\n//    tokens\n//\n//  - The number of outgoing edges for the state\n//\n//  - The accepting tokens, as (token id, group mask) pairs\n//\n//  - The outgoing edges, as (start character, end character, state\n//    index) triples, with end character being exclusive\n//\n// This function interprets that data, running through a stream as\n// long as new states with the a matching group mask can be reached,\n// and updating `input.token` when it matches a token.\nfunction readToken(data, input, stack, group, precTable, precOffset) {\n    let state = 0, groupMask = 1 << group, { dialect } = stack.p.parser;\n    scan: for (;;) {\n        if ((groupMask & data[state]) == 0)\n            break;\n        let accEnd = data[state + 1];\n        // Check whether this state can lead to a token in the current group\n        // Accept tokens in this state, possibly overwriting\n        // lower-precedence / shorter tokens\n        for (let i = state + 3; i < accEnd; i += 2)\n            if ((data[i + 1] & groupMask) > 0) {\n                let term = data[i];\n                if (dialect.allows(term) &&\n                    (input.token.value == -1 || input.token.value == term ||\n                        overrides(term, input.token.value, precTable, precOffset))) {\n                    input.acceptToken(term);\n                    break;\n                }\n            }\n        let next = input.next, low = 0, high = data[state + 2];\n        // Special case for EOF\n        if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 /* Seq.End */) {\n            state = data[accEnd + high * 3 - 1];\n            continue scan;\n        }\n        // Do a binary search on the state's edges\n        for (; low < high;) {\n            let mid = (low + high) >> 1;\n            let index = accEnd + mid + (mid << 1);\n            let from = data[index], to = data[index + 1] || 0x10000;\n            if (next < from)\n                high = mid;\n            else if (next >= to)\n                low = mid + 1;\n            else {\n                state = data[index + 2];\n                input.advance();\n                continue scan;\n            }\n        }\n        break;\n    }\n}\nfunction findOffset(data, start, term) {\n    for (let i = start, next; (next = data[i]) != 65535 /* Seq.End */; i++)\n        if (next == term)\n            return i - start;\n    return -1;\n}\nfunction overrides(token, prev, tableData, tableOffset) {\n    let iPrev = findOffset(tableData, tableOffset, prev);\n    return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev;\n}\n\n// Environment variable used to control console output\nconst verbose = typeof process != \"undefined\" && process.env && /\\bparse\\b/.test(process.env.LOG);\nlet stackIDs = null;\nfunction cutAt(tree, pos, side) {\n    let cursor = tree.cursor(IterMode.IncludeAnonymous);\n    cursor.moveTo(pos);\n    for (;;) {\n        if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos)))\n            for (;;) {\n                if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError)\n                    return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Lookahead.Margin */))\n                        : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Lookahead.Margin */));\n                if (side < 0 ? cursor.prevSibling() : cursor.nextSibling())\n                    break;\n                if (!cursor.parent())\n                    return side < 0 ? 0 : tree.length;\n            }\n    }\n}\nclass FragmentCursor {\n    constructor(fragments, nodeSet) {\n        this.fragments = fragments;\n        this.nodeSet = nodeSet;\n        this.i = 0;\n        this.fragment = null;\n        this.safeFrom = -1;\n        this.safeTo = -1;\n        this.trees = [];\n        this.start = [];\n        this.index = [];\n        this.nextFragment();\n    }\n    nextFragment() {\n        let fr = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];\n        if (fr) {\n            this.safeFrom = fr.openStart ? cutAt(fr.tree, fr.from + fr.offset, 1) - fr.offset : fr.from;\n            this.safeTo = fr.openEnd ? cutAt(fr.tree, fr.to + fr.offset, -1) - fr.offset : fr.to;\n            while (this.trees.length) {\n                this.trees.pop();\n                this.start.pop();\n                this.index.pop();\n            }\n            this.trees.push(fr.tree);\n            this.start.push(-fr.offset);\n            this.index.push(0);\n            this.nextStart = this.safeFrom;\n        }\n        else {\n            this.nextStart = 1e9;\n        }\n    }\n    // `pos` must be >= any previously given `pos` for this cursor\n    nodeAt(pos) {\n        if (pos < this.nextStart)\n            return null;\n        while (this.fragment && this.safeTo <= pos)\n            this.nextFragment();\n        if (!this.fragment)\n            return null;\n        for (;;) {\n            let last = this.trees.length - 1;\n            if (last < 0) { // End of tree\n                this.nextFragment();\n                return null;\n            }\n            let top = this.trees[last], index = this.index[last];\n            if (index == top.children.length) {\n                this.trees.pop();\n                this.start.pop();\n                this.index.pop();\n                continue;\n            }\n            let next = top.children[index];\n            let start = this.start[last] + top.positions[index];\n            if (start > pos) {\n                this.nextStart = start;\n                return null;\n            }\n            if (next instanceof Tree) {\n                if (start == pos) {\n                    if (start < this.safeFrom)\n                        return null;\n                    let end = start + next.length;\n                    if (end <= this.safeTo) {\n                        let lookAhead = next.prop(NodeProp.lookAhead);\n                        if (!lookAhead || end + lookAhead < this.fragment.to)\n                            return next;\n                    }\n                }\n                this.index[last]++;\n                if (start + next.length >= Math.max(this.safeFrom, pos)) { // Enter this node\n                    this.trees.push(next);\n                    this.start.push(start);\n                    this.index.push(0);\n                }\n            }\n            else {\n                this.index[last]++;\n                this.nextStart = start + next.length;\n            }\n        }\n    }\n}\nclass TokenCache {\n    constructor(parser, stream) {\n        this.stream = stream;\n        this.tokens = [];\n        this.mainToken = null;\n        this.actions = [];\n        this.tokens = parser.tokenizers.map(_ => new CachedToken);\n    }\n    getActions(stack) {\n        let actionIndex = 0;\n        let main = null;\n        let { parser } = stack.p, { tokenizers } = parser;\n        let mask = parser.stateSlot(stack.state, 3 /* ParseState.TokenizerMask */);\n        let context = stack.curContext ? stack.curContext.hash : 0;\n        let lookAhead = 0;\n        for (let i = 0; i < tokenizers.length; i++) {\n            if (((1 << i) & mask) == 0)\n                continue;\n            let tokenizer = tokenizers[i], token = this.tokens[i];\n            if (main && !tokenizer.fallback)\n                continue;\n            if (tokenizer.contextual || token.start != stack.pos || token.mask != mask || token.context != context) {\n                this.updateCachedToken(token, tokenizer, stack);\n                token.mask = mask;\n                token.context = context;\n            }\n            if (token.lookAhead > token.end + 25 /* Lookahead.Margin */)\n                lookAhead = Math.max(token.lookAhead, lookAhead);\n            if (token.value != 0 /* Term.Err */) {\n                let startIndex = actionIndex;\n                if (token.extended > -1)\n                    actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);\n                actionIndex = this.addActions(stack, token.value, token.end, actionIndex);\n                if (!tokenizer.extend) {\n                    main = token;\n                    if (actionIndex > startIndex)\n                        break;\n                }\n            }\n        }\n        while (this.actions.length > actionIndex)\n            this.actions.pop();\n        if (lookAhead)\n            stack.setLookAhead(lookAhead);\n        if (!main && stack.pos == this.stream.end) {\n            main = new CachedToken;\n            main.value = stack.p.parser.eofTerm;\n            main.start = main.end = stack.pos;\n            actionIndex = this.addActions(stack, main.value, main.end, actionIndex);\n        }\n        this.mainToken = main;\n        return this.actions;\n    }\n    getMainToken(stack) {\n        if (this.mainToken)\n            return this.mainToken;\n        let main = new CachedToken, { pos, p } = stack;\n        main.start = pos;\n        main.end = Math.min(pos + 1, p.stream.end);\n        main.value = pos == p.stream.end ? p.parser.eofTerm : 0 /* Term.Err */;\n        return main;\n    }\n    updateCachedToken(token, tokenizer, stack) {\n        let start = this.stream.clipPos(stack.pos);\n        tokenizer.token(this.stream.reset(start, token), stack);\n        if (token.value > -1) {\n            let { parser } = stack.p;\n            for (let i = 0; i < parser.specialized.length; i++)\n                if (parser.specialized[i] == token.value) {\n                    let result = parser.specializers[i](this.stream.read(token.start, token.end), stack);\n                    if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {\n                        if ((result & 1) == 0 /* Specialize.Specialize */)\n                            token.value = result >> 1;\n                        else\n                            token.extended = result >> 1;\n                        break;\n                    }\n                }\n        }\n        else {\n            token.value = 0 /* Term.Err */;\n            token.end = this.stream.clipPos(start + 1);\n        }\n    }\n    putAction(action, token, end, index) {\n        // Don't add duplicate actions\n        for (let i = 0; i < index; i += 3)\n            if (this.actions[i] == action)\n                return index;\n        this.actions[index++] = action;\n        this.actions[index++] = token;\n        this.actions[index++] = end;\n        return index;\n    }\n    addActions(stack, token, end, index) {\n        let { state } = stack, { parser } = stack.p, { data } = parser;\n        for (let set = 0; set < 2; set++) {\n            for (let i = parser.stateSlot(state, set ? 2 /* ParseState.Skip */ : 1 /* ParseState.Actions */);; i += 3) {\n                if (data[i] == 65535 /* Seq.End */) {\n                    if (data[i + 1] == 1 /* Seq.Next */) {\n                        i = pair(data, i + 2);\n                    }\n                    else {\n                        if (index == 0 && data[i + 1] == 2 /* Seq.Other */)\n                            index = this.putAction(pair(data, i + 2), token, end, index);\n                        break;\n                    }\n                }\n                if (data[i] == token)\n                    index = this.putAction(pair(data, i + 1), token, end, index);\n            }\n        }\n        return index;\n    }\n}\nclass Parse {\n    constructor(parser, input, fragments, ranges) {\n        this.parser = parser;\n        this.input = input;\n        this.ranges = ranges;\n        this.recovering = 0;\n        this.nextStackID = 0x2654; // ♔, ♕, ♖, ♗, ♘, ♙, ♠, ♡, ♢, ♣, ♤, ♥, ♦, ♧\n        this.minStackPos = 0;\n        this.reused = [];\n        this.stoppedAt = null;\n        this.lastBigReductionStart = -1;\n        this.lastBigReductionSize = 0;\n        this.bigReductionCount = 0;\n        this.stream = new InputStream(input, ranges);\n        this.tokens = new TokenCache(parser, this.stream);\n        this.topTerm = parser.top[1];\n        let { from } = ranges[0];\n        this.stacks = [Stack.start(this, parser.top[0], from)];\n        this.fragments = fragments.length && this.stream.end - from > parser.bufferLength * 4\n            ? new FragmentCursor(fragments, parser.nodeSet) : null;\n    }\n    get parsedPos() {\n        return this.minStackPos;\n    }\n    // Move the parser forward. This will process all parse stacks at\n    // `this.pos` and try to advance them to a further position. If no\n    // stack for such a position is found, it'll start error-recovery.\n    //\n    // When the parse is finished, this will return a syntax tree. When\n    // not, it returns `null`.\n    advance() {\n        let stacks = this.stacks, pos = this.minStackPos;\n        // This will hold stacks beyond `pos`.\n        let newStacks = this.stacks = [];\n        let stopped, stoppedTokens;\n        // If a large amount of reductions happened with the same start\n        // position, force the stack out of that production in order to\n        // avoid creating a tree too deep to recurse through.\n        // (This is an ugly kludge, because unfortunately there is no\n        // straightforward, cheap way to check for this happening, due to\n        // the history of reductions only being available in an\n        // expensive-to-access format in the stack buffers.)\n        if (this.bigReductionCount > 300 /* Rec.MaxLeftAssociativeReductionCount */ && stacks.length == 1) {\n            let [s] = stacks;\n            while (s.forceReduce() && s.stack.length && s.stack[s.stack.length - 2] >= this.lastBigReductionStart) { }\n            this.bigReductionCount = this.lastBigReductionSize = 0;\n        }\n        // Keep advancing any stacks at `pos` until they either move\n        // forward or can't be advanced. Gather stacks that can't be\n        // advanced further in `stopped`.\n        for (let i = 0; i < stacks.length; i++) {\n            let stack = stacks[i];\n            for (;;) {\n                this.tokens.mainToken = null;\n                if (stack.pos > pos) {\n                    newStacks.push(stack);\n                }\n                else if (this.advanceStack(stack, newStacks, stacks)) {\n                    continue;\n                }\n                else {\n                    if (!stopped) {\n                        stopped = [];\n                        stoppedTokens = [];\n                    }\n                    stopped.push(stack);\n                    let tok = this.tokens.getMainToken(stack);\n                    stoppedTokens.push(tok.value, tok.end);\n                }\n                break;\n            }\n        }\n        if (!newStacks.length) {\n            let finished = stopped && findFinished(stopped);\n            if (finished) {\n                if (verbose)\n                    console.log(\"Finish with \" + this.stackID(finished));\n                return this.stackToTree(finished);\n            }\n            if (this.parser.strict) {\n                if (verbose && stopped)\n                    console.log(\"Stuck with token \" + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : \"none\"));\n                throw new SyntaxError(\"No parse at \" + pos);\n            }\n            if (!this.recovering)\n                this.recovering = 5 /* Rec.Distance */;\n        }\n        if (this.recovering && stopped) {\n            let finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0]\n                : this.runRecovery(stopped, stoppedTokens, newStacks);\n            if (finished) {\n                if (verbose)\n                    console.log(\"Force-finish \" + this.stackID(finished));\n                return this.stackToTree(finished.forceAll());\n            }\n        }\n        if (this.recovering) {\n            let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3 /* Rec.MaxRemainingPerStep */;\n            if (newStacks.length > maxRemaining) {\n                newStacks.sort((a, b) => b.score - a.score);\n                while (newStacks.length > maxRemaining)\n                    newStacks.pop();\n            }\n            if (newStacks.some(s => s.reducePos > pos))\n                this.recovering--;\n        }\n        else if (newStacks.length > 1) {\n            // Prune stacks that are in the same state, or that have been\n            // running without splitting for a while, to avoid getting stuck\n            // with multiple successful stacks running endlessly on.\n            outer: for (let i = 0; i < newStacks.length - 1; i++) {\n                let stack = newStacks[i];\n                for (let j = i + 1; j < newStacks.length; j++) {\n                    let other = newStacks[j];\n                    if (stack.sameState(other) ||\n                        stack.buffer.length > 500 /* Rec.MinBufferLengthPrune */ && other.buffer.length > 500 /* Rec.MinBufferLengthPrune */) {\n                        if (((stack.score - other.score) || (stack.buffer.length - other.buffer.length)) > 0) {\n                            newStacks.splice(j--, 1);\n                        }\n                        else {\n                            newStacks.splice(i--, 1);\n                            continue outer;\n                        }\n                    }\n                }\n            }\n            if (newStacks.length > 12 /* Rec.MaxStackCount */)\n                newStacks.splice(12 /* Rec.MaxStackCount */, newStacks.length - 12 /* Rec.MaxStackCount */);\n        }\n        this.minStackPos = newStacks[0].pos;\n        for (let i = 1; i < newStacks.length; i++)\n            if (newStacks[i].pos < this.minStackPos)\n                this.minStackPos = newStacks[i].pos;\n        return null;\n    }\n    stopAt(pos) {\n        if (this.stoppedAt != null && this.stoppedAt < pos)\n            throw new RangeError(\"Can't move stoppedAt forward\");\n        this.stoppedAt = pos;\n    }\n    // Returns an updated version of the given stack, or null if the\n    // stack can't advance normally. When `split` and `stacks` are\n    // given, stacks split off by ambiguous operations will be pushed to\n    // `split`, or added to `stacks` if they move `pos` forward.\n    advanceStack(stack, stacks, split) {\n        let start = stack.pos, { parser } = this;\n        let base = verbose ? this.stackID(stack) + \" -> \" : \"\";\n        if (this.stoppedAt != null && start > this.stoppedAt)\n            return stack.forceReduce() ? stack : null;\n        if (this.fragments) {\n            let strictCx = stack.curContext && stack.curContext.tracker.strict, cxHash = strictCx ? stack.curContext.hash : 0;\n            for (let cached = this.fragments.nodeAt(start); cached;) {\n                let match = this.parser.nodeSet.types[cached.type.id] == cached.type ? parser.getGoto(stack.state, cached.type.id) : -1;\n                if (match > -1 && cached.length && (!strictCx || (cached.prop(NodeProp.contextHash) || 0) == cxHash)) {\n                    stack.useNode(cached, match);\n                    if (verbose)\n                        console.log(base + this.stackID(stack) + ` (via reuse of ${parser.getName(cached.type.id)})`);\n                    return true;\n                }\n                if (!(cached instanceof Tree) || cached.children.length == 0 || cached.positions[0] > 0)\n                    break;\n                let inner = cached.children[0];\n                if (inner instanceof Tree && cached.positions[0] == 0)\n                    cached = inner;\n                else\n                    break;\n            }\n        }\n        let defaultReduce = parser.stateSlot(stack.state, 4 /* ParseState.DefaultReduce */);\n        if (defaultReduce > 0) {\n            stack.reduce(defaultReduce);\n            if (verbose)\n                console.log(base + this.stackID(stack) + ` (via always-reduce ${parser.getName(defaultReduce & 65535 /* Action.ValueMask */)})`);\n            return true;\n        }\n        if (stack.stack.length >= 8400 /* Rec.CutDepth */) {\n            while (stack.stack.length > 6000 /* Rec.CutTo */ && stack.forceReduce()) { }\n        }\n        let actions = this.tokens.getActions(stack);\n        for (let i = 0; i < actions.length;) {\n            let action = actions[i++], term = actions[i++], end = actions[i++];\n            let last = i == actions.length || !split;\n            let localStack = last ? stack : stack.split();\n            let main = this.tokens.mainToken;\n            localStack.apply(action, term, main ? main.start : localStack.pos, end);\n            if (verbose)\n                console.log(base + this.stackID(localStack) + ` (via ${(action & 65536 /* Action.ReduceFlag */) == 0 ? \"shift\"\n                    : `reduce of ${parser.getName(action & 65535 /* Action.ValueMask */)}`} for ${parser.getName(term)} @ ${start}${localStack == stack ? \"\" : \", split\"})`);\n            if (last)\n                return true;\n            else if (localStack.pos > start)\n                stacks.push(localStack);\n            else\n                split.push(localStack);\n        }\n        return false;\n    }\n    // Advance a given stack forward as far as it will go. Returns the\n    // (possibly updated) stack if it got stuck, or null if it moved\n    // forward and was given to `pushStackDedup`.\n    advanceFully(stack, newStacks) {\n        let pos = stack.pos;\n        for (;;) {\n            if (!this.advanceStack(stack, null, null))\n                return false;\n            if (stack.pos > pos) {\n                pushStackDedup(stack, newStacks);\n                return true;\n            }\n        }\n    }\n    runRecovery(stacks, tokens, newStacks) {\n        let finished = null, restarted = false;\n        for (let i = 0; i < stacks.length; i++) {\n            let stack = stacks[i], token = tokens[i << 1], tokenEnd = tokens[(i << 1) + 1];\n            let base = verbose ? this.stackID(stack) + \" -> \" : \"\";\n            if (stack.deadEnd) {\n                if (restarted)\n                    continue;\n                restarted = true;\n                stack.restart();\n                if (verbose)\n                    console.log(base + this.stackID(stack) + \" (restarted)\");\n                let done = this.advanceFully(stack, newStacks);\n                if (done)\n                    continue;\n            }\n            let force = stack.split(), forceBase = base;\n            for (let j = 0; j < 10 /* Rec.ForceReduceLimit */ && force.forceReduce(); j++) {\n                if (verbose)\n                    console.log(forceBase + this.stackID(force) + \" (via force-reduce)\");\n                let done = this.advanceFully(force, newStacks);\n                if (done)\n                    break;\n                if (verbose)\n                    forceBase = this.stackID(force) + \" -> \";\n            }\n            for (let insert of stack.recoverByInsert(token)) {\n                if (verbose)\n                    console.log(base + this.stackID(insert) + \" (via recover-insert)\");\n                this.advanceFully(insert, newStacks);\n            }\n            if (this.stream.end > stack.pos) {\n                if (tokenEnd == stack.pos) {\n                    tokenEnd++;\n                    token = 0 /* Term.Err */;\n                }\n                stack.recoverByDelete(token, tokenEnd);\n                if (verbose)\n                    console.log(base + this.stackID(stack) + ` (via recover-delete ${this.parser.getName(token)})`);\n                pushStackDedup(stack, newStacks);\n            }\n            else if (!finished || finished.score < stack.score) {\n                finished = stack;\n            }\n        }\n        return finished;\n    }\n    // Convert the stack's buffer to a syntax tree.\n    stackToTree(stack) {\n        stack.close();\n        return Tree.build({ buffer: StackBufferCursor.create(stack),\n            nodeSet: this.parser.nodeSet,\n            topID: this.topTerm,\n            maxBufferLength: this.parser.bufferLength,\n            reused: this.reused,\n            start: this.ranges[0].from,\n            length: stack.pos - this.ranges[0].from,\n            minRepeatType: this.parser.minRepeatTerm });\n    }\n    stackID(stack) {\n        let id = (stackIDs || (stackIDs = new WeakMap)).get(stack);\n        if (!id)\n            stackIDs.set(stack, id = String.fromCodePoint(this.nextStackID++));\n        return id + stack;\n    }\n}\nfunction pushStackDedup(stack, newStacks) {\n    for (let i = 0; i < newStacks.length; i++) {\n        let other = newStacks[i];\n        if (other.pos == stack.pos && other.sameState(stack)) {\n            if (newStacks[i].score < stack.score)\n                newStacks[i] = stack;\n            return;\n        }\n    }\n    newStacks.push(stack);\n}\nclass Dialect {\n    constructor(source, flags, disabled) {\n        this.source = source;\n        this.flags = flags;\n        this.disabled = disabled;\n    }\n    allows(term) { return !this.disabled || this.disabled[term] == 0; }\n}\nconst id = x => x;\n/**\nContext trackers are used to track stateful context (such as\nindentation in the Python grammar, or parent elements in the XML\ngrammar) needed by external tokenizers. You declare them in a\ngrammar file as `@context exportName from \"module\"`.\n\nContext values should be immutable, and can be updated (replaced)\non shift or reduce actions.\n\nThe export used in a `@context` declaration should be of this\ntype.\n*/\nclass ContextTracker {\n    /**\n    Define a context tracker.\n    */\n    constructor(spec) {\n        this.start = spec.start;\n        this.shift = spec.shift || id;\n        this.reduce = spec.reduce || id;\n        this.reuse = spec.reuse || id;\n        this.hash = spec.hash || (() => 0);\n        this.strict = spec.strict !== false;\n    }\n}\n/**\nHolds the parse tables for a given grammar, as generated by\n`lezer-generator`, and provides [methods](#common.Parser) to parse\ncontent with.\n*/\nclass LRParser extends Parser {\n    /**\n    @internal\n    */\n    constructor(spec) {\n        super();\n        /**\n        @internal\n        */\n        this.wrappers = [];\n        if (spec.version != 14 /* File.Version */)\n            throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14 /* File.Version */})`);\n        let nodeNames = spec.nodeNames.split(\" \");\n        this.minRepeatTerm = nodeNames.length;\n        for (let i = 0; i < spec.repeatNodeCount; i++)\n            nodeNames.push(\"\");\n        let topTerms = Object.keys(spec.topRules).map(r => spec.topRules[r][1]);\n        let nodeProps = [];\n        for (let i = 0; i < nodeNames.length; i++)\n            nodeProps.push([]);\n        function setProp(nodeID, prop, value) {\n            nodeProps[nodeID].push([prop, prop.deserialize(String(value))]);\n        }\n        if (spec.nodeProps)\n            for (let propSpec of spec.nodeProps) {\n                let prop = propSpec[0];\n                if (typeof prop == \"string\")\n                    prop = NodeProp[prop];\n                for (let i = 1; i < propSpec.length;) {\n                    let next = propSpec[i++];\n                    if (next >= 0) {\n                        setProp(next, prop, propSpec[i++]);\n                    }\n                    else {\n                        let value = propSpec[i + -next];\n                        for (let j = -next; j > 0; j--)\n                            setProp(propSpec[i++], prop, value);\n                        i++;\n                    }\n                }\n            }\n        this.nodeSet = new NodeSet(nodeNames.map((name, i) => NodeType.define({\n            name: i >= this.minRepeatTerm ? undefined : name,\n            id: i,\n            props: nodeProps[i],\n            top: topTerms.indexOf(i) > -1,\n            error: i == 0,\n            skipped: spec.skippedNodes && spec.skippedNodes.indexOf(i) > -1\n        })));\n        if (spec.propSources)\n            this.nodeSet = this.nodeSet.extend(...spec.propSources);\n        this.strict = false;\n        this.bufferLength = DefaultBufferLength;\n        let tokenArray = decodeArray(spec.tokenData);\n        this.context = spec.context;\n        this.specializerSpecs = spec.specialized || [];\n        this.specialized = new Uint16Array(this.specializerSpecs.length);\n        for (let i = 0; i < this.specializerSpecs.length; i++)\n            this.specialized[i] = this.specializerSpecs[i].term;\n        this.specializers = this.specializerSpecs.map(getSpecializer);\n        this.states = decodeArray(spec.states, Uint32Array);\n        this.data = decodeArray(spec.stateData);\n        this.goto = decodeArray(spec.goto);\n        this.maxTerm = spec.maxTerm;\n        this.tokenizers = spec.tokenizers.map(value => typeof value == \"number\" ? new TokenGroup(tokenArray, value) : value);\n        this.topRules = spec.topRules;\n        this.dialects = spec.dialects || {};\n        this.dynamicPrecedences = spec.dynamicPrecedences || null;\n        this.tokenPrecTable = spec.tokenPrec;\n        this.termNames = spec.termNames || null;\n        this.maxNode = this.nodeSet.types.length - 1;\n        this.dialect = this.parseDialect();\n        this.top = this.topRules[Object.keys(this.topRules)[0]];\n    }\n    createParse(input, fragments, ranges) {\n        let parse = new Parse(this, input, fragments, ranges);\n        for (let w of this.wrappers)\n            parse = w(parse, input, fragments, ranges);\n        return parse;\n    }\n    /**\n    Get a goto table entry @internal\n    */\n    getGoto(state, term, loose = false) {\n        let table = this.goto;\n        if (term >= table[0])\n            return -1;\n        for (let pos = table[term + 1];;) {\n            let groupTag = table[pos++], last = groupTag & 1;\n            let target = table[pos++];\n            if (last && loose)\n                return target;\n            for (let end = pos + (groupTag >> 1); pos < end; pos++)\n                if (table[pos] == state)\n                    return target;\n            if (last)\n                return -1;\n        }\n    }\n    /**\n    Check if this state has an action for a given terminal @internal\n    */\n    hasAction(state, terminal) {\n        let data = this.data;\n        for (let set = 0; set < 2; set++) {\n            for (let i = this.stateSlot(state, set ? 2 /* ParseState.Skip */ : 1 /* ParseState.Actions */), next;; i += 3) {\n                if ((next = data[i]) == 65535 /* Seq.End */) {\n                    if (data[i + 1] == 1 /* Seq.Next */)\n                        next = data[i = pair(data, i + 2)];\n                    else if (data[i + 1] == 2 /* Seq.Other */)\n                        return pair(data, i + 2);\n                    else\n                        break;\n                }\n                if (next == terminal || next == 0 /* Term.Err */)\n                    return pair(data, i + 1);\n            }\n        }\n        return 0;\n    }\n    /**\n    @internal\n    */\n    stateSlot(state, slot) {\n        return this.states[(state * 6 /* ParseState.Size */) + slot];\n    }\n    /**\n    @internal\n    */\n    stateFlag(state, flag) {\n        return (this.stateSlot(state, 0 /* ParseState.Flags */) & flag) > 0;\n    }\n    /**\n    @internal\n    */\n    validAction(state, action) {\n        return !!this.allActions(state, a => a == action ? true : null);\n    }\n    /**\n    @internal\n    */\n    allActions(state, action) {\n        let deflt = this.stateSlot(state, 4 /* ParseState.DefaultReduce */);\n        let result = deflt ? action(deflt) : undefined;\n        for (let i = this.stateSlot(state, 1 /* ParseState.Actions */); result == null; i += 3) {\n            if (this.data[i] == 65535 /* Seq.End */) {\n                if (this.data[i + 1] == 1 /* Seq.Next */)\n                    i = pair(this.data, i + 2);\n                else\n                    break;\n            }\n            result = action(pair(this.data, i + 1));\n        }\n        return result;\n    }\n    /**\n    Get the states that can follow this one through shift actions or\n    goto jumps. @internal\n    */\n    nextStates(state) {\n        let result = [];\n        for (let i = this.stateSlot(state, 1 /* ParseState.Actions */);; i += 3) {\n            if (this.data[i] == 65535 /* Seq.End */) {\n                if (this.data[i + 1] == 1 /* Seq.Next */)\n                    i = pair(this.data, i + 2);\n                else\n                    break;\n            }\n            if ((this.data[i + 2] & (65536 /* Action.ReduceFlag */ >> 16)) == 0) {\n                let value = this.data[i + 1];\n                if (!result.some((v, i) => (i & 1) && v == value))\n                    result.push(this.data[i], value);\n            }\n        }\n        return result;\n    }\n    /**\n    Configure the parser. Returns a new parser instance that has the\n    given settings modified. Settings not provided in `config` are\n    kept from the original parser.\n    */\n    configure(config) {\n        // Hideous reflection-based kludge to make it easy to create a\n        // slightly modified copy of a parser.\n        let copy = Object.assign(Object.create(LRParser.prototype), this);\n        if (config.props)\n            copy.nodeSet = this.nodeSet.extend(...config.props);\n        if (config.top) {\n            let info = this.topRules[config.top];\n            if (!info)\n                throw new RangeError(`Invalid top rule name ${config.top}`);\n            copy.top = info;\n        }\n        if (config.tokenizers)\n            copy.tokenizers = this.tokenizers.map(t => {\n                let found = config.tokenizers.find(r => r.from == t);\n                return found ? found.to : t;\n            });\n        if (config.specializers) {\n            copy.specializers = this.specializers.slice();\n            copy.specializerSpecs = this.specializerSpecs.map((s, i) => {\n                let found = config.specializers.find(r => r.from == s.external);\n                if (!found)\n                    return s;\n                let spec = Object.assign(Object.assign({}, s), { external: found.to });\n                copy.specializers[i] = getSpecializer(spec);\n                return spec;\n            });\n        }\n        if (config.contextTracker)\n            copy.context = config.contextTracker;\n        if (config.dialect)\n            copy.dialect = this.parseDialect(config.dialect);\n        if (config.strict != null)\n            copy.strict = config.strict;\n        if (config.wrap)\n            copy.wrappers = copy.wrappers.concat(config.wrap);\n        if (config.bufferLength != null)\n            copy.bufferLength = config.bufferLength;\n        return copy;\n    }\n    /**\n    Tells you whether any [parse wrappers](#lr.ParserConfig.wrap)\n    are registered for this parser.\n    */\n    hasWrappers() {\n        return this.wrappers.length > 0;\n    }\n    /**\n    Returns the name associated with a given term. This will only\n    work for all terms when the parser was generated with the\n    `--names` option. By default, only the names of tagged terms are\n    stored.\n    */\n    getName(term) {\n        return this.termNames ? this.termNames[term] : String(term <= this.maxNode && this.nodeSet.types[term].name || term);\n    }\n    /**\n    The eof term id is always allocated directly after the node\n    types. @internal\n    */\n    get eofTerm() { return this.maxNode + 1; }\n    /**\n    The type of top node produced by the parser.\n    */\n    get topNode() { return this.nodeSet.types[this.top[1]]; }\n    /**\n    @internal\n    */\n    dynamicPrecedence(term) {\n        let prec = this.dynamicPrecedences;\n        return prec == null ? 0 : prec[term] || 0;\n    }\n    /**\n    @internal\n    */\n    parseDialect(dialect) {\n        let values = Object.keys(this.dialects), flags = values.map(() => false);\n        if (dialect)\n            for (let part of dialect.split(\" \")) {\n                let id = values.indexOf(part);\n                if (id >= 0)\n                    flags[id] = true;\n            }\n        let disabled = null;\n        for (let i = 0; i < values.length; i++)\n            if (!flags[i]) {\n                for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535 /* Seq.End */;)\n                    (disabled || (disabled = new Uint8Array(this.maxTerm + 1)))[id] = 1;\n            }\n        return new Dialect(dialect, flags, disabled);\n    }\n    /**\n    Used by the output of the parser generator. Not available to\n    user code. @hide\n    */\n    static deserialize(spec) {\n        return new LRParser(spec);\n    }\n}\nfunction pair(data, off) { return data[off] | (data[off + 1] << 16); }\nfunction findFinished(stacks) {\n    let best = null;\n    for (let stack of stacks) {\n        let stopped = stack.p.stoppedAt;\n        if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) &&\n            stack.p.parser.stateFlag(stack.state, 2 /* StateFlag.Accepting */) &&\n            (!best || best.score < stack.score))\n            best = stack;\n    }\n    return best;\n}\nfunction getSpecializer(spec) {\n    if (spec.external) {\n        let mask = spec.extend ? 1 /* Specialize.Extend */ : 0 /* Specialize.Specialize */;\n        return (value, stack) => (spec.external(value, stack) << 1) | mask;\n    }\n    return spec.get;\n}\n\nexport { ContextTracker, ExternalTokenizer, InputStream, LRParser, LocalTokenGroup, Stack };\n"],"names":["Stack","p","stack","state","reducePos","pos","score","buffer","bufferBase","curContext","lookAhead","parent","_","i","cx","StackContext","start","action","_a","depth","type","parser","lookaheadRecord","dPrec","base","size","count","baseStateID","term","end","mustSink","cur","top","index","mustMove","scan","nextState","next","nextStart","nextEnd","value","off","isNode","sim","SimulatedStack","nextStates","best","s","v","result","reduce","target","backup","seen","explore","rDepth","found","other","dialectID","last","context","newCx","tracker","goto","StackBufferCursor","decodeArray","input","Type","array","out","stop","digit","CachedToken","nullToken","InputStream","ranges","offset","assoc","range","idx","resolved","token","endOffset","endPos","chunk","chunkPos","nextChunk","n","from","to","r","TokenGroup","data","id","readToken","LocalTokenGroup","precTable","elseToken","skipped","atEof","nextPos","ExternalTokenizer","options","group","precOffset","groupMask","dialect","accEnd","overrides","low","high","mid","findOffset","prev","tableData","tableOffset","iPrev","verbose","stackIDs","cutAt","tree","side","cursor","IterMode","FragmentCursor","fragments","nodeSet","fr","Tree","NodeProp","TokenCache","stream","actionIndex","main","tokenizers","mask","tokenizer","startIndex","set","pair","Parse","stacks","newStacks","stopped","stoppedTokens","tok","finished","findFinished","maxRemaining","a","b","outer","j","split","strictCx","cxHash","cached","match","inner","defaultReduce","actions","localStack","pushStackDedup","tokens","restarted","tokenEnd","force","forceBase","insert","Dialect","source","flags","disabled","x","ContextTracker","spec","LRParser","Parser","nodeNames","topTerms","nodeProps","setProp","nodeID","prop","propSpec","NodeSet","name","NodeType","DefaultBufferLength","tokenArray","getSpecializer","parse","w","loose","table","groupTag","terminal","slot","flag","deflt","config","copy","info","t","prec","values","part"],"mappings":"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","x_google_ignoreList":[0]}