diff --git "a/src/backend/gradio_tokenizertextbox/templates/component/radar-VG2SY3DT-DUR9h7DO.js" "b/src/backend/gradio_tokenizertextbox/templates/component/radar-VG2SY3DT-DUR9h7DO.js" new file mode 100644--- /dev/null +++ "b/src/backend/gradio_tokenizertextbox/templates/component/radar-VG2SY3DT-DUR9h7DO.js" @@ -0,0 +1,12784 @@ +var Eu = Object.defineProperty; +var ku = (n, e, t) => e in n ? Eu(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t; +var Qe = (n, e, t) => ku(n, typeof e != "symbol" ? e + "" : e, t); +import { bx as xu, by as $u, aO as Rl, bh as Su, aS as Iu, aP as ee, aA as Nu, aB as ha, b7 as Cu, ba as vl, bb as Al, b8 as wu, bm as pa, aD as gt, aE as D, aQ as ma, aK as _u } from "./mermaid.core-BiIw1_mh.js"; +import { k as Kt, j as Ps, g as Jt, S as Lu, w as Ou, x as bu, c as El, v as z, y as kl, l as Pu, z as Mu, A as Du, B as Fu, C as Gu, a as xl, d as N, i as qe, r as oe, f as xe, D as Y } from "./_baseUniq-BzpV2HJ8.js"; +import { j as Ms, m as $, d as Uu, f as Ce, g as Wt, h as C, i as Ds, l as jt, e as Bu } from "./_basePickBy-DxXFlUZa.js"; +import { c as ne } from "./clone-CnKi__lm.js"; +var Vu = Object.prototype, Ku = Vu.hasOwnProperty, ke = xu(function(n, e) { + if ($u(e) || Rl(e)) { + Su(e, Kt(e), n); + return; + } + for (var t in e) + Ku.call(e, t) && Iu(n, t, e[t]); +}); +function $l(n, e, t) { + var r = -1, i = n.length; + e < 0 && (e = -e > i ? 0 : i + e), t = t > i ? i : t, t < 0 && (t += i), i = e > t ? 0 : t - e >>> 0, e >>>= 0; + for (var s = Array(i); ++r < i; ) + s[r] = n[r + e]; + return s; +} +function Xn(n) { + for (var e = -1, t = n == null ? 0 : n.length, r = 0, i = []; ++e < t; ) { + var s = n[e]; + s && (i[r++] = s); + } + return i; +} +function Wu(n, e, t, r) { + for (var i = -1, s = n == null ? 0 : n.length; ++i < s; ) { + var a = n[i]; + e(r, a, t(a), n); + } + return r; +} +function ju(n, e, t, r) { + return Ps(n, function(i, s, a) { + e(r, i, t(i), a); + }), r; +} +function Hu(n, e) { + return function(t, r) { + var i = ee(t) ? Wu : ju, s = e ? e() : {}; + return i(t, n, Jt(r), s); + }; +} +var zu = 200; +function qu(n, e, t, r) { + var i = -1, s = Ou, a = !0, o = n.length, l = [], c = e.length; + if (!o) + return l; + e.length >= zu && (s = bu, a = !1, e = new Lu(e)); + e: + for (; ++i < o; ) { + var u = n[i], d = u; + if (u = u !== 0 ? u : 0, a && d === d) { + for (var h = c; h--; ) + if (e[h] === d) + continue e; + l.push(u); + } else s(e, d, r) || l.push(u); + } + return l; +} +var ai = Nu(function(n, e) { + return ha(n) ? qu(n, El(e, 1, ha, !0)) : []; +}); +function J(n, e, t) { + var r = n == null ? 0 : n.length; + return r ? (e = e === void 0 ? 1 : Ms(e), $l(n, e < 0 ? 0 : e, r)) : []; +} +function jn(n, e, t) { + var r = n == null ? 0 : n.length; + return r ? (e = e === void 0 ? 1 : Ms(e), e = r - e, $l(n, 0, e < 0 ? 0 : e)) : []; +} +function Yu(n, e) { + for (var t = -1, r = n == null ? 0 : n.length; ++t < r; ) + if (!e(n[t], t, n)) + return !1; + return !0; +} +function Xu(n, e) { + var t = !0; + return Ps(n, function(r, i, s) { + return t = !!e(r, i, s), t; + }), t; +} +function be(n, e, t) { + var r = ee(n) ? Yu : Xu; + return r(n, Jt(e)); +} +function Pe(n) { + return n && n.length ? n[0] : void 0; +} +function Ee(n, e) { + return El($(n, e)); +} +var Ju = Object.prototype, Qu = Ju.hasOwnProperty, Zu = Hu(function(n, e, t) { + Qu.call(n, t) ? n[t].push(e) : Cu(n, t, [e]); +}), ed = "[object String]"; +function fe(n) { + return typeof n == "string" || !ee(n) && vl(n) && Al(n) == ed; +} +var td = Math.max; +function ue(n, e, t, r) { + n = Rl(n) ? n : z(n), t = t ? Ms(t) : 0; + var i = n.length; + return t < 0 && (t = td(i + t, 0)), fe(n) ? t <= i && n.indexOf(e, t) > -1 : !!i && kl(n, e, t) > -1; +} +function ga(n, e, t) { + var r = n == null ? 0 : n.length; + if (!r) + return -1; + var i = 0; + return kl(n, e, i); +} +var nd = "[object RegExp]"; +function rd(n) { + return vl(n) && Al(n) == nd; +} +var ya = pa && pa.isRegExp, Ye = ya ? wu(ya) : rd, id = "Expected a function"; +function sd(n) { + if (typeof n != "function") + throw new TypeError(id); + return function() { + var e = arguments; + switch (e.length) { + case 0: + return !n.call(this); + case 1: + return !n.call(this, e[0]); + case 2: + return !n.call(this, e[0], e[1]); + case 3: + return !n.call(this, e[0], e[1], e[2]); + } + return !n.apply(this, e); + }; +} +function Me(n, e) { + if (n == null) + return {}; + var t = Pu(Mu(n), function(r) { + return [r]; + }); + return e = Jt(e), Uu(n, t, function(r, i) { + return e(r, i[0]); + }); +} +function oi(n, e) { + var t = ee(n) ? Du : Fu; + return t(n, sd(Jt(e))); +} +function ad(n, e) { + var t; + return Ps(n, function(r, i, s) { + return t = e(r, i, s), !t; + }), !!t; +} +function Sl(n, e, t) { + var r = ee(n) ? Gu : ad; + return r(n, Jt(e)); +} +function Fs(n) { + return n && n.length ? xl(n) : []; +} +function od(n, e) { + return n && n.length ? xl(n, Jt(e)) : []; +} +function ae(n) { + return typeof n == "object" && n !== null && typeof n.$type == "string"; +} +function Ge(n) { + return typeof n == "object" && n !== null && typeof n.$refText == "string"; +} +function ld(n) { + return typeof n == "object" && n !== null && typeof n.name == "string" && typeof n.type == "string" && typeof n.path == "string"; +} +function Er(n) { + return typeof n == "object" && n !== null && ae(n.container) && Ge(n.reference) && typeof n.message == "string"; +} +class Il { + constructor() { + this.subtypes = {}, this.allSubtypes = {}; + } + isInstance(e, t) { + return ae(e) && this.isSubtype(e.$type, t); + } + isSubtype(e, t) { + if (e === t) + return !0; + let r = this.subtypes[e]; + r || (r = this.subtypes[e] = {}); + const i = r[t]; + if (i !== void 0) + return i; + { + const s = this.computeIsSubtype(e, t); + return r[t] = s, s; + } + } + getAllSubTypes(e) { + const t = this.allSubtypes[e]; + if (t) + return t; + { + const r = this.getAllTypes(), i = []; + for (const s of r) + this.isSubtype(s, e) && i.push(s); + return this.allSubtypes[e] = i, i; + } + } +} +function Hn(n) { + return typeof n == "object" && n !== null && Array.isArray(n.content); +} +function Nl(n) { + return typeof n == "object" && n !== null && typeof n.tokenType == "object"; +} +function Cl(n) { + return Hn(n) && typeof n.fullText == "string"; +} +class Q { + constructor(e, t) { + this.startFn = e, this.nextFn = t; + } + iterator() { + const e = { + state: this.startFn(), + next: () => this.nextFn(e.state), + [Symbol.iterator]: () => e + }; + return e; + } + [Symbol.iterator]() { + return this.iterator(); + } + isEmpty() { + return !!this.iterator().next().done; + } + count() { + const e = this.iterator(); + let t = 0, r = e.next(); + for (; !r.done; ) + t++, r = e.next(); + return t; + } + toArray() { + const e = [], t = this.iterator(); + let r; + do + r = t.next(), r.value !== void 0 && e.push(r.value); + while (!r.done); + return e; + } + toSet() { + return new Set(this); + } + toMap(e, t) { + const r = this.map((i) => [ + e ? e(i) : i, + t ? t(i) : i + ]); + return new Map(r); + } + toString() { + return this.join(); + } + concat(e) { + return new Q(() => ({ first: this.startFn(), firstDone: !1, iterator: e[Symbol.iterator]() }), (t) => { + let r; + if (!t.firstDone) { + do + if (r = this.nextFn(t.first), !r.done) + return r; + while (!r.done); + t.firstDone = !0; + } + do + if (r = t.iterator.next(), !r.done) + return r; + while (!r.done); + return ve; + }); + } + join(e = ",") { + const t = this.iterator(); + let r = "", i, s = !1; + do + i = t.next(), i.done || (s && (r += e), r += cd(i.value)), s = !0; + while (!i.done); + return r; + } + indexOf(e, t = 0) { + const r = this.iterator(); + let i = 0, s = r.next(); + for (; !s.done; ) { + if (i >= t && s.value === e) + return i; + s = r.next(), i++; + } + return -1; + } + every(e) { + const t = this.iterator(); + let r = t.next(); + for (; !r.done; ) { + if (!e(r.value)) + return !1; + r = t.next(); + } + return !0; + } + some(e) { + const t = this.iterator(); + let r = t.next(); + for (; !r.done; ) { + if (e(r.value)) + return !0; + r = t.next(); + } + return !1; + } + forEach(e) { + const t = this.iterator(); + let r = 0, i = t.next(); + for (; !i.done; ) + e(i.value, r), i = t.next(), r++; + } + map(e) { + return new Q(this.startFn, (t) => { + const { done: r, value: i } = this.nextFn(t); + return r ? ve : { done: !1, value: e(i) }; + }); + } + filter(e) { + return new Q(this.startFn, (t) => { + let r; + do + if (r = this.nextFn(t), !r.done && e(r.value)) + return r; + while (!r.done); + return ve; + }); + } + nonNullable() { + return this.filter((e) => e != null); + } + reduce(e, t) { + const r = this.iterator(); + let i = t, s = r.next(); + for (; !s.done; ) + i === void 0 ? i = s.value : i = e(i, s.value), s = r.next(); + return i; + } + reduceRight(e, t) { + return this.recursiveReduce(this.iterator(), e, t); + } + recursiveReduce(e, t, r) { + const i = e.next(); + if (i.done) + return r; + const s = this.recursiveReduce(e, t, r); + return s === void 0 ? i.value : t(s, i.value); + } + find(e) { + const t = this.iterator(); + let r = t.next(); + for (; !r.done; ) { + if (e(r.value)) + return r.value; + r = t.next(); + } + } + findIndex(e) { + const t = this.iterator(); + let r = 0, i = t.next(); + for (; !i.done; ) { + if (e(i.value)) + return r; + i = t.next(), r++; + } + return -1; + } + includes(e) { + const t = this.iterator(); + let r = t.next(); + for (; !r.done; ) { + if (r.value === e) + return !0; + r = t.next(); + } + return !1; + } + flatMap(e) { + return new Q(() => ({ this: this.startFn() }), (t) => { + do { + if (t.iterator) { + const s = t.iterator.next(); + if (s.done) + t.iterator = void 0; + else + return s; + } + const { done: r, value: i } = this.nextFn(t.this); + if (!r) { + const s = e(i); + if (Mr(s)) + t.iterator = s[Symbol.iterator](); + else + return { done: !1, value: s }; + } + } while (t.iterator); + return ve; + }); + } + flat(e) { + if (e === void 0 && (e = 1), e <= 0) + return this; + const t = e > 1 ? this.flat(e - 1) : this; + return new Q(() => ({ this: t.startFn() }), (r) => { + do { + if (r.iterator) { + const a = r.iterator.next(); + if (a.done) + r.iterator = void 0; + else + return a; + } + const { done: i, value: s } = t.nextFn(r.this); + if (!i) + if (Mr(s)) + r.iterator = s[Symbol.iterator](); + else + return { done: !1, value: s }; + } while (r.iterator); + return ve; + }); + } + head() { + const t = this.iterator().next(); + if (!t.done) + return t.value; + } + tail(e = 1) { + return new Q(() => { + const t = this.startFn(); + for (let r = 0; r < e; r++) + if (this.nextFn(t).done) + return t; + return t; + }, this.nextFn); + } + limit(e) { + return new Q(() => ({ size: 0, state: this.startFn() }), (t) => (t.size++, t.size > e ? ve : this.nextFn(t.state))); + } + distinct(e) { + return new Q(() => ({ set: /* @__PURE__ */ new Set(), internalState: this.startFn() }), (t) => { + let r; + do + if (r = this.nextFn(t.internalState), !r.done) { + const i = e ? e(r.value) : r.value; + if (!t.set.has(i)) + return t.set.add(i), r; + } + while (!r.done); + return ve; + }); + } + exclude(e, t) { + const r = /* @__PURE__ */ new Set(); + for (const i of e) { + const s = t ? t(i) : i; + r.add(s); + } + return this.filter((i) => { + const s = t ? t(i) : i; + return !r.has(s); + }); + } +} +function cd(n) { + return typeof n == "string" ? n : typeof n > "u" ? "undefined" : typeof n.toString == "function" ? n.toString() : Object.prototype.toString.call(n); +} +function Mr(n) { + return !!n && typeof n[Symbol.iterator] == "function"; +} +const ud = new Q(() => { +}, () => ve), ve = Object.freeze({ done: !0, value: void 0 }); +function Z(...n) { + if (n.length === 1) { + const e = n[0]; + if (e instanceof Q) + return e; + if (Mr(e)) + return new Q(() => e[Symbol.iterator](), (t) => t.next()); + if (typeof e.length == "number") + return new Q(() => ({ index: 0 }), (t) => t.index < e.length ? { done: !1, value: e[t.index++] } : ve); + } + return n.length > 1 ? new Q(() => ({ collIndex: 0, arrIndex: 0 }), (e) => { + do { + if (e.iterator) { + const t = e.iterator.next(); + if (!t.done) + return t; + e.iterator = void 0; + } + if (e.array) { + if (e.arrIndex < e.array.length) + return { done: !1, value: e.array[e.arrIndex++] }; + e.array = void 0, e.arrIndex = 0; + } + if (e.collIndex < n.length) { + const t = n[e.collIndex++]; + Mr(t) ? e.iterator = t[Symbol.iterator]() : t && typeof t.length == "number" && (e.array = t); + } + } while (e.iterator || e.array || e.collIndex < n.length); + return ve; + }) : ud; +} +class Gs extends Q { + constructor(e, t, r) { + super(() => ({ + iterators: r != null && r.includeRoot ? [[e][Symbol.iterator]()] : [t(e)[Symbol.iterator]()], + pruned: !1 + }), (i) => { + for (i.pruned && (i.iterators.pop(), i.pruned = !1); i.iterators.length > 0; ) { + const a = i.iterators[i.iterators.length - 1].next(); + if (a.done) + i.iterators.pop(); + else + return i.iterators.push(t(a.value)[Symbol.iterator]()), a; + } + return ve; + }); + } + iterator() { + const e = { + state: this.startFn(), + next: () => this.nextFn(e.state), + prune: () => { + e.state.pruned = !0; + }, + [Symbol.iterator]: () => e + }; + return e; + } +} +var Xi; +(function(n) { + function e(s) { + return s.reduce((a, o) => a + o, 0); + } + n.sum = e; + function t(s) { + return s.reduce((a, o) => a * o, 0); + } + n.product = t; + function r(s) { + return s.reduce((a, o) => Math.min(a, o)); + } + n.min = r; + function i(s) { + return s.reduce((a, o) => Math.max(a, o)); + } + n.max = i; +})(Xi || (Xi = {})); +function Ji(n) { + return new Gs(n, (e) => Hn(e) ? e.content : [], { includeRoot: !0 }); +} +function dd(n, e) { + for (; n.container; ) + if (n = n.container, n === e) + return !0; + return !1; +} +function Qi(n) { + return { + start: { + character: n.startColumn - 1, + line: n.startLine - 1 + }, + end: { + character: n.endColumn, + // endColumn uses the correct index + line: n.endLine - 1 + } + }; +} +function Dr(n) { + if (!n) + return; + const { offset: e, end: t, range: r } = n; + return { + range: r, + offset: e, + end: t, + length: t - e + }; +} +var je; +(function(n) { + n[n.Before = 0] = "Before", n[n.After = 1] = "After", n[n.OverlapFront = 2] = "OverlapFront", n[n.OverlapBack = 3] = "OverlapBack", n[n.Inside = 4] = "Inside", n[n.Outside = 5] = "Outside"; +})(je || (je = {})); +function fd(n, e) { + if (n.end.line < e.start.line || n.end.line === e.start.line && n.end.character <= e.start.character) + return je.Before; + if (n.start.line > e.end.line || n.start.line === e.end.line && n.start.character >= e.end.character) + return je.After; + const t = n.start.line > e.start.line || n.start.line === e.start.line && n.start.character >= e.start.character, r = n.end.line < e.end.line || n.end.line === e.end.line && n.end.character <= e.end.character; + return t && r ? je.Inside : t ? je.OverlapBack : r ? je.OverlapFront : je.Outside; +} +function hd(n, e) { + return fd(n, e) > je.After; +} +const pd = /^[\w\p{L}]$/u; +function md(n, e) { + if (n) { + const t = gd(n, !0); + if (t && Ta(t, e)) + return t; + if (Cl(n)) { + const r = n.content.findIndex((i) => !i.hidden); + for (let i = r - 1; i >= 0; i--) { + const s = n.content[i]; + if (Ta(s, e)) + return s; + } + } + } +} +function Ta(n, e) { + return Nl(n) && e.includes(n.tokenType.name); +} +function gd(n, e = !0) { + for (; n.container; ) { + const t = n.container; + let r = t.content.indexOf(n); + for (; r > 0; ) { + r--; + const i = t.content[r]; + if (e || !i.hidden) + return i; + } + n = t; + } +} +class wl extends Error { + constructor(e, t) { + super(e ? `${t} at ${e.range.start.line}:${e.range.start.character}` : t); + } +} +function Jn(n) { + throw new Error("Error! The input value was not handled."); +} +const ir = "AbstractRule", sr = "AbstractType", xi = "Condition", Ra = "TypeDefinition", $i = "ValueLiteral", ln = "AbstractElement"; +function yd(n) { + return M.isInstance(n, ln); +} +const ar = "ArrayLiteral", or = "ArrayType", cn = "BooleanLiteral"; +function Td(n) { + return M.isInstance(n, cn); +} +const un = "Conjunction"; +function Rd(n) { + return M.isInstance(n, un); +} +const dn = "Disjunction"; +function vd(n) { + return M.isInstance(n, dn); +} +const lr = "Grammar", Si = "GrammarImport", fn = "InferredType"; +function _l(n) { + return M.isInstance(n, fn); +} +const hn = "Interface"; +function Ll(n) { + return M.isInstance(n, hn); +} +const Ii = "NamedArgument", pn = "Negation"; +function Ad(n) { + return M.isInstance(n, pn); +} +const cr = "NumberLiteral", ur = "Parameter", mn = "ParameterReference"; +function Ed(n) { + return M.isInstance(n, mn); +} +const gn = "ParserRule"; +function we(n) { + return M.isInstance(n, gn); +} +const dr = "ReferenceType", kr = "ReturnType"; +function kd(n) { + return M.isInstance(n, kr); +} +const yn = "SimpleType"; +function xd(n) { + return M.isInstance(n, yn); +} +const fr = "StringLiteral", $t = "TerminalRule"; +function yt(n) { + return M.isInstance(n, $t); +} +const Tn = "Type"; +function Ol(n) { + return M.isInstance(n, Tn); +} +const Ni = "TypeAttribute", hr = "UnionType", Rn = "Action"; +function li(n) { + return M.isInstance(n, Rn); +} +const vn = "Alternatives"; +function bl(n) { + return M.isInstance(n, vn); +} +const An = "Assignment"; +function ut(n) { + return M.isInstance(n, An); +} +const En = "CharacterRange"; +function $d(n) { + return M.isInstance(n, En); +} +const kn = "CrossReference"; +function Us(n) { + return M.isInstance(n, kn); +} +const xn = "EndOfFile"; +function Sd(n) { + return M.isInstance(n, xn); +} +const $n = "Group"; +function Bs(n) { + return M.isInstance(n, $n); +} +const Sn = "Keyword"; +function dt(n) { + return M.isInstance(n, Sn); +} +const In = "NegatedToken"; +function Id(n) { + return M.isInstance(n, In); +} +const Nn = "RegexToken"; +function Nd(n) { + return M.isInstance(n, Nn); +} +const Cn = "RuleCall"; +function ft(n) { + return M.isInstance(n, Cn); +} +const wn = "TerminalAlternatives"; +function Cd(n) { + return M.isInstance(n, wn); +} +const _n = "TerminalGroup"; +function wd(n) { + return M.isInstance(n, _n); +} +const Ln = "TerminalRuleCall"; +function _d(n) { + return M.isInstance(n, Ln); +} +const On = "UnorderedGroup"; +function Pl(n) { + return M.isInstance(n, On); +} +const bn = "UntilToken"; +function Ld(n) { + return M.isInstance(n, bn); +} +const Pn = "Wildcard"; +function Od(n) { + return M.isInstance(n, Pn); +} +class Ml extends Il { + getAllTypes() { + return [ln, ir, sr, Rn, vn, ar, or, An, cn, En, xi, un, kn, dn, xn, lr, Si, $n, fn, hn, Sn, Ii, In, pn, cr, ur, mn, gn, dr, Nn, kr, Cn, yn, fr, wn, _n, $t, Ln, Tn, Ni, Ra, hr, On, bn, $i, Pn]; + } + computeIsSubtype(e, t) { + switch (e) { + case Rn: + case vn: + case An: + case En: + case kn: + case xn: + case $n: + case Sn: + case In: + case Nn: + case Cn: + case wn: + case _n: + case Ln: + case On: + case bn: + case Pn: + return this.isSubtype(ln, t); + case ar: + case cr: + case fr: + return this.isSubtype($i, t); + case or: + case dr: + case yn: + case hr: + return this.isSubtype(Ra, t); + case cn: + return this.isSubtype(xi, t) || this.isSubtype($i, t); + case un: + case dn: + case pn: + case mn: + return this.isSubtype(xi, t); + case fn: + case hn: + case Tn: + return this.isSubtype(sr, t); + case gn: + return this.isSubtype(ir, t) || this.isSubtype(sr, t); + case $t: + return this.isSubtype(ir, t); + default: + return !1; + } + } + getReferenceType(e) { + const t = `${e.container.$type}:${e.property}`; + switch (t) { + case "Action:type": + case "CrossReference:type": + case "Interface:superTypes": + case "ParserRule:returnType": + case "SimpleType:typeRef": + return sr; + case "Grammar:hiddenTokens": + case "ParserRule:hiddenTokens": + case "RuleCall:rule": + return ir; + case "Grammar:usedGrammars": + return lr; + case "NamedArgument:parameter": + case "ParameterReference:parameter": + return ur; + case "TerminalRuleCall:rule": + return $t; + default: + throw new Error(`${t} is not a valid reference id.`); + } + } + getTypeMetaData(e) { + switch (e) { + case ln: + return { + name: ln, + properties: [ + { name: "cardinality" }, + { name: "lookahead" } + ] + }; + case ar: + return { + name: ar, + properties: [ + { name: "elements", defaultValue: [] } + ] + }; + case or: + return { + name: or, + properties: [ + { name: "elementType" } + ] + }; + case cn: + return { + name: cn, + properties: [ + { name: "true", defaultValue: !1 } + ] + }; + case un: + return { + name: un, + properties: [ + { name: "left" }, + { name: "right" } + ] + }; + case dn: + return { + name: dn, + properties: [ + { name: "left" }, + { name: "right" } + ] + }; + case lr: + return { + name: lr, + properties: [ + { name: "definesHiddenTokens", defaultValue: !1 }, + { name: "hiddenTokens", defaultValue: [] }, + { name: "imports", defaultValue: [] }, + { name: "interfaces", defaultValue: [] }, + { name: "isDeclared", defaultValue: !1 }, + { name: "name" }, + { name: "rules", defaultValue: [] }, + { name: "types", defaultValue: [] }, + { name: "usedGrammars", defaultValue: [] } + ] + }; + case Si: + return { + name: Si, + properties: [ + { name: "path" } + ] + }; + case fn: + return { + name: fn, + properties: [ + { name: "name" } + ] + }; + case hn: + return { + name: hn, + properties: [ + { name: "attributes", defaultValue: [] }, + { name: "name" }, + { name: "superTypes", defaultValue: [] } + ] + }; + case Ii: + return { + name: Ii, + properties: [ + { name: "calledByName", defaultValue: !1 }, + { name: "parameter" }, + { name: "value" } + ] + }; + case pn: + return { + name: pn, + properties: [ + { name: "value" } + ] + }; + case cr: + return { + name: cr, + properties: [ + { name: "value" } + ] + }; + case ur: + return { + name: ur, + properties: [ + { name: "name" } + ] + }; + case mn: + return { + name: mn, + properties: [ + { name: "parameter" } + ] + }; + case gn: + return { + name: gn, + properties: [ + { name: "dataType" }, + { name: "definesHiddenTokens", defaultValue: !1 }, + { name: "definition" }, + { name: "entry", defaultValue: !1 }, + { name: "fragment", defaultValue: !1 }, + { name: "hiddenTokens", defaultValue: [] }, + { name: "inferredType" }, + { name: "name" }, + { name: "parameters", defaultValue: [] }, + { name: "returnType" }, + { name: "wildcard", defaultValue: !1 } + ] + }; + case dr: + return { + name: dr, + properties: [ + { name: "referenceType" } + ] + }; + case kr: + return { + name: kr, + properties: [ + { name: "name" } + ] + }; + case yn: + return { + name: yn, + properties: [ + { name: "primitiveType" }, + { name: "stringType" }, + { name: "typeRef" } + ] + }; + case fr: + return { + name: fr, + properties: [ + { name: "value" } + ] + }; + case $t: + return { + name: $t, + properties: [ + { name: "definition" }, + { name: "fragment", defaultValue: !1 }, + { name: "hidden", defaultValue: !1 }, + { name: "name" }, + { name: "type" } + ] + }; + case Tn: + return { + name: Tn, + properties: [ + { name: "name" }, + { name: "type" } + ] + }; + case Ni: + return { + name: Ni, + properties: [ + { name: "defaultValue" }, + { name: "isOptional", defaultValue: !1 }, + { name: "name" }, + { name: "type" } + ] + }; + case hr: + return { + name: hr, + properties: [ + { name: "types", defaultValue: [] } + ] + }; + case Rn: + return { + name: Rn, + properties: [ + { name: "cardinality" }, + { name: "feature" }, + { name: "inferredType" }, + { name: "lookahead" }, + { name: "operator" }, + { name: "type" } + ] + }; + case vn: + return { + name: vn, + properties: [ + { name: "cardinality" }, + { name: "elements", defaultValue: [] }, + { name: "lookahead" } + ] + }; + case An: + return { + name: An, + properties: [ + { name: "cardinality" }, + { name: "feature" }, + { name: "lookahead" }, + { name: "operator" }, + { name: "terminal" } + ] + }; + case En: + return { + name: En, + properties: [ + { name: "cardinality" }, + { name: "left" }, + { name: "lookahead" }, + { name: "right" } + ] + }; + case kn: + return { + name: kn, + properties: [ + { name: "cardinality" }, + { name: "deprecatedSyntax", defaultValue: !1 }, + { name: "lookahead" }, + { name: "terminal" }, + { name: "type" } + ] + }; + case xn: + return { + name: xn, + properties: [ + { name: "cardinality" }, + { name: "lookahead" } + ] + }; + case $n: + return { + name: $n, + properties: [ + { name: "cardinality" }, + { name: "elements", defaultValue: [] }, + { name: "guardCondition" }, + { name: "lookahead" } + ] + }; + case Sn: + return { + name: Sn, + properties: [ + { name: "cardinality" }, + { name: "lookahead" }, + { name: "value" } + ] + }; + case In: + return { + name: In, + properties: [ + { name: "cardinality" }, + { name: "lookahead" }, + { name: "terminal" } + ] + }; + case Nn: + return { + name: Nn, + properties: [ + { name: "cardinality" }, + { name: "lookahead" }, + { name: "regex" } + ] + }; + case Cn: + return { + name: Cn, + properties: [ + { name: "arguments", defaultValue: [] }, + { name: "cardinality" }, + { name: "lookahead" }, + { name: "rule" } + ] + }; + case wn: + return { + name: wn, + properties: [ + { name: "cardinality" }, + { name: "elements", defaultValue: [] }, + { name: "lookahead" } + ] + }; + case _n: + return { + name: _n, + properties: [ + { name: "cardinality" }, + { name: "elements", defaultValue: [] }, + { name: "lookahead" } + ] + }; + case Ln: + return { + name: Ln, + properties: [ + { name: "cardinality" }, + { name: "lookahead" }, + { name: "rule" } + ] + }; + case On: + return { + name: On, + properties: [ + { name: "cardinality" }, + { name: "elements", defaultValue: [] }, + { name: "lookahead" } + ] + }; + case bn: + return { + name: bn, + properties: [ + { name: "cardinality" }, + { name: "lookahead" }, + { name: "terminal" } + ] + }; + case Pn: + return { + name: Pn, + properties: [ + { name: "cardinality" }, + { name: "lookahead" } + ] + }; + default: + return { + name: e, + properties: [] + }; + } + } +} +const M = new Ml(); +function bd(n) { + for (const [e, t] of Object.entries(n)) + e.startsWith("$") || (Array.isArray(t) ? t.forEach((r, i) => { + ae(r) && (r.$container = n, r.$containerProperty = e, r.$containerIndex = i); + }) : ae(t) && (t.$container = n, t.$containerProperty = e)); +} +function ci(n, e) { + let t = n; + for (; t; ) { + if (e(t)) + return t; + t = t.$container; + } +} +function et(n) { + const t = Zi(n).$document; + if (!t) + throw new Error("AST node has no document."); + return t; +} +function Zi(n) { + for (; n.$container; ) + n = n.$container; + return n; +} +function Vs(n, e) { + if (!n) + throw new Error("Node must be an AstNode."); + const t = e == null ? void 0 : e.range; + return new Q(() => ({ + keys: Object.keys(n), + keyIndex: 0, + arrayIndex: 0 + }), (r) => { + for (; r.keyIndex < r.keys.length; ) { + const i = r.keys[r.keyIndex]; + if (!i.startsWith("$")) { + const s = n[i]; + if (ae(s)) { + if (r.keyIndex++, va(s, t)) + return { done: !1, value: s }; + } else if (Array.isArray(s)) { + for (; r.arrayIndex < s.length; ) { + const a = r.arrayIndex++, o = s[a]; + if (ae(o) && va(o, t)) + return { done: !1, value: o }; + } + r.arrayIndex = 0; + } + } + r.keyIndex++; + } + return ve; + }); +} +function Qn(n, e) { + if (!n) + throw new Error("Root node must be an AstNode."); + return new Gs(n, (t) => Vs(t, e)); +} +function It(n, e) { + if (!n) + throw new Error("Root node must be an AstNode."); + return new Gs(n, (t) => Vs(t, e), { includeRoot: !0 }); +} +function va(n, e) { + var t; + if (!e) + return !0; + const r = (t = n.$cstNode) === null || t === void 0 ? void 0 : t.range; + return r ? hd(r, e) : !1; +} +function Dl(n) { + return new Q(() => ({ + keys: Object.keys(n), + keyIndex: 0, + arrayIndex: 0 + }), (e) => { + for (; e.keyIndex < e.keys.length; ) { + const t = e.keys[e.keyIndex]; + if (!t.startsWith("$")) { + const r = n[t]; + if (Ge(r)) + return e.keyIndex++, { done: !1, value: { reference: r, container: n, property: t } }; + if (Array.isArray(r)) { + for (; e.arrayIndex < r.length; ) { + const i = e.arrayIndex++, s = r[i]; + if (Ge(s)) + return { done: !1, value: { reference: s, container: n, property: t, index: i } }; + } + e.arrayIndex = 0; + } + } + e.keyIndex++; + } + return ve; + }); +} +function Pd(n, e) { + const t = n.getTypeMetaData(e.$type), r = e; + for (const i of t.properties) + i.defaultValue !== void 0 && r[i.name] === void 0 && (r[i.name] = Fl(i.defaultValue)); +} +function Fl(n) { + return Array.isArray(n) ? [...n.map(Fl)] : n; +} +function w(n) { + return n.charCodeAt(0); +} +function Ci(n, e) { + Array.isArray(n) ? n.forEach(function(t) { + e.push(t); + }) : e.push(n); +} +function sn(n, e) { + if (n[e] === !0) + throw "duplicate flag " + e; + n[e], n[e] = !0; +} +function xt(n) { + if (n === void 0) + throw Error("Internal Error - Should never get here!"); + return !0; +} +function Md() { + throw Error("Internal Error - Should never get here!"); +} +function Aa(n) { + return n.type === "Character"; +} +const Fr = []; +for (let n = w("0"); n <= w("9"); n++) + Fr.push(n); +const Gr = [w("_")].concat(Fr); +for (let n = w("a"); n <= w("z"); n++) + Gr.push(n); +for (let n = w("A"); n <= w("Z"); n++) + Gr.push(n); +const Ea = [ + w(" "), + w("\f"), + w(` +`), + w("\r"), + w(" "), + w("\v"), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w(" "), + w("\u2028"), + w("\u2029"), + w(" "), + w(" "), + w("　"), + w("\uFEFF") +], Dd = /[0-9a-fA-F]/, pr = /[0-9]/, Fd = /[1-9]/; +class Gl { + constructor() { + this.idx = 0, this.input = "", this.groupIdx = 0; + } + saveState() { + return { + idx: this.idx, + input: this.input, + groupIdx: this.groupIdx + }; + } + restoreState(e) { + this.idx = e.idx, this.input = e.input, this.groupIdx = e.groupIdx; + } + pattern(e) { + this.idx = 0, this.input = e, this.groupIdx = 0, this.consumeChar("/"); + const t = this.disjunction(); + this.consumeChar("/"); + const r = { + type: "Flags", + loc: { begin: this.idx, end: e.length }, + global: !1, + ignoreCase: !1, + multiLine: !1, + unicode: !1, + sticky: !1 + }; + for (; this.isRegExpFlag(); ) + switch (this.popChar()) { + case "g": + sn(r, "global"); + break; + case "i": + sn(r, "ignoreCase"); + break; + case "m": + sn(r, "multiLine"); + break; + case "u": + sn(r, "unicode"); + break; + case "y": + sn(r, "sticky"); + break; + } + if (this.idx !== this.input.length) + throw Error("Redundant input: " + this.input.substring(this.idx)); + return { + type: "Pattern", + flags: r, + value: t, + loc: this.loc(0) + }; + } + disjunction() { + const e = [], t = this.idx; + for (e.push(this.alternative()); this.peekChar() === "|"; ) + this.consumeChar("|"), e.push(this.alternative()); + return { type: "Disjunction", value: e, loc: this.loc(t) }; + } + alternative() { + const e = [], t = this.idx; + for (; this.isTerm(); ) + e.push(this.term()); + return { type: "Alternative", value: e, loc: this.loc(t) }; + } + term() { + return this.isAssertion() ? this.assertion() : this.atom(); + } + assertion() { + const e = this.idx; + switch (this.popChar()) { + case "^": + return { + type: "StartAnchor", + loc: this.loc(e) + }; + case "$": + return { type: "EndAnchor", loc: this.loc(e) }; + case "\\": + switch (this.popChar()) { + case "b": + return { + type: "WordBoundary", + loc: this.loc(e) + }; + case "B": + return { + type: "NonWordBoundary", + loc: this.loc(e) + }; + } + throw Error("Invalid Assertion Escape"); + case "(": + this.consumeChar("?"); + let t; + switch (this.popChar()) { + case "=": + t = "Lookahead"; + break; + case "!": + t = "NegativeLookahead"; + break; + } + xt(t); + const r = this.disjunction(); + return this.consumeChar(")"), { + type: t, + value: r, + loc: this.loc(e) + }; + } + return Md(); + } + quantifier(e = !1) { + let t; + const r = this.idx; + switch (this.popChar()) { + case "*": + t = { + atLeast: 0, + atMost: 1 / 0 + }; + break; + case "+": + t = { + atLeast: 1, + atMost: 1 / 0 + }; + break; + case "?": + t = { + atLeast: 0, + atMost: 1 + }; + break; + case "{": + const i = this.integerIncludingZero(); + switch (this.popChar()) { + case "}": + t = { + atLeast: i, + atMost: i + }; + break; + case ",": + let s; + this.isDigit() ? (s = this.integerIncludingZero(), t = { + atLeast: i, + atMost: s + }) : t = { + atLeast: i, + atMost: 1 / 0 + }, this.consumeChar("}"); + break; + } + if (e === !0 && t === void 0) + return; + xt(t); + break; + } + if (!(e === !0 && t === void 0) && xt(t)) + return this.peekChar(0) === "?" ? (this.consumeChar("?"), t.greedy = !1) : t.greedy = !0, t.type = "Quantifier", t.loc = this.loc(r), t; + } + atom() { + let e; + const t = this.idx; + switch (this.peekChar()) { + case ".": + e = this.dotAll(); + break; + case "\\": + e = this.atomEscape(); + break; + case "[": + e = this.characterClass(); + break; + case "(": + e = this.group(); + break; + } + if (e === void 0 && this.isPatternCharacter() && (e = this.patternCharacter()), xt(e)) + return e.loc = this.loc(t), this.isQuantifier() && (e.quantifier = this.quantifier()), e; + } + dotAll() { + return this.consumeChar("."), { + type: "Set", + complement: !0, + value: [w(` +`), w("\r"), w("\u2028"), w("\u2029")] + }; + } + atomEscape() { + switch (this.consumeChar("\\"), this.peekChar()) { + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + return this.decimalEscapeAtom(); + case "d": + case "D": + case "s": + case "S": + case "w": + case "W": + return this.characterClassEscape(); + case "f": + case "n": + case "r": + case "t": + case "v": + return this.controlEscapeAtom(); + case "c": + return this.controlLetterEscapeAtom(); + case "0": + return this.nulCharacterAtom(); + case "x": + return this.hexEscapeSequenceAtom(); + case "u": + return this.regExpUnicodeEscapeSequenceAtom(); + default: + return this.identityEscapeAtom(); + } + } + decimalEscapeAtom() { + return { type: "GroupBackReference", value: this.positiveInteger() }; + } + characterClassEscape() { + let e, t = !1; + switch (this.popChar()) { + case "d": + e = Fr; + break; + case "D": + e = Fr, t = !0; + break; + case "s": + e = Ea; + break; + case "S": + e = Ea, t = !0; + break; + case "w": + e = Gr; + break; + case "W": + e = Gr, t = !0; + break; + } + if (xt(e)) + return { type: "Set", value: e, complement: t }; + } + controlEscapeAtom() { + let e; + switch (this.popChar()) { + case "f": + e = w("\f"); + break; + case "n": + e = w(` +`); + break; + case "r": + e = w("\r"); + break; + case "t": + e = w(" "); + break; + case "v": + e = w("\v"); + break; + } + if (xt(e)) + return { type: "Character", value: e }; + } + controlLetterEscapeAtom() { + this.consumeChar("c"); + const e = this.popChar(); + if (/[a-zA-Z]/.test(e) === !1) + throw Error("Invalid "); + return { type: "Character", value: e.toUpperCase().charCodeAt(0) - 64 }; + } + nulCharacterAtom() { + return this.consumeChar("0"), { type: "Character", value: w("\0") }; + } + hexEscapeSequenceAtom() { + return this.consumeChar("x"), this.parseHexDigits(2); + } + regExpUnicodeEscapeSequenceAtom() { + return this.consumeChar("u"), this.parseHexDigits(4); + } + identityEscapeAtom() { + const e = this.popChar(); + return { type: "Character", value: w(e) }; + } + classPatternCharacterAtom() { + switch (this.peekChar()) { + case ` +`: + case "\r": + case "\u2028": + case "\u2029": + case "\\": + case "]": + throw Error("TBD"); + default: + const e = this.popChar(); + return { type: "Character", value: w(e) }; + } + } + characterClass() { + const e = []; + let t = !1; + for (this.consumeChar("["), this.peekChar(0) === "^" && (this.consumeChar("^"), t = !0); this.isClassAtom(); ) { + const r = this.classAtom(); + if (r.type, Aa(r) && this.isRangeDash()) { + this.consumeChar("-"); + const i = this.classAtom(); + if (i.type, Aa(i)) { + if (i.value < r.value) + throw Error("Range out of order in character class"); + e.push({ from: r.value, to: i.value }); + } else + Ci(r.value, e), e.push(w("-")), Ci(i.value, e); + } else + Ci(r.value, e); + } + return this.consumeChar("]"), { type: "Set", complement: t, value: e }; + } + classAtom() { + switch (this.peekChar()) { + case "]": + case ` +`: + case "\r": + case "\u2028": + case "\u2029": + throw Error("TBD"); + case "\\": + return this.classEscape(); + default: + return this.classPatternCharacterAtom(); + } + } + classEscape() { + switch (this.consumeChar("\\"), this.peekChar()) { + case "b": + return this.consumeChar("b"), { type: "Character", value: w("\b") }; + case "d": + case "D": + case "s": + case "S": + case "w": + case "W": + return this.characterClassEscape(); + case "f": + case "n": + case "r": + case "t": + case "v": + return this.controlEscapeAtom(); + case "c": + return this.controlLetterEscapeAtom(); + case "0": + return this.nulCharacterAtom(); + case "x": + return this.hexEscapeSequenceAtom(); + case "u": + return this.regExpUnicodeEscapeSequenceAtom(); + default: + return this.identityEscapeAtom(); + } + } + group() { + let e = !0; + switch (this.consumeChar("("), this.peekChar(0)) { + case "?": + this.consumeChar("?"), this.consumeChar(":"), e = !1; + break; + default: + this.groupIdx++; + break; + } + const t = this.disjunction(); + this.consumeChar(")"); + const r = { + type: "Group", + capturing: e, + value: t + }; + return e && (r.idx = this.groupIdx), r; + } + positiveInteger() { + let e = this.popChar(); + if (Fd.test(e) === !1) + throw Error("Expecting a positive integer"); + for (; pr.test(this.peekChar(0)); ) + e += this.popChar(); + return parseInt(e, 10); + } + integerIncludingZero() { + let e = this.popChar(); + if (pr.test(e) === !1) + throw Error("Expecting an integer"); + for (; pr.test(this.peekChar(0)); ) + e += this.popChar(); + return parseInt(e, 10); + } + patternCharacter() { + const e = this.popChar(); + switch (e) { + case ` +`: + case "\r": + case "\u2028": + case "\u2029": + case "^": + case "$": + case "\\": + case ".": + case "*": + case "+": + case "?": + case "(": + case ")": + case "[": + case "|": + throw Error("TBD"); + default: + return { type: "Character", value: w(e) }; + } + } + isRegExpFlag() { + switch (this.peekChar(0)) { + case "g": + case "i": + case "m": + case "u": + case "y": + return !0; + default: + return !1; + } + } + isRangeDash() { + return this.peekChar() === "-" && this.isClassAtom(1); + } + isDigit() { + return pr.test(this.peekChar(0)); + } + isClassAtom(e = 0) { + switch (this.peekChar(e)) { + case "]": + case ` +`: + case "\r": + case "\u2028": + case "\u2029": + return !1; + default: + return !0; + } + } + isTerm() { + return this.isAtom() || this.isAssertion(); + } + isAtom() { + if (this.isPatternCharacter()) + return !0; + switch (this.peekChar(0)) { + case ".": + case "\\": + case "[": + case "(": + return !0; + default: + return !1; + } + } + isAssertion() { + switch (this.peekChar(0)) { + case "^": + case "$": + return !0; + case "\\": + switch (this.peekChar(1)) { + case "b": + case "B": + return !0; + default: + return !1; + } + case "(": + return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!"); + default: + return !1; + } + } + isQuantifier() { + const e = this.saveState(); + try { + return this.quantifier(!0) !== void 0; + } catch { + return !1; + } finally { + this.restoreState(e); + } + } + isPatternCharacter() { + switch (this.peekChar()) { + case "^": + case "$": + case "\\": + case ".": + case "*": + case "+": + case "?": + case "(": + case ")": + case "[": + case "|": + case "/": + case ` +`: + case "\r": + case "\u2028": + case "\u2029": + return !1; + default: + return !0; + } + } + parseHexDigits(e) { + let t = ""; + for (let i = 0; i < e; i++) { + const s = this.popChar(); + if (Dd.test(s) === !1) + throw Error("Expecting a HexDecimal digits"); + t += s; + } + return { type: "Character", value: parseInt(t, 16) }; + } + peekChar(e = 0) { + return this.input[this.idx + e]; + } + popChar() { + const e = this.peekChar(0); + return this.consumeChar(void 0), e; + } + consumeChar(e) { + if (e !== void 0 && this.input[this.idx] !== e) + throw Error("Expected: '" + e + "' but found: '" + this.input[this.idx] + "' at offset: " + this.idx); + if (this.idx >= this.input.length) + throw Error("Unexpected end of input"); + this.idx++; + } + loc(e) { + return { begin: e, end: this.idx }; + } +} +class ui { + visitChildren(e) { + for (const t in e) { + const r = e[t]; + e.hasOwnProperty(t) && (r.type !== void 0 ? this.visit(r) : Array.isArray(r) && r.forEach((i) => { + this.visit(i); + }, this)); + } + } + visit(e) { + switch (e.type) { + case "Pattern": + this.visitPattern(e); + break; + case "Flags": + this.visitFlags(e); + break; + case "Disjunction": + this.visitDisjunction(e); + break; + case "Alternative": + this.visitAlternative(e); + break; + case "StartAnchor": + this.visitStartAnchor(e); + break; + case "EndAnchor": + this.visitEndAnchor(e); + break; + case "WordBoundary": + this.visitWordBoundary(e); + break; + case "NonWordBoundary": + this.visitNonWordBoundary(e); + break; + case "Lookahead": + this.visitLookahead(e); + break; + case "NegativeLookahead": + this.visitNegativeLookahead(e); + break; + case "Character": + this.visitCharacter(e); + break; + case "Set": + this.visitSet(e); + break; + case "Group": + this.visitGroup(e); + break; + case "GroupBackReference": + this.visitGroupBackReference(e); + break; + case "Quantifier": + this.visitQuantifier(e); + break; + } + this.visitChildren(e); + } + visitPattern(e) { + } + visitFlags(e) { + } + visitDisjunction(e) { + } + visitAlternative(e) { + } + // Assertion + visitStartAnchor(e) { + } + visitEndAnchor(e) { + } + visitWordBoundary(e) { + } + visitNonWordBoundary(e) { + } + visitLookahead(e) { + } + visitNegativeLookahead(e) { + } + // atoms + visitCharacter(e) { + } + visitSet(e) { + } + visitGroup(e) { + } + visitGroupBackReference(e) { + } + visitQuantifier(e) { + } +} +const Gd = /\r?\n/gm, Ud = new Gl(); +class Bd extends ui { + constructor() { + super(...arguments), this.isStarting = !0, this.endRegexpStack = [], this.multiline = !1; + } + get endRegex() { + return this.endRegexpStack.join(""); + } + reset(e) { + this.multiline = !1, this.regex = e, this.startRegexp = "", this.isStarting = !0, this.endRegexpStack = []; + } + visitGroup(e) { + e.quantifier && (this.isStarting = !1, this.endRegexpStack = []); + } + visitCharacter(e) { + const t = String.fromCharCode(e.value); + if (!this.multiline && t === ` +` && (this.multiline = !0), e.quantifier) + this.isStarting = !1, this.endRegexpStack = []; + else { + const r = di(t); + this.endRegexpStack.push(r), this.isStarting && (this.startRegexp += r); + } + } + visitSet(e) { + if (!this.multiline) { + const t = this.regex.substring(e.loc.begin, e.loc.end), r = new RegExp(t); + this.multiline = !!` +`.match(r); + } + if (e.quantifier) + this.isStarting = !1, this.endRegexpStack = []; + else { + const t = this.regex.substring(e.loc.begin, e.loc.end); + this.endRegexpStack.push(t), this.isStarting && (this.startRegexp += t); + } + } + visitChildren(e) { + e.type === "Group" && e.quantifier || super.visitChildren(e); + } +} +const wi = new Bd(); +function Vd(n) { + try { + return typeof n == "string" && (n = new RegExp(n)), n = n.toString(), wi.reset(n), wi.visit(Ud.pattern(n)), wi.multiline; + } catch { + return !1; + } +} +const Kd = `\f +\r \v              \u2028\u2029  　\uFEFF`.split(""); +function es(n) { + const e = typeof n == "string" ? new RegExp(n) : n; + return Kd.some((t) => e.test(t)); +} +function di(n) { + return n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function Wd(n) { + return Array.prototype.map.call(n, (e) => /\w/.test(e) ? `[${e.toLowerCase()}${e.toUpperCase()}]` : di(e)).join(""); +} +function jd(n, e) { + const t = Hd(n), r = e.match(t); + return !!r && r[0].length > 0; +} +function Hd(n) { + typeof n == "string" && (n = new RegExp(n)); + const e = n, t = n.source; + let r = 0; + function i() { + let s = "", a; + function o(c) { + s += t.substr(r, c), r += c; + } + function l(c) { + s += "(?:" + t.substr(r, c) + "|$)", r += c; + } + for (; r < t.length; ) + switch (t[r]) { + case "\\": + switch (t[r + 1]) { + case "c": + l(3); + break; + case "x": + l(4); + break; + case "u": + e.unicode ? t[r + 2] === "{" ? l(t.indexOf("}", r) - r + 1) : l(6) : l(2); + break; + case "p": + case "P": + e.unicode ? l(t.indexOf("}", r) - r + 1) : l(2); + break; + case "k": + l(t.indexOf(">", r) - r + 1); + break; + default: + l(2); + break; + } + break; + case "[": + a = /\[(?:\\.|.)*?\]/g, a.lastIndex = r, a = a.exec(t) || [], l(a[0].length); + break; + case "|": + case "^": + case "$": + case "*": + case "+": + case "?": + o(1); + break; + case "{": + a = /\{\d+,?\d*\}/g, a.lastIndex = r, a = a.exec(t), a ? o(a[0].length) : l(1); + break; + case "(": + if (t[r + 1] === "?") + switch (t[r + 2]) { + case ":": + s += "(?:", r += 3, s += i() + "|$)"; + break; + case "=": + s += "(?=", r += 3, s += i() + ")"; + break; + case "!": + a = r, r += 3, i(), s += t.substr(a, r - a); + break; + case "<": + switch (t[r + 3]) { + case "=": + case "!": + a = r, r += 4, i(), s += t.substr(a, r - a); + break; + default: + o(t.indexOf(">", r) - r + 1), s += i() + "|$)"; + break; + } + break; + } + else + o(1), s += i() + "|$)"; + break; + case ")": + return ++r, s; + default: + l(1); + break; + } + return s; + } + return new RegExp(i(), n.flags); +} +function zd(n) { + return n.rules.find((e) => we(e) && e.entry); +} +function qd(n) { + return n.rules.filter((e) => yt(e) && e.hidden); +} +function Ul(n, e) { + const t = /* @__PURE__ */ new Set(), r = zd(n); + if (!r) + return new Set(n.rules); + const i = [r].concat(qd(n)); + for (const a of i) + Bl(a, t, e); + const s = /* @__PURE__ */ new Set(); + for (const a of n.rules) + (t.has(a.name) || yt(a) && a.hidden) && s.add(a); + return s; +} +function Bl(n, e, t) { + e.add(n.name), Qn(n).forEach((r) => { + if (ft(r) || t) { + const i = r.rule.ref; + i && !e.has(i.name) && Bl(i, e, t); + } + }); +} +function Yd(n) { + if (n.terminal) + return n.terminal; + if (n.type.ref) { + const e = Kl(n.type.ref); + return e == null ? void 0 : e.terminal; + } +} +function Xd(n) { + return n.hidden && !es(Hs(n)); +} +function Jd(n, e) { + return !n || !e ? [] : Ks(n, e, n.astNode, !0); +} +function Vl(n, e, t) { + if (!n || !e) + return; + const r = Ks(n, e, n.astNode, !0); + if (r.length !== 0) + return t !== void 0 ? t = Math.max(0, Math.min(t, r.length - 1)) : t = 0, r[t]; +} +function Ks(n, e, t, r) { + if (!r) { + const i = ci(n.grammarSource, ut); + if (i && i.feature === e) + return [n]; + } + return Hn(n) && n.astNode === t ? n.content.flatMap((i) => Ks(i, e, t, !1)) : []; +} +function Qd(n, e, t) { + if (!n) + return; + const r = Zd(n, e, n == null ? void 0 : n.astNode); + if (r.length !== 0) + return t !== void 0 ? t = Math.max(0, Math.min(t, r.length - 1)) : t = 0, r[t]; +} +function Zd(n, e, t) { + if (n.astNode !== t) + return []; + if (dt(n.grammarSource) && n.grammarSource.value === e) + return [n]; + const r = Ji(n).iterator(); + let i; + const s = []; + do + if (i = r.next(), !i.done) { + const a = i.value; + a.astNode === t ? dt(a.grammarSource) && a.grammarSource.value === e && s.push(a) : r.prune(); + } + while (!i.done); + return s; +} +function ef(n) { + var e; + const t = n.astNode; + for (; t === ((e = n.container) === null || e === void 0 ? void 0 : e.astNode); ) { + const r = ci(n.grammarSource, ut); + if (r) + return r; + n = n.container; + } +} +function Kl(n) { + let e = n; + return _l(e) && (li(e.$container) ? e = e.$container.$container : we(e.$container) ? e = e.$container : Jn(e.$container)), Wl(n, e, /* @__PURE__ */ new Map()); +} +function Wl(n, e, t) { + var r; + function i(s, a) { + let o; + return ci(s, ut) || (o = Wl(a, a, t)), t.set(n, o), o; + } + if (t.has(n)) + return t.get(n); + t.set(n, void 0); + for (const s of Qn(e)) { + if (ut(s) && s.feature.toLowerCase() === "name") + return t.set(n, s), s; + if (ft(s) && we(s.rule.ref)) + return i(s, s.rule.ref); + if (xd(s) && (!((r = s.typeRef) === null || r === void 0) && r.ref)) + return i(s, s.typeRef.ref); + } +} +function jl(n) { + return Hl(n, /* @__PURE__ */ new Set()); +} +function Hl(n, e) { + if (e.has(n)) + return !0; + e.add(n); + for (const t of Qn(n)) + if (ft(t)) { + if (!t.rule.ref || we(t.rule.ref) && !Hl(t.rule.ref, e)) + return !1; + } else { + if (ut(t)) + return !1; + if (li(t)) + return !1; + } + return !!n.definition; +} +function Ws(n) { + if (n.inferredType) + return n.inferredType.name; + if (n.dataType) + return n.dataType; + if (n.returnType) { + const e = n.returnType.ref; + if (e) { + if (we(e)) + return e.name; + if (Ll(e) || Ol(e)) + return e.name; + } + } +} +function js(n) { + var e; + if (we(n)) + return jl(n) ? n.name : (e = Ws(n)) !== null && e !== void 0 ? e : n.name; + if (Ll(n) || Ol(n) || kd(n)) + return n.name; + if (li(n)) { + const t = tf(n); + if (t) + return t; + } else if (_l(n)) + return n.name; + throw new Error("Cannot get name of Unknown Type"); +} +function tf(n) { + var e; + if (n.inferredType) + return n.inferredType.name; + if (!((e = n.type) === null || e === void 0) && e.ref) + return js(n.type.ref); +} +function nf(n) { + var e, t, r; + return yt(n) ? (t = (e = n.type) === null || e === void 0 ? void 0 : e.name) !== null && t !== void 0 ? t : "string" : (r = Ws(n)) !== null && r !== void 0 ? r : n.name; +} +function Hs(n) { + const e = { + s: !1, + i: !1, + u: !1 + }, t = Qt(n.definition, e), r = Object.entries(e).filter(([, i]) => i).map(([i]) => i).join(""); + return new RegExp(t, r); +} +const zs = /[\s\S]/.source; +function Qt(n, e) { + if (Cd(n)) + return rf(n); + if (wd(n)) + return sf(n); + if ($d(n)) + return lf(n); + if (_d(n)) { + const t = n.rule.ref; + if (!t) + throw new Error("Missing rule reference."); + return ze(Qt(t.definition), { + cardinality: n.cardinality, + lookahead: n.lookahead + }); + } else { + if (Id(n)) + return of(n); + if (Ld(n)) + return af(n); + if (Nd(n)) { + const t = n.regex.lastIndexOf("/"), r = n.regex.substring(1, t), i = n.regex.substring(t + 1); + return e && (e.i = i.includes("i"), e.s = i.includes("s"), e.u = i.includes("u")), ze(r, { + cardinality: n.cardinality, + lookahead: n.lookahead, + wrap: !1 + }); + } else { + if (Od(n)) + return ze(zs, { + cardinality: n.cardinality, + lookahead: n.lookahead + }); + throw new Error(`Invalid terminal element: ${n == null ? void 0 : n.$type}`); + } + } +} +function rf(n) { + return ze(n.elements.map((e) => Qt(e)).join("|"), { + cardinality: n.cardinality, + lookahead: n.lookahead + }); +} +function sf(n) { + return ze(n.elements.map((e) => Qt(e)).join(""), { + cardinality: n.cardinality, + lookahead: n.lookahead + }); +} +function af(n) { + return ze(`${zs}*?${Qt(n.terminal)}`, { + cardinality: n.cardinality, + lookahead: n.lookahead + }); +} +function of(n) { + return ze(`(?!${Qt(n.terminal)})${zs}*?`, { + cardinality: n.cardinality, + lookahead: n.lookahead + }); +} +function lf(n) { + return n.right ? ze(`[${_i(n.left)}-${_i(n.right)}]`, { + cardinality: n.cardinality, + lookahead: n.lookahead, + wrap: !1 + }) : ze(_i(n.left), { + cardinality: n.cardinality, + lookahead: n.lookahead, + wrap: !1 + }); +} +function _i(n) { + return di(n.value); +} +function ze(n, e) { + var t; + return (e.wrap !== !1 || e.lookahead) && (n = `(${(t = e.lookahead) !== null && t !== void 0 ? t : ""}${n})`), e.cardinality ? `${n}${e.cardinality}` : n; +} +function cf(n) { + const e = [], t = n.Grammar; + for (const r of t.rules) + yt(r) && Xd(r) && Vd(Hs(r)) && e.push(r.name); + return { + multilineCommentRules: e, + nameRegexp: pd + }; +} +function ts(n) { + console && console.error && console.error(`Error: ${n}`); +} +function zl(n) { + console && console.warn && console.warn(`Warning: ${n}`); +} +function ql(n) { + const e = (/* @__PURE__ */ new Date()).getTime(), t = n(); + return { time: (/* @__PURE__ */ new Date()).getTime() - e, value: t }; +} +function Yl(n) { + function e() { + } + e.prototype = n; + const t = new e(); + function r() { + return typeof t.bar; + } + return r(), r(), n; +} +function uf(n) { + return df(n) ? n.LABEL : n.name; +} +function df(n) { + return fe(n.LABEL) && n.LABEL !== ""; +} +class Ue { + get definition() { + return this._definition; + } + set definition(e) { + this._definition = e; + } + constructor(e) { + this._definition = e; + } + accept(e) { + e.visit(this), N(this.definition, (t) => { + t.accept(e); + }); + } +} +class le extends Ue { + constructor(e) { + super([]), this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } + set definition(e) { + } + get definition() { + return this.referencedRule !== void 0 ? this.referencedRule.definition : []; + } + accept(e) { + e.visit(this); + } +} +class Zt extends Ue { + constructor(e) { + super(e.definition), this.orgText = "", ke(this, Me(e, (t) => t !== void 0)); + } +} +class he extends Ue { + constructor(e) { + super(e.definition), this.ignoreAmbiguities = !1, ke(this, Me(e, (t) => t !== void 0)); + } +} +let te = class extends Ue { + constructor(e) { + super(e.definition), this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } +}; +class $e extends Ue { + constructor(e) { + super(e.definition), this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } +} +class Se extends Ue { + constructor(e) { + super(e.definition), this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } +} +class W extends Ue { + constructor(e) { + super(e.definition), this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } +} +class me extends Ue { + constructor(e) { + super(e.definition), this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } +} +class ge extends Ue { + get definition() { + return this._definition; + } + set definition(e) { + this._definition = e; + } + constructor(e) { + super(e.definition), this.idx = 1, this.ignoreAmbiguities = !1, this.hasPredicates = !1, ke(this, Me(e, (t) => t !== void 0)); + } +} +class G { + constructor(e) { + this.idx = 1, ke(this, Me(e, (t) => t !== void 0)); + } + accept(e) { + e.visit(this); + } +} +function ff(n) { + return $(n, xr); +} +function xr(n) { + function e(t) { + return $(t, xr); + } + if (n instanceof le) { + const t = { + type: "NonTerminal", + name: n.nonTerminalName, + idx: n.idx + }; + return fe(n.label) && (t.label = n.label), t; + } else { + if (n instanceof he) + return { + type: "Alternative", + definition: e(n.definition) + }; + if (n instanceof te) + return { + type: "Option", + idx: n.idx, + definition: e(n.definition) + }; + if (n instanceof $e) + return { + type: "RepetitionMandatory", + idx: n.idx, + definition: e(n.definition) + }; + if (n instanceof Se) + return { + type: "RepetitionMandatoryWithSeparator", + idx: n.idx, + separator: xr(new G({ terminalType: n.separator })), + definition: e(n.definition) + }; + if (n instanceof me) + return { + type: "RepetitionWithSeparator", + idx: n.idx, + separator: xr(new G({ terminalType: n.separator })), + definition: e(n.definition) + }; + if (n instanceof W) + return { + type: "Repetition", + idx: n.idx, + definition: e(n.definition) + }; + if (n instanceof ge) + return { + type: "Alternation", + idx: n.idx, + definition: e(n.definition) + }; + if (n instanceof G) { + const t = { + type: "Terminal", + name: n.terminalType.name, + label: uf(n.terminalType), + idx: n.idx + }; + fe(n.label) && (t.terminalLabel = n.label); + const r = n.terminalType.PATTERN; + return n.terminalType.PATTERN && (t.pattern = Ye(r) ? r.source : r), t; + } else { + if (n instanceof Zt) + return { + type: "Rule", + name: n.name, + orgText: n.orgText, + definition: e(n.definition) + }; + throw Error("non exhaustive match"); + } + } +} +class en { + visit(e) { + const t = e; + switch (t.constructor) { + case le: + return this.visitNonTerminal(t); + case he: + return this.visitAlternative(t); + case te: + return this.visitOption(t); + case $e: + return this.visitRepetitionMandatory(t); + case Se: + return this.visitRepetitionMandatoryWithSeparator(t); + case me: + return this.visitRepetitionWithSeparator(t); + case W: + return this.visitRepetition(t); + case ge: + return this.visitAlternation(t); + case G: + return this.visitTerminal(t); + case Zt: + return this.visitRule(t); + default: + throw Error("non exhaustive match"); + } + } + /* c8 ignore next */ + visitNonTerminal(e) { + } + /* c8 ignore next */ + visitAlternative(e) { + } + /* c8 ignore next */ + visitOption(e) { + } + /* c8 ignore next */ + visitRepetition(e) { + } + /* c8 ignore next */ + visitRepetitionMandatory(e) { + } + /* c8 ignore next 3 */ + visitRepetitionMandatoryWithSeparator(e) { + } + /* c8 ignore next */ + visitRepetitionWithSeparator(e) { + } + /* c8 ignore next */ + visitAlternation(e) { + } + /* c8 ignore next */ + visitTerminal(e) { + } + /* c8 ignore next */ + visitRule(e) { + } +} +function hf(n) { + return n instanceof he || n instanceof te || n instanceof W || n instanceof $e || n instanceof Se || n instanceof me || n instanceof G || n instanceof Zt; +} +function Ur(n, e = []) { + return n instanceof te || n instanceof W || n instanceof me ? !0 : n instanceof ge ? Sl(n.definition, (r) => Ur(r, e)) : n instanceof le && ue(e, n) ? !1 : n instanceof Ue ? (n instanceof le && e.push(n), be(n.definition, (r) => Ur(r, e))) : !1; +} +function pf(n) { + return n instanceof ge; +} +function Fe(n) { + if (n instanceof le) + return "SUBRULE"; + if (n instanceof te) + return "OPTION"; + if (n instanceof ge) + return "OR"; + if (n instanceof $e) + return "AT_LEAST_ONE"; + if (n instanceof Se) + return "AT_LEAST_ONE_SEP"; + if (n instanceof me) + return "MANY_SEP"; + if (n instanceof W) + return "MANY"; + if (n instanceof G) + return "CONSUME"; + throw Error("non exhaustive match"); +} +class fi { + walk(e, t = []) { + N(e.definition, (r, i) => { + const s = J(e.definition, i + 1); + if (r instanceof le) + this.walkProdRef(r, s, t); + else if (r instanceof G) + this.walkTerminal(r, s, t); + else if (r instanceof he) + this.walkFlat(r, s, t); + else if (r instanceof te) + this.walkOption(r, s, t); + else if (r instanceof $e) + this.walkAtLeastOne(r, s, t); + else if (r instanceof Se) + this.walkAtLeastOneSep(r, s, t); + else if (r instanceof me) + this.walkManySep(r, s, t); + else if (r instanceof W) + this.walkMany(r, s, t); + else if (r instanceof ge) + this.walkOr(r, s, t); + else + throw Error("non exhaustive match"); + }); + } + walkTerminal(e, t, r) { + } + walkProdRef(e, t, r) { + } + walkFlat(e, t, r) { + const i = t.concat(r); + this.walk(e, i); + } + walkOption(e, t, r) { + const i = t.concat(r); + this.walk(e, i); + } + walkAtLeastOne(e, t, r) { + const i = [ + new te({ definition: e.definition }) + ].concat(t, r); + this.walk(e, i); + } + walkAtLeastOneSep(e, t, r) { + const i = ka(e, t, r); + this.walk(e, i); + } + walkMany(e, t, r) { + const i = [ + new te({ definition: e.definition }) + ].concat(t, r); + this.walk(e, i); + } + walkManySep(e, t, r) { + const i = ka(e, t, r); + this.walk(e, i); + } + walkOr(e, t, r) { + const i = t.concat(r); + N(e.definition, (s) => { + const a = new he({ definition: [s] }); + this.walk(a, i); + }); + } +} +function ka(n, e, t) { + return [ + new te({ + definition: [ + new G({ terminalType: n.separator }) + ].concat(n.definition) + }) + ].concat(e, t); +} +function Zn(n) { + if (n instanceof le) + return Zn(n.referencedRule); + if (n instanceof G) + return yf(n); + if (hf(n)) + return mf(n); + if (pf(n)) + return gf(n); + throw Error("non exhaustive match"); +} +function mf(n) { + let e = []; + const t = n.definition; + let r = 0, i = t.length > r, s, a = !0; + for (; i && a; ) + s = t[r], a = Ur(s), e = e.concat(Zn(s)), r = r + 1, i = t.length > r; + return Fs(e); +} +function gf(n) { + const e = $(n.definition, (t) => Zn(t)); + return Fs(Ce(e)); +} +function yf(n) { + return [n.terminalType]; +} +const Xl = "_~IN~_"; +class Tf extends fi { + constructor(e) { + super(), this.topProd = e, this.follows = {}; + } + startWalking() { + return this.walk(this.topProd), this.follows; + } + walkTerminal(e, t, r) { + } + walkProdRef(e, t, r) { + const i = vf(e.referencedRule, e.idx) + this.topProd.name, s = t.concat(r), a = new he({ definition: s }), o = Zn(a); + this.follows[i] = o; + } +} +function Rf(n) { + const e = {}; + return N(n, (t) => { + const r = new Tf(t).startWalking(); + ke(e, r); + }), e; +} +function vf(n, e) { + return n.name + e + Xl; +} +let $r = {}; +const Af = new Gl(); +function hi(n) { + const e = n.toString(); + if ($r.hasOwnProperty(e)) + return $r[e]; + { + const t = Af.pattern(e); + return $r[e] = t, t; + } +} +function Ef() { + $r = {}; +} +const Jl = "Complement Sets are not supported for first char optimization", Br = `Unable to use "first char" lexer optimizations: +`; +function kf(n, e = !1) { + try { + const t = hi(n); + return ns(t.value, {}, t.flags.ignoreCase); + } catch (t) { + if (t.message === Jl) + e && zl(`${Br} Unable to optimize: < ${n.toString()} > + Complement Sets cannot be automatically optimized. + This will disable the lexer's first char optimizations. + See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`); + else { + let r = ""; + e && (r = ` + This will disable the lexer's first char optimizations. + See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.`), ts(`${Br} + Failed parsing: < ${n.toString()} > + Using the @chevrotain/regexp-to-ast library + Please open an issue at: https://github.com/chevrotain/chevrotain/issues` + r); + } + } + return []; +} +function ns(n, e, t) { + switch (n.type) { + case "Disjunction": + for (let i = 0; i < n.value.length; i++) + ns(n.value[i], e, t); + break; + case "Alternative": + const r = n.value; + for (let i = 0; i < r.length; i++) { + const s = r[i]; + switch (s.type) { + case "EndAnchor": + case "GroupBackReference": + case "Lookahead": + case "NegativeLookahead": + case "StartAnchor": + case "WordBoundary": + case "NonWordBoundary": + continue; + } + const a = s; + switch (a.type) { + case "Character": + mr(a.value, e, t); + break; + case "Set": + if (a.complement === !0) + throw Error(Jl); + N(a.value, (l) => { + if (typeof l == "number") + mr(l, e, t); + else { + const c = l; + if (t === !0) + for (let u = c.from; u <= c.to; u++) + mr(u, e, t); + else { + for (let u = c.from; u <= c.to && u < Dn; u++) + mr(u, e, t); + if (c.to >= Dn) { + const u = c.from >= Dn ? c.from : Dn, d = c.to, h = tt(u), f = tt(d); + for (let m = h; m <= f; m++) + e[m] = m; + } + } + } + }); + break; + case "Group": + ns(a.value, e, t); + break; + default: + throw Error("Non Exhaustive Match"); + } + const o = a.quantifier !== void 0 && a.quantifier.atLeast === 0; + if ( + // A group may be optional due to empty contents /(?:)/ + // or if everything inside it is optional /((a)?)/ + a.type === "Group" && rs(a) === !1 || // If this term is not a group it may only be optional if it has an optional quantifier + a.type !== "Group" && o === !1 + ) + break; + } + break; + default: + throw Error("non exhaustive match!"); + } + return z(e); +} +function mr(n, e, t) { + const r = tt(n); + e[r] = r, t === !0 && xf(n, e); +} +function xf(n, e) { + const t = String.fromCharCode(n), r = t.toUpperCase(); + if (r !== t) { + const i = tt(r.charCodeAt(0)); + e[i] = i; + } else { + const i = t.toLowerCase(); + if (i !== t) { + const s = tt(i.charCodeAt(0)); + e[s] = s; + } + } +} +function xa(n, e) { + return Wt(n.value, (t) => { + if (typeof t == "number") + return ue(e, t); + { + const r = t; + return Wt(e, (i) => r.from <= i && i <= r.to) !== void 0; + } + }); +} +function rs(n) { + const e = n.quantifier; + return e && e.atLeast === 0 ? !0 : n.value ? ee(n.value) ? be(n.value, rs) : rs(n.value) : !1; +} +class $f extends ui { + constructor(e) { + super(), this.targetCharCodes = e, this.found = !1; + } + visitChildren(e) { + if (this.found !== !0) { + switch (e.type) { + case "Lookahead": + this.visitLookahead(e); + return; + case "NegativeLookahead": + this.visitNegativeLookahead(e); + return; + } + super.visitChildren(e); + } + } + visitCharacter(e) { + ue(this.targetCharCodes, e.value) && (this.found = !0); + } + visitSet(e) { + e.complement ? xa(e, this.targetCharCodes) === void 0 && (this.found = !0) : xa(e, this.targetCharCodes) !== void 0 && (this.found = !0); + } +} +function qs(n, e) { + if (e instanceof RegExp) { + const t = hi(e), r = new $f(n); + return r.visit(t), r.found; + } else + return Wt(e, (t) => ue(n, t.charCodeAt(0))) !== void 0; +} +const ht = "PATTERN", Mn = "defaultMode", gr = "modes"; +let Ql = typeof new RegExp("(?:)").sticky == "boolean"; +function Sf(n, e) { + e = Ds(e, { + useSticky: Ql, + debug: !1, + safeMode: !1, + positionTracking: "full", + lineTerminatorCharacters: ["\r", ` +`], + tracer: (A, R) => R() + }); + const t = e.tracer; + t("initCharCodeToOptimizedIndexMap", () => { + Yf(); + }); + let r; + t("Reject Lexer.NA", () => { + r = oi(n, (A) => A[ht] === de.NA); + }); + let i = !1, s; + t("Transform Patterns", () => { + i = !1, s = $(r, (A) => { + const R = A[ht]; + if (Ye(R)) { + const I = R.source; + return I.length === 1 && // only these regExp meta characters which can appear in a length one regExp + I !== "^" && I !== "$" && I !== "." && !R.ignoreCase ? I : I.length === 2 && I[0] === "\\" && // not a meta character + !ue([ + "d", + "D", + "s", + "S", + "t", + "r", + "n", + "t", + "0", + "c", + "b", + "B", + "f", + "v", + "w", + "W" + ], I[1]) ? I[1] : e.useSticky ? Sa(R) : $a(R); + } else { + if (gt(R)) + return i = !0, { exec: R }; + if (typeof R == "object") + return i = !0, R; + if (typeof R == "string") { + if (R.length === 1) + return R; + { + const I = R.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&"), F = new RegExp(I); + return e.useSticky ? Sa(F) : $a(F); + } + } else + throw Error("non exhaustive match"); + } + }); + }); + let a, o, l, c, u; + t("misc mapping", () => { + a = $(r, (A) => A.tokenTypeIdx), o = $(r, (A) => { + const R = A.GROUP; + if (R !== de.SKIPPED) { + if (fe(R)) + return R; + if (qe(R)) + return !1; + throw Error("non exhaustive match"); + } + }), l = $(r, (A) => { + const R = A.LONGER_ALT; + if (R) + return ee(R) ? $(R, (F) => ga(r, F)) : [ga(r, R)]; + }), c = $(r, (A) => A.PUSH_MODE), u = $(r, (A) => C(A, "POP_MODE")); + }); + let d; + t("Line Terminator Handling", () => { + const A = tc(e.lineTerminatorCharacters); + d = $(r, (R) => !1), e.positionTracking !== "onlyOffset" && (d = $(r, (R) => C(R, "LINE_BREAKS") ? !!R.LINE_BREAKS : ec(R, A) === !1 && qs(A, R.PATTERN))); + }); + let h, f, m, g; + t("Misc Mapping #2", () => { + h = $(r, Zl), f = $(s, Hf), m = oe(r, (A, R) => { + const I = R.GROUP; + return fe(I) && I !== de.SKIPPED && (A[I] = []), A; + }, {}), g = $(s, (A, R) => ({ + pattern: s[R], + longerAlt: l[R], + canLineTerminator: d[R], + isCustom: h[R], + short: f[R], + group: o[R], + push: c[R], + pop: u[R], + tokenTypeIdx: a[R], + tokenType: r[R] + })); + }); + let v = !0, y = []; + return e.safeMode || t("First Char Optimization", () => { + y = oe(r, (A, R, I) => { + if (typeof R.PATTERN == "string") { + const F = R.PATTERN.charCodeAt(0), re = tt(F); + Li(A, re, g[I]); + } else if (ee(R.START_CHARS_HINT)) { + let F; + N(R.START_CHARS_HINT, (re) => { + const _e = typeof re == "string" ? re.charCodeAt(0) : re, ye = tt(_e); + F !== ye && (F = ye, Li(A, ye, g[I])); + }); + } else if (Ye(R.PATTERN)) + if (R.PATTERN.unicode) + v = !1, e.ensureOptimizations && ts(`${Br} Unable to analyze < ${R.PATTERN.toString()} > pattern. + The regexp unicode flag is not currently supported by the regexp-to-ast library. + This will disable the lexer's first char optimizations. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE`); + else { + const F = kf(R.PATTERN, e.ensureOptimizations); + D(F) && (v = !1), N(F, (re) => { + Li(A, re, g[I]); + }); + } + else + e.ensureOptimizations && ts(`${Br} TokenType: <${R.name}> is using a custom token pattern without providing parameter. + This will disable the lexer's first char optimizations. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE`), v = !1; + return A; + }, []); + }), { + emptyGroups: m, + patternIdxToConfig: g, + charCodeToPatternIdxToConfig: y, + hasCustom: i, + canBeOptimized: v + }; +} +function If(n, e) { + let t = []; + const r = Cf(n); + t = t.concat(r.errors); + const i = wf(r.valid), s = i.valid; + return t = t.concat(i.errors), t = t.concat(Nf(s)), t = t.concat(Ff(s)), t = t.concat(Gf(s, e)), t = t.concat(Uf(s)), t; +} +function Nf(n) { + let e = []; + const t = xe(n, (r) => Ye(r[ht])); + return e = e.concat(Lf(t)), e = e.concat(Pf(t)), e = e.concat(Mf(t)), e = e.concat(Df(t)), e = e.concat(Of(t)), e; +} +function Cf(n) { + const e = xe(n, (i) => !C(i, ht)), t = $(e, (i) => ({ + message: "Token Type: ->" + i.name + "<- missing static 'PATTERN' property", + type: j.MISSING_PATTERN, + tokenTypes: [i] + })), r = ai(n, e); + return { errors: t, valid: r }; +} +function wf(n) { + const e = xe(n, (i) => { + const s = i[ht]; + return !Ye(s) && !gt(s) && !C(s, "exec") && !fe(s); + }), t = $(e, (i) => ({ + message: "Token Type: ->" + i.name + "<- static 'PATTERN' can only be a RegExp, a Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.", + type: j.INVALID_PATTERN, + tokenTypes: [i] + })), r = ai(n, e); + return { errors: t, valid: r }; +} +const _f = /[^\\][$]/; +function Lf(n) { + class e extends ui { + constructor() { + super(...arguments), this.found = !1; + } + visitEndAnchor(s) { + this.found = !0; + } + } + const t = xe(n, (i) => { + const s = i.PATTERN; + try { + const a = hi(s), o = new e(); + return o.visit(a), o.found; + } catch { + return _f.test(s.source); + } + }); + return $(t, (i) => ({ + message: `Unexpected RegExp Anchor Error: + Token Type: ->` + i.name + `<- static 'PATTERN' cannot contain end of input anchor '$' + See chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS for details.`, + type: j.EOI_ANCHOR_FOUND, + tokenTypes: [i] + })); +} +function Of(n) { + const e = xe(n, (r) => r.PATTERN.test("")); + return $(e, (r) => ({ + message: "Token Type: ->" + r.name + "<- static 'PATTERN' must not match an empty string", + type: j.EMPTY_MATCH_PATTERN, + tokenTypes: [r] + })); +} +const bf = /[^\\[][\^]|^\^/; +function Pf(n) { + class e extends ui { + constructor() { + super(...arguments), this.found = !1; + } + visitStartAnchor(s) { + this.found = !0; + } + } + const t = xe(n, (i) => { + const s = i.PATTERN; + try { + const a = hi(s), o = new e(); + return o.visit(a), o.found; + } catch { + return bf.test(s.source); + } + }); + return $(t, (i) => ({ + message: `Unexpected RegExp Anchor Error: + Token Type: ->` + i.name + `<- static 'PATTERN' cannot contain start of input anchor '^' + See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS for details.`, + type: j.SOI_ANCHOR_FOUND, + tokenTypes: [i] + })); +} +function Mf(n) { + const e = xe(n, (r) => { + const i = r[ht]; + return i instanceof RegExp && (i.multiline || i.global); + }); + return $(e, (r) => ({ + message: "Token Type: ->" + r.name + "<- static 'PATTERN' may NOT contain global('g') or multiline('m')", + type: j.UNSUPPORTED_FLAGS_FOUND, + tokenTypes: [r] + })); +} +function Df(n) { + const e = []; + let t = $(n, (s) => oe(n, (a, o) => (s.PATTERN.source === o.PATTERN.source && !ue(e, o) && o.PATTERN !== de.NA && (e.push(o), a.push(o)), a), [])); + t = Xn(t); + const r = xe(t, (s) => s.length > 1); + return $(r, (s) => { + const a = $(s, (l) => l.name); + return { + message: `The same RegExp pattern ->${Pe(s).PATTERN}<-has been used in all of the following Token Types: ${a.join(", ")} <-`, + type: j.DUPLICATE_PATTERNS_FOUND, + tokenTypes: s + }; + }); +} +function Ff(n) { + const e = xe(n, (r) => { + if (!C(r, "GROUP")) + return !1; + const i = r.GROUP; + return i !== de.SKIPPED && i !== de.NA && !fe(i); + }); + return $(e, (r) => ({ + message: "Token Type: ->" + r.name + "<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String", + type: j.INVALID_GROUP_TYPE_FOUND, + tokenTypes: [r] + })); +} +function Gf(n, e) { + const t = xe(n, (i) => i.PUSH_MODE !== void 0 && !ue(e, i.PUSH_MODE)); + return $(t, (i) => ({ + message: `Token Type: ->${i.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${i.PUSH_MODE}<-which does not exist`, + type: j.PUSH_MODE_DOES_NOT_EXIST, + tokenTypes: [i] + })); +} +function Uf(n) { + const e = [], t = oe(n, (r, i, s) => { + const a = i.PATTERN; + return a === de.NA || (fe(a) ? r.push({ str: a, idx: s, tokenType: i }) : Ye(a) && Vf(a) && r.push({ str: a.source, idx: s, tokenType: i })), r; + }, []); + return N(n, (r, i) => { + N(t, ({ str: s, idx: a, tokenType: o }) => { + if (i < a && Bf(s, r.PATTERN)) { + const l = `Token: ->${o.name}<- can never be matched. +Because it appears AFTER the Token Type ->${r.name}<-in the lexer's definition. +See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`; + e.push({ + message: l, + type: j.UNREACHABLE_PATTERN, + tokenTypes: [r, o] + }); + } + }); + }), e; +} +function Bf(n, e) { + if (Ye(e)) { + const t = e.exec(n); + return t !== null && t.index === 0; + } else { + if (gt(e)) + return e(n, 0, [], {}); + if (C(e, "exec")) + return e.exec(n, 0, [], {}); + if (typeof e == "string") + return e === n; + throw Error("non exhaustive match"); + } +} +function Vf(n) { + return Wt([ + ".", + "\\", + "[", + "]", + "|", + "^", + "$", + "(", + ")", + "?", + "*", + "+", + "{" + ], (t) => n.source.indexOf(t) !== -1) === void 0; +} +function $a(n) { + const e = n.ignoreCase ? "i" : ""; + return new RegExp(`^(?:${n.source})`, e); +} +function Sa(n) { + const e = n.ignoreCase ? "iy" : "y"; + return new RegExp(`${n.source}`, e); +} +function Kf(n, e, t) { + const r = []; + return C(n, Mn) || r.push({ + message: "A MultiMode Lexer cannot be initialized without a <" + Mn + `> property in its definition +`, + type: j.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE + }), C(n, gr) || r.push({ + message: "A MultiMode Lexer cannot be initialized without a <" + gr + `> property in its definition +`, + type: j.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY + }), C(n, gr) && C(n, Mn) && !C(n.modes, n.defaultMode) && r.push({ + message: `A MultiMode Lexer cannot be initialized with a ${Mn}: <${n.defaultMode}>which does not exist +`, + type: j.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST + }), C(n, gr) && N(n.modes, (i, s) => { + N(i, (a, o) => { + if (qe(a)) + r.push({ + message: `A Lexer cannot be initialized using an undefined Token Type. Mode:<${s}> at index: <${o}> +`, + type: j.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED + }); + else if (C(a, "LONGER_ALT")) { + const l = ee(a.LONGER_ALT) ? a.LONGER_ALT : [a.LONGER_ALT]; + N(l, (c) => { + !qe(c) && !ue(i, c) && r.push({ + message: `A MultiMode Lexer cannot be initialized with a longer_alt <${c.name}> on token <${a.name}> outside of mode <${s}> +`, + type: j.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE + }); + }); + } + }); + }), r; +} +function Wf(n, e, t) { + const r = []; + let i = !1; + const s = Xn(Ce(z(n.modes))), a = oi(s, (l) => l[ht] === de.NA), o = tc(t); + return e && N(a, (l) => { + const c = ec(l, o); + if (c !== !1) { + const d = { + message: qf(l, c), + type: c.issue, + tokenType: l + }; + r.push(d); + } else + C(l, "LINE_BREAKS") ? l.LINE_BREAKS === !0 && (i = !0) : qs(o, l.PATTERN) && (i = !0); + }), e && !i && r.push({ + message: `Warning: No LINE_BREAKS Found. + This Lexer has been defined to track line and column information, + But none of the Token Types can be identified as matching a line terminator. + See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS + for details.`, + type: j.NO_LINE_BREAKS_FLAGS + }), r; +} +function jf(n) { + const e = {}, t = Kt(n); + return N(t, (r) => { + const i = n[r]; + if (ee(i)) + e[r] = []; + else + throw Error("non exhaustive match"); + }), e; +} +function Zl(n) { + const e = n.PATTERN; + if (Ye(e)) + return !1; + if (gt(e)) + return !0; + if (C(e, "exec")) + return !0; + if (fe(e)) + return !1; + throw Error("non exhaustive match"); +} +function Hf(n) { + return fe(n) && n.length === 1 ? n.charCodeAt(0) : !1; +} +const zf = { + // implements /\n|\r\n?/g.test + test: function(n) { + const e = n.length; + for (let t = this.lastIndex; t < e; t++) { + const r = n.charCodeAt(t); + if (r === 10) + return this.lastIndex = t + 1, !0; + if (r === 13) + return n.charCodeAt(t + 1) === 10 ? this.lastIndex = t + 2 : this.lastIndex = t + 1, !0; + } + return !1; + }, + lastIndex: 0 +}; +function ec(n, e) { + if (C(n, "LINE_BREAKS")) + return !1; + if (Ye(n.PATTERN)) { + try { + qs(e, n.PATTERN); + } catch (t) { + return { + issue: j.IDENTIFY_TERMINATOR, + errMsg: t.message + }; + } + return !1; + } else { + if (fe(n.PATTERN)) + return !1; + if (Zl(n)) + return { issue: j.CUSTOM_LINE_BREAK }; + throw Error("non exhaustive match"); + } +} +function qf(n, e) { + if (e.issue === j.IDENTIFY_TERMINATOR) + return `Warning: unable to identify line terminator usage in pattern. + The problem is in the <${n.name}> Token Type + Root cause: ${e.errMsg}. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR`; + if (e.issue === j.CUSTOM_LINE_BREAK) + return `Warning: A Custom Token Pattern should specify the option. + The problem is in the <${n.name}> Token Type + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK`; + throw Error("non exhaustive match"); +} +function tc(n) { + return $(n, (t) => fe(t) ? t.charCodeAt(0) : t); +} +function Li(n, e, t) { + n[e] === void 0 ? n[e] = [t] : n[e].push(t); +} +const Dn = 256; +let Sr = []; +function tt(n) { + return n < Dn ? n : Sr[n]; +} +function Yf() { + if (D(Sr)) { + Sr = new Array(65536); + for (let n = 0; n < 65536; n++) + Sr[n] = n > 255 ? 255 + ~~(n / 255) : n; + } +} +function er(n, e) { + const t = n.tokenTypeIdx; + return t === e.tokenTypeIdx ? !0 : e.isParent === !0 && e.categoryMatchesMap[t] === !0; +} +function Vr(n, e) { + return n.tokenTypeIdx === e.tokenTypeIdx; +} +let Ia = 1; +const nc = {}; +function tr(n) { + const e = Xf(n); + Jf(e), Zf(e), Qf(e), N(e, (t) => { + t.isParent = t.categoryMatches.length > 0; + }); +} +function Xf(n) { + let e = ne(n), t = n, r = !0; + for (; r; ) { + t = Xn(Ce($(t, (s) => s.CATEGORIES))); + const i = ai(t, e); + e = e.concat(i), D(i) ? r = !1 : t = i; + } + return e; +} +function Jf(n) { + N(n, (e) => { + ic(e) || (nc[Ia] = e, e.tokenTypeIdx = Ia++), Na(e) && !ee(e.CATEGORIES) && (e.CATEGORIES = [e.CATEGORIES]), Na(e) || (e.CATEGORIES = []), eh(e) || (e.categoryMatches = []), th(e) || (e.categoryMatchesMap = {}); + }); +} +function Qf(n) { + N(n, (e) => { + e.categoryMatches = [], N(e.categoryMatchesMap, (t, r) => { + e.categoryMatches.push(nc[r].tokenTypeIdx); + }); + }); +} +function Zf(n) { + N(n, (e) => { + rc([], e); + }); +} +function rc(n, e) { + N(n, (t) => { + e.categoryMatchesMap[t.tokenTypeIdx] = !0; + }), N(e.CATEGORIES, (t) => { + const r = n.concat(e); + ue(r, t) || rc(r, t); + }); +} +function ic(n) { + return C(n, "tokenTypeIdx"); +} +function Na(n) { + return C(n, "CATEGORIES"); +} +function eh(n) { + return C(n, "categoryMatches"); +} +function th(n) { + return C(n, "categoryMatchesMap"); +} +function nh(n) { + return C(n, "tokenTypeIdx"); +} +const is = { + buildUnableToPopLexerModeMessage(n) { + return `Unable to pop Lexer Mode after encountering Token ->${n.image}<- The Mode Stack is empty`; + }, + buildUnexpectedCharactersMessage(n, e, t, r, i) { + return `unexpected character: ->${n.charAt(e)}<- at offset: ${e}, skipped ${t} characters.`; + } +}; +var j; +(function(n) { + n[n.MISSING_PATTERN = 0] = "MISSING_PATTERN", n[n.INVALID_PATTERN = 1] = "INVALID_PATTERN", n[n.EOI_ANCHOR_FOUND = 2] = "EOI_ANCHOR_FOUND", n[n.UNSUPPORTED_FLAGS_FOUND = 3] = "UNSUPPORTED_FLAGS_FOUND", n[n.DUPLICATE_PATTERNS_FOUND = 4] = "DUPLICATE_PATTERNS_FOUND", n[n.INVALID_GROUP_TYPE_FOUND = 5] = "INVALID_GROUP_TYPE_FOUND", n[n.PUSH_MODE_DOES_NOT_EXIST = 6] = "PUSH_MODE_DOES_NOT_EXIST", n[n.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE = 7] = "MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE", n[n.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY = 8] = "MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY", n[n.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST = 9] = "MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST", n[n.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED = 10] = "LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED", n[n.SOI_ANCHOR_FOUND = 11] = "SOI_ANCHOR_FOUND", n[n.EMPTY_MATCH_PATTERN = 12] = "EMPTY_MATCH_PATTERN", n[n.NO_LINE_BREAKS_FLAGS = 13] = "NO_LINE_BREAKS_FLAGS", n[n.UNREACHABLE_PATTERN = 14] = "UNREACHABLE_PATTERN", n[n.IDENTIFY_TERMINATOR = 15] = "IDENTIFY_TERMINATOR", n[n.CUSTOM_LINE_BREAK = 16] = "CUSTOM_LINE_BREAK", n[n.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE = 17] = "MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE"; +})(j || (j = {})); +const Fn = { + deferDefinitionErrorsHandling: !1, + positionTracking: "full", + lineTerminatorsPattern: /\n|\r\n?/g, + lineTerminatorCharacters: [` +`, "\r"], + ensureOptimizations: !1, + safeMode: !1, + errorMessageProvider: is, + traceInitPerf: !1, + skipValidations: !1, + recoveryEnabled: !0 +}; +Object.freeze(Fn); +class de { + constructor(e, t = Fn) { + if (this.lexerDefinition = e, this.lexerDefinitionErrors = [], this.lexerDefinitionWarning = [], this.patternIdxToConfig = {}, this.charCodeToPatternIdxToConfig = {}, this.modes = [], this.emptyGroups = {}, this.trackStartLines = !0, this.trackEndLines = !0, this.hasCustom = !1, this.canModeBeOptimized = {}, this.TRACE_INIT = (i, s) => { + if (this.traceInitPerf === !0) { + this.traceInitIndent++; + const a = new Array(this.traceInitIndent + 1).join(" "); + this.traceInitIndent < this.traceInitMaxIdent && console.log(`${a}--> <${i}>`); + const { time: o, value: l } = ql(s), c = o > 10 ? console.warn : console.log; + return this.traceInitIndent < this.traceInitMaxIdent && c(`${a}<-- <${i}> time: ${o}ms`), this.traceInitIndent--, l; + } else + return s(); + }, typeof t == "boolean") + throw Error(`The second argument to the Lexer constructor is now an ILexerConfig Object. +a boolean 2nd argument is no longer supported`); + this.config = ke({}, Fn, t); + const r = this.config.traceInitPerf; + r === !0 ? (this.traceInitMaxIdent = 1 / 0, this.traceInitPerf = !0) : typeof r == "number" && (this.traceInitMaxIdent = r, this.traceInitPerf = !0), this.traceInitIndent = -1, this.TRACE_INIT("Lexer Constructor", () => { + let i, s = !0; + this.TRACE_INIT("Lexer Config handling", () => { + if (this.config.lineTerminatorsPattern === Fn.lineTerminatorsPattern) + this.config.lineTerminatorsPattern = zf; + else if (this.config.lineTerminatorCharacters === Fn.lineTerminatorCharacters) + throw Error(`Error: Missing property on the Lexer config. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS`); + if (t.safeMode && t.ensureOptimizations) + throw Error('"safeMode" and "ensureOptimizations" flags are mutually exclusive.'); + this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking), this.trackEndLines = /full/i.test(this.config.positionTracking), ee(e) ? i = { + modes: { defaultMode: ne(e) }, + defaultMode: Mn + } : (s = !1, i = ne(e)); + }), this.config.skipValidations === !1 && (this.TRACE_INIT("performRuntimeChecks", () => { + this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(Kf(i, this.trackStartLines, this.config.lineTerminatorCharacters)); + }), this.TRACE_INIT("performWarningRuntimeChecks", () => { + this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(Wf(i, this.trackStartLines, this.config.lineTerminatorCharacters)); + })), i.modes = i.modes ? i.modes : {}, N(i.modes, (o, l) => { + i.modes[l] = oi(o, (c) => qe(c)); + }); + const a = Kt(i.modes); + if (N(i.modes, (o, l) => { + this.TRACE_INIT(`Mode: <${l}> processing`, () => { + if (this.modes.push(l), this.config.skipValidations === !1 && this.TRACE_INIT("validatePatterns", () => { + this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(If(o, a)); + }), D(this.lexerDefinitionErrors)) { + tr(o); + let c; + this.TRACE_INIT("analyzeTokenTypes", () => { + c = Sf(o, { + lineTerminatorCharacters: this.config.lineTerminatorCharacters, + positionTracking: t.positionTracking, + ensureOptimizations: t.ensureOptimizations, + safeMode: t.safeMode, + tracer: this.TRACE_INIT + }); + }), this.patternIdxToConfig[l] = c.patternIdxToConfig, this.charCodeToPatternIdxToConfig[l] = c.charCodeToPatternIdxToConfig, this.emptyGroups = ke({}, this.emptyGroups, c.emptyGroups), this.hasCustom = c.hasCustom || this.hasCustom, this.canModeBeOptimized[l] = c.canBeOptimized; + } + }); + }), this.defaultMode = i.defaultMode, !D(this.lexerDefinitionErrors) && !this.config.deferDefinitionErrorsHandling) { + const l = $(this.lexerDefinitionErrors, (c) => c.message).join(`----------------------- +`); + throw new Error(`Errors detected in definition of Lexer: +` + l); + } + N(this.lexerDefinitionWarning, (o) => { + zl(o.message); + }), this.TRACE_INIT("Choosing sub-methods implementations", () => { + if (Ql ? (this.chopInput = ma, this.match = this.matchWithTest) : (this.updateLastIndex = Y, this.match = this.matchWithExec), s && (this.handleModes = Y), this.trackStartLines === !1 && (this.computeNewColumn = ma), this.trackEndLines === !1 && (this.updateTokenEndLineColumnLocation = Y), /full/i.test(this.config.positionTracking)) + this.createTokenInstance = this.createFullToken; + else if (/onlyStart/i.test(this.config.positionTracking)) + this.createTokenInstance = this.createStartOnlyToken; + else if (/onlyOffset/i.test(this.config.positionTracking)) + this.createTokenInstance = this.createOffsetOnlyToken; + else + throw Error(`Invalid config option: "${this.config.positionTracking}"`); + this.hasCustom ? (this.addToken = this.addTokenUsingPush, this.handlePayload = this.handlePayloadWithCustom) : (this.addToken = this.addTokenUsingMemberAccess, this.handlePayload = this.handlePayloadNoCustom); + }), this.TRACE_INIT("Failed Optimization Warnings", () => { + const o = oe(this.canModeBeOptimized, (l, c, u) => (c === !1 && l.push(u), l), []); + if (t.ensureOptimizations && !D(o)) + throw Error(`Lexer Modes: < ${o.join(", ")} > cannot be optimized. + Disable the "ensureOptimizations" lexer config flag to silently ignore this and run the lexer in an un-optimized mode. + Or inspect the console log for details on how to resolve these issues.`); + }), this.TRACE_INIT("clearRegExpParserCache", () => { + Ef(); + }), this.TRACE_INIT("toFastProperties", () => { + Yl(this); + }); + }); + } + tokenize(e, t = this.defaultMode) { + if (!D(this.lexerDefinitionErrors)) { + const i = $(this.lexerDefinitionErrors, (s) => s.message).join(`----------------------- +`); + throw new Error(`Unable to Tokenize because Errors detected in definition of Lexer: +` + i); + } + return this.tokenizeInternal(e, t); + } + // There is quite a bit of duplication between this and "tokenizeInternalLazy" + // This is intentional due to performance considerations. + // this method also used quite a bit of `!` none null assertions because it is too optimized + // for `tsc` to always understand it is "safe" + tokenizeInternal(e, t) { + let r, i, s, a, o, l, c, u, d, h, f, m, g, v, y; + const A = e, R = A.length; + let I = 0, F = 0; + const re = this.hasCustom ? 0 : Math.floor(e.length / 10), _e = new Array(re), ye = []; + let De = this.trackStartLines ? 1 : void 0, Ie = this.trackStartLines ? 1 : void 0; + const x = jf(this.emptyGroups), T = this.trackStartLines, E = this.config.lineTerminatorsPattern; + let S = 0, O = [], L = []; + const _ = [], Te = []; + Object.freeze(Te); + let q; + function K() { + return O; + } + function ot(ie) { + const Ne = tt(ie), kt = L[Ne]; + return kt === void 0 ? Te : kt; + } + const Au = (ie) => { + if (_.length === 1 && // if we have both a POP_MODE and a PUSH_MODE this is in-fact a "transition" + // So no error should occur. + ie.tokenType.PUSH_MODE === void 0) { + const Ne = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(ie); + ye.push({ + offset: ie.startOffset, + line: ie.startLine, + column: ie.startColumn, + length: ie.image.length, + message: Ne + }); + } else { + _.pop(); + const Ne = jt(_); + O = this.patternIdxToConfig[Ne], L = this.charCodeToPatternIdxToConfig[Ne], S = O.length; + const kt = this.canModeBeOptimized[Ne] && this.config.safeMode === !1; + L && kt ? q = ot : q = K; + } + }; + function ua(ie) { + _.push(ie), L = this.charCodeToPatternIdxToConfig[ie], O = this.patternIdxToConfig[ie], S = O.length, S = O.length; + const Ne = this.canModeBeOptimized[ie] && this.config.safeMode === !1; + L && Ne ? q = ot : q = K; + } + ua.call(this, t); + let Le; + const da = this.config.recoveryEnabled; + for (; I < R; ) { + l = null; + const ie = A.charCodeAt(I), Ne = q(ie), kt = Ne.length; + for (r = 0; r < kt; r++) { + Le = Ne[r]; + const Re = Le.pattern; + c = null; + const Ve = Le.short; + if (Ve !== !1 ? ie === Ve && (l = Re) : Le.isCustom === !0 ? (y = Re.exec(A, I, _e, x), y !== null ? (l = y[0], y.payload !== void 0 && (c = y.payload)) : l = null) : (this.updateLastIndex(Re, I), l = this.match(Re, e, I)), l !== null) { + if (o = Le.longerAlt, o !== void 0) { + const Je = o.length; + for (s = 0; s < Je; s++) { + const Ke = O[o[s]], lt = Ke.pattern; + if (u = null, Ke.isCustom === !0 ? (y = lt.exec(A, I, _e, x), y !== null ? (a = y[0], y.payload !== void 0 && (u = y.payload)) : a = null) : (this.updateLastIndex(lt, I), a = this.match(lt, e, I)), a && a.length > l.length) { + l = a, c = u, Le = Ke; + break; + } + } + } + break; + } + } + if (l !== null) { + if (d = l.length, h = Le.group, h !== void 0 && (f = Le.tokenTypeIdx, m = this.createTokenInstance(l, I, f, Le.tokenType, De, Ie, d), this.handlePayload(m, c), h === !1 ? F = this.addToken(_e, F, m) : x[h].push(m)), e = this.chopInput(e, d), I = I + d, Ie = this.computeNewColumn(Ie, d), T === !0 && Le.canLineTerminator === !0) { + let Re = 0, Ve, Je; + E.lastIndex = 0; + do + Ve = E.test(l), Ve === !0 && (Je = E.lastIndex - 1, Re++); + while (Ve === !0); + Re !== 0 && (De = De + Re, Ie = d - Je, this.updateTokenEndLineColumnLocation(m, h, Je, Re, De, Ie, d)); + } + this.handleModes(Le, Au, ua, m); + } else { + const Re = I, Ve = De, Je = Ie; + let Ke = da === !1; + for (; Ke === !1 && I < R; ) + for (e = this.chopInput(e, 1), I++, i = 0; i < S; i++) { + const lt = O[i], ki = lt.pattern, fa = lt.short; + if (fa !== !1 ? A.charCodeAt(I) === fa && (Ke = !0) : lt.isCustom === !0 ? Ke = ki.exec(A, I, _e, x) !== null : (this.updateLastIndex(ki, I), Ke = ki.exec(e) !== null), Ke === !0) + break; + } + if (g = I - Re, Ie = this.computeNewColumn(Ie, g), v = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(A, Re, g, Ve, Je), ye.push({ + offset: Re, + line: Ve, + column: Je, + length: g, + message: v + }), da === !1) + break; + } + } + return this.hasCustom || (_e.length = F), { + tokens: _e, + groups: x, + errors: ye + }; + } + handleModes(e, t, r, i) { + if (e.pop === !0) { + const s = e.push; + t(i), s !== void 0 && r.call(this, s); + } else e.push !== void 0 && r.call(this, e.push); + } + chopInput(e, t) { + return e.substring(t); + } + updateLastIndex(e, t) { + e.lastIndex = t; + } + // TODO: decrease this under 600 characters? inspect stripping comments option in TSC compiler + updateTokenEndLineColumnLocation(e, t, r, i, s, a, o) { + let l, c; + t !== void 0 && (l = r === o - 1, c = l ? -1 : 0, i === 1 && l === !0 || (e.endLine = s + c, e.endColumn = a - 1 + -c)); + } + computeNewColumn(e, t) { + return e + t; + } + createOffsetOnlyToken(e, t, r, i) { + return { + image: e, + startOffset: t, + tokenTypeIdx: r, + tokenType: i + }; + } + createStartOnlyToken(e, t, r, i, s, a) { + return { + image: e, + startOffset: t, + startLine: s, + startColumn: a, + tokenTypeIdx: r, + tokenType: i + }; + } + createFullToken(e, t, r, i, s, a, o) { + return { + image: e, + startOffset: t, + endOffset: t + o - 1, + startLine: s, + endLine: s, + startColumn: a, + endColumn: a + o - 1, + tokenTypeIdx: r, + tokenType: i + }; + } + addTokenUsingPush(e, t, r) { + return e.push(r), t; + } + addTokenUsingMemberAccess(e, t, r) { + return e[t] = r, t++, t; + } + handlePayloadNoCustom(e, t) { + } + handlePayloadWithCustom(e, t) { + t !== null && (e.payload = t); + } + matchWithTest(e, t, r) { + return e.test(t) === !0 ? t.substring(r, e.lastIndex) : null; + } + matchWithExec(e, t) { + const r = e.exec(t); + return r !== null ? r[0] : null; + } +} +de.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it willbe consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace."; +de.NA = /NOT_APPLICABLE/; +function Nt(n) { + return sc(n) ? n.LABEL : n.name; +} +function sc(n) { + return fe(n.LABEL) && n.LABEL !== ""; +} +const rh = "parent", Ca = "categories", wa = "label", _a = "group", La = "push_mode", Oa = "pop_mode", ba = "longer_alt", Pa = "line_breaks", Ma = "start_chars_hint"; +function ac(n) { + return ih(n); +} +function ih(n) { + const e = n.pattern, t = {}; + if (t.name = n.name, qe(e) || (t.PATTERN = e), C(n, rh)) + throw `The parent property is no longer supported. +See: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.`; + return C(n, Ca) && (t.CATEGORIES = n[Ca]), tr([t]), C(n, wa) && (t.LABEL = n[wa]), C(n, _a) && (t.GROUP = n[_a]), C(n, Oa) && (t.POP_MODE = n[Oa]), C(n, La) && (t.PUSH_MODE = n[La]), C(n, ba) && (t.LONGER_ALT = n[ba]), C(n, Pa) && (t.LINE_BREAKS = n[Pa]), C(n, Ma) && (t.START_CHARS_HINT = n[Ma]), t; +} +const nt = ac({ name: "EOF", pattern: de.NA }); +tr([nt]); +function Ys(n, e, t, r, i, s, a, o) { + return { + image: e, + startOffset: t, + endOffset: r, + startLine: i, + endLine: s, + startColumn: a, + endColumn: o, + tokenTypeIdx: n.tokenTypeIdx, + tokenType: n + }; +} +function oc(n, e) { + return er(n, e); +} +const St = { + buildMismatchTokenMessage({ expected: n, actual: e, previous: t, ruleName: r }) { + return `Expecting ${sc(n) ? `--> ${Nt(n)} <--` : `token of type --> ${n.name} <--`} but found --> '${e.image}' <--`; + }, + buildNotAllInputParsedMessage({ firstRedundant: n, ruleName: e }) { + return "Redundant input, expecting EOF but found: " + n.image; + }, + buildNoViableAltMessage({ expectedPathsPerAlt: n, actual: e, previous: t, customUserDescription: r, ruleName: i }) { + const s = "Expecting: ", o = ` +but found: '` + Pe(e).image + "'"; + if (r) + return s + r + o; + { + const l = oe(n, (h, f) => h.concat(f), []), c = $(l, (h) => `[${$(h, (f) => Nt(f)).join(", ")}]`), d = `one of these possible Token sequences: +${$(c, (h, f) => ` ${f + 1}. ${h}`).join(` +`)}`; + return s + d + o; + } + }, + buildEarlyExitMessage({ expectedIterationPaths: n, actual: e, customUserDescription: t, ruleName: r }) { + const i = "Expecting: ", a = ` +but found: '` + Pe(e).image + "'"; + if (t) + return i + t + a; + { + const l = `expecting at least one iteration which starts with one of these possible Token sequences:: + <${$(n, (c) => `[${$(c, (u) => Nt(u)).join(",")}]`).join(" ,")}>`; + return i + l + a; + } + } +}; +Object.freeze(St); +const sh = { + buildRuleNotFoundError(n, e) { + return "Invalid grammar, reference to a rule which is not defined: ->" + e.nonTerminalName + `<- +inside top level rule: ->` + n.name + "<-"; + } +}, ct = { + buildDuplicateFoundError(n, e) { + function t(u) { + return u instanceof G ? u.terminalType.name : u instanceof le ? u.nonTerminalName : ""; + } + const r = n.name, i = Pe(e), s = i.idx, a = Fe(i), o = t(i), l = s > 0; + let c = `->${a}${l ? s : ""}<- ${o ? `with argument: ->${o}<-` : ""} + appears more than once (${e.length} times) in the top level rule: ->${r}<-. + For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES + `; + return c = c.replace(/[ \t]+/g, " "), c = c.replace(/\s\s+/g, ` +`), c; + }, + buildNamespaceConflictError(n) { + return `Namespace conflict found in grammar. +The grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${n.name}>. +To resolve this make sure each Terminal and Non-Terminal names are unique +This is easy to accomplish by using the convention that Terminal names start with an uppercase letter +and Non-Terminal names start with a lower case letter.`; + }, + buildAlternationPrefixAmbiguityError(n) { + const e = $(n.prefixPath, (i) => Nt(i)).join(", "), t = n.alternation.idx === 0 ? "" : n.alternation.idx; + return `Ambiguous alternatives: <${n.ambiguityIndices.join(" ,")}> due to common lookahead prefix +in inside <${n.topLevelRule.name}> Rule, +<${e}> may appears as a prefix path in all these alternatives. +See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX +For Further details.`; + }, + buildAlternationAmbiguityError(n) { + const e = $(n.prefixPath, (i) => Nt(i)).join(", "), t = n.alternation.idx === 0 ? "" : n.alternation.idx; + let r = `Ambiguous Alternatives Detected: <${n.ambiguityIndices.join(" ,")}> in inside <${n.topLevelRule.name}> Rule, +<${e}> may appears as a prefix path in all these alternatives. +`; + return r = r + `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES +For Further details.`, r; + }, + buildEmptyRepetitionError(n) { + let e = Fe(n.repetition); + return n.repetition.idx !== 0 && (e += n.repetition.idx), `The repetition <${e}> within Rule <${n.topLevelRule.name}> can never consume any tokens. +This could lead to an infinite loop.`; + }, + // TODO: remove - `errors_public` from nyc.config.js exclude + // once this method is fully removed from this file + buildTokenNameError(n) { + return "deprecated"; + }, + buildEmptyAlternationError(n) { + return `Ambiguous empty alternative: <${n.emptyChoiceIdx + 1}> in inside <${n.topLevelRule.name}> Rule. +Only the last alternative may be an empty alternative.`; + }, + buildTooManyAlternativesError(n) { + return `An Alternation cannot have more than 256 alternatives: + inside <${n.topLevelRule.name}> Rule. + has ${n.alternation.definition.length + 1} alternatives.`; + }, + buildLeftRecursionError(n) { + const e = n.topLevelRule.name, t = $(n.leftRecursionPath, (s) => s.name), r = `${e} --> ${t.concat([e]).join(" --> ")}`; + return `Left Recursion found in grammar. +rule: <${e}> can be invoked from itself (directly or indirectly) +without consuming any Tokens. The grammar path that causes this is: + ${r} + To fix this refactor your grammar to remove the left recursion. +see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`; + }, + // TODO: remove - `errors_public` from nyc.config.js exclude + // once this method is fully removed from this file + buildInvalidRuleNameError(n) { + return "deprecated"; + }, + buildDuplicateRuleNameError(n) { + let e; + return n.topLevelRule instanceof Zt ? e = n.topLevelRule.name : e = n.topLevelRule, `Duplicate definition, rule: ->${e}<- is already defined in the grammar: ->${n.grammarName}<-`; + } +}; +function ah(n, e) { + const t = new oh(n, e); + return t.resolveRefs(), t.errors; +} +class oh extends en { + constructor(e, t) { + super(), this.nameToTopRule = e, this.errMsgProvider = t, this.errors = []; + } + resolveRefs() { + N(z(this.nameToTopRule), (e) => { + this.currTopLevel = e, e.accept(this); + }); + } + visitNonTerminal(e) { + const t = this.nameToTopRule[e.nonTerminalName]; + if (t) + e.referencedRule = t; + else { + const r = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e); + this.errors.push({ + message: r, + type: ce.UNRESOLVED_SUBRULE_REF, + ruleName: this.currTopLevel.name, + unresolvedRefName: e.nonTerminalName + }); + } + } +} +class lh extends fi { + constructor(e, t) { + super(), this.topProd = e, this.path = t, this.possibleTokTypes = [], this.nextProductionName = "", this.nextProductionOccurrence = 0, this.found = !1, this.isAtEndOfPath = !1; + } + startWalking() { + if (this.found = !1, this.path.ruleStack[0] !== this.topProd.name) + throw Error("The path does not start with the walker's top Rule!"); + return this.ruleStack = ne(this.path.ruleStack).reverse(), this.occurrenceStack = ne(this.path.occurrenceStack).reverse(), this.ruleStack.pop(), this.occurrenceStack.pop(), this.updateExpectedNext(), this.walk(this.topProd), this.possibleTokTypes; + } + walk(e, t = []) { + this.found || super.walk(e, t); + } + walkProdRef(e, t, r) { + if (e.referencedRule.name === this.nextProductionName && e.idx === this.nextProductionOccurrence) { + const i = t.concat(r); + this.updateExpectedNext(), this.walk(e.referencedRule, i); + } + } + updateExpectedNext() { + D(this.ruleStack) ? (this.nextProductionName = "", this.nextProductionOccurrence = 0, this.isAtEndOfPath = !0) : (this.nextProductionName = this.ruleStack.pop(), this.nextProductionOccurrence = this.occurrenceStack.pop()); + } +} +class ch extends lh { + constructor(e, t) { + super(e, t), this.path = t, this.nextTerminalName = "", this.nextTerminalOccurrence = 0, this.nextTerminalName = this.path.lastTok.name, this.nextTerminalOccurrence = this.path.lastTokOccurrence; + } + walkTerminal(e, t, r) { + if (this.isAtEndOfPath && e.terminalType.name === this.nextTerminalName && e.idx === this.nextTerminalOccurrence && !this.found) { + const i = t.concat(r), s = new he({ definition: i }); + this.possibleTokTypes = Zn(s), this.found = !0; + } + } +} +class pi extends fi { + constructor(e, t) { + super(), this.topRule = e, this.occurrence = t, this.result = { + token: void 0, + occurrence: void 0, + isEndOfRule: void 0 + }; + } + startWalking() { + return this.walk(this.topRule), this.result; + } +} +class uh extends pi { + walkMany(e, t, r) { + if (e.idx === this.occurrence) { + const i = Pe(t.concat(r)); + this.result.isEndOfRule = i === void 0, i instanceof G && (this.result.token = i.terminalType, this.result.occurrence = i.idx); + } else + super.walkMany(e, t, r); + } +} +class Da extends pi { + walkManySep(e, t, r) { + if (e.idx === this.occurrence) { + const i = Pe(t.concat(r)); + this.result.isEndOfRule = i === void 0, i instanceof G && (this.result.token = i.terminalType, this.result.occurrence = i.idx); + } else + super.walkManySep(e, t, r); + } +} +class dh extends pi { + walkAtLeastOne(e, t, r) { + if (e.idx === this.occurrence) { + const i = Pe(t.concat(r)); + this.result.isEndOfRule = i === void 0, i instanceof G && (this.result.token = i.terminalType, this.result.occurrence = i.idx); + } else + super.walkAtLeastOne(e, t, r); + } +} +class Fa extends pi { + walkAtLeastOneSep(e, t, r) { + if (e.idx === this.occurrence) { + const i = Pe(t.concat(r)); + this.result.isEndOfRule = i === void 0, i instanceof G && (this.result.token = i.terminalType, this.result.occurrence = i.idx); + } else + super.walkAtLeastOneSep(e, t, r); + } +} +function ss(n, e, t = []) { + t = ne(t); + let r = [], i = 0; + function s(o) { + return o.concat(J(n, i + 1)); + } + function a(o) { + const l = ss(s(o), e, t); + return r.concat(l); + } + for (; t.length < e && i < n.length; ) { + const o = n[i]; + if (o instanceof he) + return a(o.definition); + if (o instanceof le) + return a(o.definition); + if (o instanceof te) + r = a(o.definition); + else if (o instanceof $e) { + const l = o.definition.concat([ + new W({ + definition: o.definition + }) + ]); + return a(l); + } else if (o instanceof Se) { + const l = [ + new he({ definition: o.definition }), + new W({ + definition: [new G({ terminalType: o.separator })].concat(o.definition) + }) + ]; + return a(l); + } else if (o instanceof me) { + const l = o.definition.concat([ + new W({ + definition: [new G({ terminalType: o.separator })].concat(o.definition) + }) + ]); + r = a(l); + } else if (o instanceof W) { + const l = o.definition.concat([ + new W({ + definition: o.definition + }) + ]); + r = a(l); + } else { + if (o instanceof ge) + return N(o.definition, (l) => { + D(l.definition) === !1 && (r = a(l.definition)); + }), r; + if (o instanceof G) + t.push(o.terminalType); + else + throw Error("non exhaustive match"); + } + i++; + } + return r.push({ + partialPath: t, + suffixDef: J(n, i) + }), r; +} +function lc(n, e, t, r) { + const i = "EXIT_NONE_TERMINAL", s = [i], a = "EXIT_ALTERNATIVE"; + let o = !1; + const l = e.length, c = l - r - 1, u = [], d = []; + for (d.push({ + idx: -1, + def: n, + ruleStack: [], + occurrenceStack: [] + }); !D(d); ) { + const h = d.pop(); + if (h === a) { + o && jt(d).idx <= c && d.pop(); + continue; + } + const f = h.def, m = h.idx, g = h.ruleStack, v = h.occurrenceStack; + if (D(f)) + continue; + const y = f[0]; + if (y === i) { + const A = { + idx: m, + def: J(f), + ruleStack: jn(g), + occurrenceStack: jn(v) + }; + d.push(A); + } else if (y instanceof G) + if (m < l - 1) { + const A = m + 1, R = e[A]; + if (t(R, y.terminalType)) { + const I = { + idx: A, + def: J(f), + ruleStack: g, + occurrenceStack: v + }; + d.push(I); + } + } else if (m === l - 1) + u.push({ + nextTokenType: y.terminalType, + nextTokenOccurrence: y.idx, + ruleStack: g, + occurrenceStack: v + }), o = !0; + else + throw Error("non exhaustive match"); + else if (y instanceof le) { + const A = ne(g); + A.push(y.nonTerminalName); + const R = ne(v); + R.push(y.idx); + const I = { + idx: m, + def: y.definition.concat(s, J(f)), + ruleStack: A, + occurrenceStack: R + }; + d.push(I); + } else if (y instanceof te) { + const A = { + idx: m, + def: J(f), + ruleStack: g, + occurrenceStack: v + }; + d.push(A), d.push(a); + const R = { + idx: m, + def: y.definition.concat(J(f)), + ruleStack: g, + occurrenceStack: v + }; + d.push(R); + } else if (y instanceof $e) { + const A = new W({ + definition: y.definition, + idx: y.idx + }), R = y.definition.concat([A], J(f)), I = { + idx: m, + def: R, + ruleStack: g, + occurrenceStack: v + }; + d.push(I); + } else if (y instanceof Se) { + const A = new G({ + terminalType: y.separator + }), R = new W({ + definition: [A].concat(y.definition), + idx: y.idx + }), I = y.definition.concat([R], J(f)), F = { + idx: m, + def: I, + ruleStack: g, + occurrenceStack: v + }; + d.push(F); + } else if (y instanceof me) { + const A = { + idx: m, + def: J(f), + ruleStack: g, + occurrenceStack: v + }; + d.push(A), d.push(a); + const R = new G({ + terminalType: y.separator + }), I = new W({ + definition: [R].concat(y.definition), + idx: y.idx + }), F = y.definition.concat([I], J(f)), re = { + idx: m, + def: F, + ruleStack: g, + occurrenceStack: v + }; + d.push(re); + } else if (y instanceof W) { + const A = { + idx: m, + def: J(f), + ruleStack: g, + occurrenceStack: v + }; + d.push(A), d.push(a); + const R = new W({ + definition: y.definition, + idx: y.idx + }), I = y.definition.concat([R], J(f)), F = { + idx: m, + def: I, + ruleStack: g, + occurrenceStack: v + }; + d.push(F); + } else if (y instanceof ge) + for (let A = y.definition.length - 1; A >= 0; A--) { + const R = y.definition[A], I = { + idx: m, + def: R.definition.concat(J(f)), + ruleStack: g, + occurrenceStack: v + }; + d.push(I), d.push(a); + } + else if (y instanceof he) + d.push({ + idx: m, + def: y.definition.concat(J(f)), + ruleStack: g, + occurrenceStack: v + }); + else if (y instanceof Zt) + d.push(fh(y, m, g, v)); + else + throw Error("non exhaustive match"); + } + return u; +} +function fh(n, e, t, r) { + const i = ne(t); + i.push(n.name); + const s = ne(r); + return s.push(1), { + idx: e, + def: n.definition, + ruleStack: i, + occurrenceStack: s + }; +} +var B; +(function(n) { + n[n.OPTION = 0] = "OPTION", n[n.REPETITION = 1] = "REPETITION", n[n.REPETITION_MANDATORY = 2] = "REPETITION_MANDATORY", n[n.REPETITION_MANDATORY_WITH_SEPARATOR = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR", n[n.REPETITION_WITH_SEPARATOR = 4] = "REPETITION_WITH_SEPARATOR", n[n.ALTERNATION = 5] = "ALTERNATION"; +})(B || (B = {})); +function Xs(n) { + if (n instanceof te || n === "Option") + return B.OPTION; + if (n instanceof W || n === "Repetition") + return B.REPETITION; + if (n instanceof $e || n === "RepetitionMandatory") + return B.REPETITION_MANDATORY; + if (n instanceof Se || n === "RepetitionMandatoryWithSeparator") + return B.REPETITION_MANDATORY_WITH_SEPARATOR; + if (n instanceof me || n === "RepetitionWithSeparator") + return B.REPETITION_WITH_SEPARATOR; + if (n instanceof ge || n === "Alternation") + return B.ALTERNATION; + throw Error("non exhaustive match"); +} +function Ga(n) { + const { occurrence: e, rule: t, prodType: r, maxLookahead: i } = n, s = Xs(r); + return s === B.ALTERNATION ? mi(e, t, i) : gi(e, t, s, i); +} +function hh(n, e, t, r, i, s) { + const a = mi(n, e, t), o = dc(a) ? Vr : er; + return s(a, r, o, i); +} +function ph(n, e, t, r, i, s) { + const a = gi(n, e, i, t), o = dc(a) ? Vr : er; + return s(a[0], o, r); +} +function mh(n, e, t, r) { + const i = n.length, s = be(n, (a) => be(a, (o) => o.length === 1)); + if (e) + return function(a) { + const o = $(a, (l) => l.GATE); + for (let l = 0; l < i; l++) { + const c = n[l], u = c.length, d = o[l]; + if (!(d !== void 0 && d.call(this) === !1)) + e: for (let h = 0; h < u; h++) { + const f = c[h], m = f.length; + for (let g = 0; g < m; g++) { + const v = this.LA(g + 1); + if (t(v, f[g]) === !1) + continue e; + } + return l; + } + } + }; + if (s && !r) { + const a = $(n, (l) => Ce(l)), o = oe(a, (l, c, u) => (N(c, (d) => { + C(l, d.tokenTypeIdx) || (l[d.tokenTypeIdx] = u), N(d.categoryMatches, (h) => { + C(l, h) || (l[h] = u); + }); + }), l), {}); + return function() { + const l = this.LA(1); + return o[l.tokenTypeIdx]; + }; + } else + return function() { + for (let a = 0; a < i; a++) { + const o = n[a], l = o.length; + e: for (let c = 0; c < l; c++) { + const u = o[c], d = u.length; + for (let h = 0; h < d; h++) { + const f = this.LA(h + 1); + if (t(f, u[h]) === !1) + continue e; + } + return a; + } + } + }; +} +function gh(n, e, t) { + const r = be(n, (s) => s.length === 1), i = n.length; + if (r && !t) { + const s = Ce(n); + if (s.length === 1 && D(s[0].categoryMatches)) { + const o = s[0].tokenTypeIdx; + return function() { + return this.LA(1).tokenTypeIdx === o; + }; + } else { + const a = oe(s, (o, l, c) => (o[l.tokenTypeIdx] = !0, N(l.categoryMatches, (u) => { + o[u] = !0; + }), o), []); + return function() { + const o = this.LA(1); + return a[o.tokenTypeIdx] === !0; + }; + } + } else + return function() { + e: for (let s = 0; s < i; s++) { + const a = n[s], o = a.length; + for (let l = 0; l < o; l++) { + const c = this.LA(l + 1); + if (e(c, a[l]) === !1) + continue e; + } + return !0; + } + return !1; + }; +} +class yh extends fi { + constructor(e, t, r) { + super(), this.topProd = e, this.targetOccurrence = t, this.targetProdType = r; + } + startWalking() { + return this.walk(this.topProd), this.restDef; + } + checkIsTarget(e, t, r, i) { + return e.idx === this.targetOccurrence && this.targetProdType === t ? (this.restDef = r.concat(i), !0) : !1; + } + walkOption(e, t, r) { + this.checkIsTarget(e, B.OPTION, t, r) || super.walkOption(e, t, r); + } + walkAtLeastOne(e, t, r) { + this.checkIsTarget(e, B.REPETITION_MANDATORY, t, r) || super.walkOption(e, t, r); + } + walkAtLeastOneSep(e, t, r) { + this.checkIsTarget(e, B.REPETITION_MANDATORY_WITH_SEPARATOR, t, r) || super.walkOption(e, t, r); + } + walkMany(e, t, r) { + this.checkIsTarget(e, B.REPETITION, t, r) || super.walkOption(e, t, r); + } + walkManySep(e, t, r) { + this.checkIsTarget(e, B.REPETITION_WITH_SEPARATOR, t, r) || super.walkOption(e, t, r); + } +} +class cc extends en { + constructor(e, t, r) { + super(), this.targetOccurrence = e, this.targetProdType = t, this.targetRef = r, this.result = []; + } + checkIsTarget(e, t) { + e.idx === this.targetOccurrence && this.targetProdType === t && (this.targetRef === void 0 || e === this.targetRef) && (this.result = e.definition); + } + visitOption(e) { + this.checkIsTarget(e, B.OPTION); + } + visitRepetition(e) { + this.checkIsTarget(e, B.REPETITION); + } + visitRepetitionMandatory(e) { + this.checkIsTarget(e, B.REPETITION_MANDATORY); + } + visitRepetitionMandatoryWithSeparator(e) { + this.checkIsTarget(e, B.REPETITION_MANDATORY_WITH_SEPARATOR); + } + visitRepetitionWithSeparator(e) { + this.checkIsTarget(e, B.REPETITION_WITH_SEPARATOR); + } + visitAlternation(e) { + this.checkIsTarget(e, B.ALTERNATION); + } +} +function Ua(n) { + const e = new Array(n); + for (let t = 0; t < n; t++) + e[t] = []; + return e; +} +function Oi(n) { + let e = [""]; + for (let t = 0; t < n.length; t++) { + const r = n[t], i = []; + for (let s = 0; s < e.length; s++) { + const a = e[s]; + i.push(a + "_" + r.tokenTypeIdx); + for (let o = 0; o < r.categoryMatches.length; o++) { + const l = "_" + r.categoryMatches[o]; + i.push(a + l); + } + } + e = i; + } + return e; +} +function Th(n, e, t) { + for (let r = 0; r < n.length; r++) { + if (r === t) + continue; + const i = n[r]; + for (let s = 0; s < e.length; s++) { + const a = e[s]; + if (i[a] === !0) + return !1; + } + } + return !0; +} +function uc(n, e) { + const t = $(n, (a) => ss([a], 1)), r = Ua(t.length), i = $(t, (a) => { + const o = {}; + return N(a, (l) => { + const c = Oi(l.partialPath); + N(c, (u) => { + o[u] = !0; + }); + }), o; + }); + let s = t; + for (let a = 1; a <= e; a++) { + const o = s; + s = Ua(o.length); + for (let l = 0; l < o.length; l++) { + const c = o[l]; + for (let u = 0; u < c.length; u++) { + const d = c[u].partialPath, h = c[u].suffixDef, f = Oi(d); + if (Th(i, f, l) || D(h) || d.length === e) { + const g = r[l]; + if (as(g, d) === !1) { + g.push(d); + for (let v = 0; v < f.length; v++) { + const y = f[v]; + i[l][y] = !0; + } + } + } else { + const g = ss(h, a + 1, d); + s[l] = s[l].concat(g), N(g, (v) => { + const y = Oi(v.partialPath); + N(y, (A) => { + i[l][A] = !0; + }); + }); + } + } + } + } + return r; +} +function mi(n, e, t, r) { + const i = new cc(n, B.ALTERNATION, r); + return e.accept(i), uc(i.result, t); +} +function gi(n, e, t, r) { + const i = new cc(n, t); + e.accept(i); + const s = i.result, o = new yh(e, n, t).startWalking(), l = new he({ definition: s }), c = new he({ definition: o }); + return uc([l, c], r); +} +function as(n, e) { + e: for (let t = 0; t < n.length; t++) { + const r = n[t]; + if (r.length === e.length) { + for (let i = 0; i < r.length; i++) { + const s = e[i], a = r[i]; + if ((s === a || a.categoryMatchesMap[s.tokenTypeIdx] !== void 0) === !1) + continue e; + } + return !0; + } + } + return !1; +} +function Rh(n, e) { + return n.length < e.length && be(n, (t, r) => { + const i = e[r]; + return t === i || i.categoryMatchesMap[t.tokenTypeIdx]; + }); +} +function dc(n) { + return be(n, (e) => be(e, (t) => be(t, (r) => D(r.categoryMatches)))); +} +function vh(n) { + const e = n.lookaheadStrategy.validate({ + rules: n.rules, + tokenTypes: n.tokenTypes, + grammarName: n.grammarName + }); + return $(e, (t) => Object.assign({ type: ce.CUSTOM_LOOKAHEAD_VALIDATION }, t)); +} +function Ah(n, e, t, r) { + const i = Ee(n, (l) => Eh(l, t)), s = bh(n, e, t), a = Ee(n, (l) => wh(l, t)), o = Ee(n, (l) => $h(l, n, r, t)); + return i.concat(s, a, o); +} +function Eh(n, e) { + const t = new xh(); + n.accept(t); + const r = t.allProductions, i = Zu(r, kh), s = Me(i, (o) => o.length > 1); + return $(z(s), (o) => { + const l = Pe(o), c = e.buildDuplicateFoundError(n, o), u = Fe(l), d = { + message: c, + type: ce.DUPLICATE_PRODUCTIONS, + ruleName: n.name, + dslName: u, + occurrence: l.idx + }, h = fc(l); + return h && (d.parameter = h), d; + }); +} +function kh(n) { + return `${Fe(n)}_#_${n.idx}_#_${fc(n)}`; +} +function fc(n) { + return n instanceof G ? n.terminalType.name : n instanceof le ? n.nonTerminalName : ""; +} +class xh extends en { + constructor() { + super(...arguments), this.allProductions = []; + } + visitNonTerminal(e) { + this.allProductions.push(e); + } + visitOption(e) { + this.allProductions.push(e); + } + visitRepetitionWithSeparator(e) { + this.allProductions.push(e); + } + visitRepetitionMandatory(e) { + this.allProductions.push(e); + } + visitRepetitionMandatoryWithSeparator(e) { + this.allProductions.push(e); + } + visitRepetition(e) { + this.allProductions.push(e); + } + visitAlternation(e) { + this.allProductions.push(e); + } + visitTerminal(e) { + this.allProductions.push(e); + } +} +function $h(n, e, t, r) { + const i = []; + if (oe(e, (a, o) => o.name === n.name ? a + 1 : a, 0) > 1) { + const a = r.buildDuplicateRuleNameError({ + topLevelRule: n, + grammarName: t + }); + i.push({ + message: a, + type: ce.DUPLICATE_RULE_NAME, + ruleName: n.name + }); + } + return i; +} +function Sh(n, e, t) { + const r = []; + let i; + return ue(e, n) || (i = `Invalid rule override, rule: ->${n}<- cannot be overridden in the grammar: ->${t}<-as it is not defined in any of the super grammars `, r.push({ + message: i, + type: ce.INVALID_RULE_OVERRIDE, + ruleName: n + })), r; +} +function hc(n, e, t, r = []) { + const i = [], s = Ir(e.definition); + if (D(s)) + return []; + { + const a = n.name; + ue(s, n) && i.push({ + message: t.buildLeftRecursionError({ + topLevelRule: n, + leftRecursionPath: r + }), + type: ce.LEFT_RECURSION, + ruleName: a + }); + const l = ai(s, r.concat([n])), c = Ee(l, (u) => { + const d = ne(r); + return d.push(u), hc(n, u, t, d); + }); + return i.concat(c); + } +} +function Ir(n) { + let e = []; + if (D(n)) + return e; + const t = Pe(n); + if (t instanceof le) + e.push(t.referencedRule); + else if (t instanceof he || t instanceof te || t instanceof $e || t instanceof Se || t instanceof me || t instanceof W) + e = e.concat(Ir(t.definition)); + else if (t instanceof ge) + e = Ce($(t.definition, (s) => Ir(s.definition))); + else if (!(t instanceof G)) throw Error("non exhaustive match"); + const r = Ur(t), i = n.length > 1; + if (r && i) { + const s = J(n); + return e.concat(Ir(s)); + } else + return e; +} +class Js extends en { + constructor() { + super(...arguments), this.alternations = []; + } + visitAlternation(e) { + this.alternations.push(e); + } +} +function Ih(n, e) { + const t = new Js(); + n.accept(t); + const r = t.alternations; + return Ee(r, (s) => { + const a = jn(s.definition); + return Ee(a, (o, l) => { + const c = lc([o], [], er, 1); + return D(c) ? [ + { + message: e.buildEmptyAlternationError({ + topLevelRule: n, + alternation: s, + emptyChoiceIdx: l + }), + type: ce.NONE_LAST_EMPTY_ALT, + ruleName: n.name, + occurrence: s.idx, + alternative: l + 1 + } + ] : []; + }); + }); +} +function Nh(n, e, t) { + const r = new Js(); + n.accept(r); + let i = r.alternations; + return i = oi(i, (a) => a.ignoreAmbiguities === !0), Ee(i, (a) => { + const o = a.idx, l = a.maxLookahead || e, c = mi(o, n, l, a), u = Lh(c, a, n, t), d = Oh(c, a, n, t); + return u.concat(d); + }); +} +class Ch extends en { + constructor() { + super(...arguments), this.allProductions = []; + } + visitRepetitionWithSeparator(e) { + this.allProductions.push(e); + } + visitRepetitionMandatory(e) { + this.allProductions.push(e); + } + visitRepetitionMandatoryWithSeparator(e) { + this.allProductions.push(e); + } + visitRepetition(e) { + this.allProductions.push(e); + } +} +function wh(n, e) { + const t = new Js(); + n.accept(t); + const r = t.alternations; + return Ee(r, (s) => s.definition.length > 255 ? [ + { + message: e.buildTooManyAlternativesError({ + topLevelRule: n, + alternation: s + }), + type: ce.TOO_MANY_ALTS, + ruleName: n.name, + occurrence: s.idx + } + ] : []); +} +function _h(n, e, t) { + const r = []; + return N(n, (i) => { + const s = new Ch(); + i.accept(s); + const a = s.allProductions; + N(a, (o) => { + const l = Xs(o), c = o.maxLookahead || e, u = o.idx, h = gi(u, i, l, c)[0]; + if (D(Ce(h))) { + const f = t.buildEmptyRepetitionError({ + topLevelRule: i, + repetition: o + }); + r.push({ + message: f, + type: ce.NO_NON_EMPTY_LOOKAHEAD, + ruleName: i.name + }); + } + }); + }), r; +} +function Lh(n, e, t, r) { + const i = [], s = oe(n, (o, l, c) => (e.definition[c].ignoreAmbiguities === !0 || N(l, (u) => { + const d = [c]; + N(n, (h, f) => { + c !== f && as(h, u) && // ignore (skip) ambiguities with this "other" alternative + e.definition[f].ignoreAmbiguities !== !0 && d.push(f); + }), d.length > 1 && !as(i, u) && (i.push(u), o.push({ + alts: d, + path: u + })); + }), o), []); + return $(s, (o) => { + const l = $(o.alts, (u) => u + 1); + return { + message: r.buildAlternationAmbiguityError({ + topLevelRule: t, + alternation: e, + ambiguityIndices: l, + prefixPath: o.path + }), + type: ce.AMBIGUOUS_ALTS, + ruleName: t.name, + occurrence: e.idx, + alternatives: o.alts + }; + }); +} +function Oh(n, e, t, r) { + const i = oe(n, (a, o, l) => { + const c = $(o, (u) => ({ idx: l, path: u })); + return a.concat(c); + }, []); + return Xn(Ee(i, (a) => { + if (e.definition[a.idx].ignoreAmbiguities === !0) + return []; + const l = a.idx, c = a.path, u = xe(i, (h) => ( + // ignore (skip) ambiguities with this "other" alternative + e.definition[h.idx].ignoreAmbiguities !== !0 && h.idx < l && // checking for strict prefix because identical lookaheads + // will be be detected using a different validation. + Rh(h.path, c) + )); + return $(u, (h) => { + const f = [h.idx + 1, l + 1], m = e.idx === 0 ? "" : e.idx; + return { + message: r.buildAlternationPrefixAmbiguityError({ + topLevelRule: t, + alternation: e, + ambiguityIndices: f, + prefixPath: h.path + }), + type: ce.AMBIGUOUS_PREFIX_ALTS, + ruleName: t.name, + occurrence: m, + alternatives: f + }; + }); + })); +} +function bh(n, e, t) { + const r = [], i = $(e, (s) => s.name); + return N(n, (s) => { + const a = s.name; + if (ue(i, a)) { + const o = t.buildNamespaceConflictError(s); + r.push({ + message: o, + type: ce.CONFLICT_TOKENS_RULES_NAMESPACE, + ruleName: a + }); + } + }), r; +} +function Ph(n) { + const e = Ds(n, { + errMsgProvider: sh + }), t = {}; + return N(n.rules, (r) => { + t[r.name] = r; + }), ah(t, e.errMsgProvider); +} +function Mh(n) { + return n = Ds(n, { + errMsgProvider: ct + }), Ah(n.rules, n.tokenTypes, n.errMsgProvider, n.grammarName); +} +const pc = "MismatchedTokenException", mc = "NoViableAltException", gc = "EarlyExitException", yc = "NotAllInputParsedException", Tc = [ + pc, + mc, + gc, + yc +]; +Object.freeze(Tc); +function Kr(n) { + return ue(Tc, n.name); +} +class yi extends Error { + constructor(e, t) { + super(e), this.token = t, this.resyncedTokens = [], Object.setPrototypeOf(this, new.target.prototype), Error.captureStackTrace && Error.captureStackTrace(this, this.constructor); + } +} +class Rc extends yi { + constructor(e, t, r) { + super(e, t), this.previousToken = r, this.name = pc; + } +} +class Dh extends yi { + constructor(e, t, r) { + super(e, t), this.previousToken = r, this.name = mc; + } +} +class Fh extends yi { + constructor(e, t) { + super(e, t), this.name = yc; + } +} +class Gh extends yi { + constructor(e, t, r) { + super(e, t), this.previousToken = r, this.name = gc; + } +} +const bi = {}, vc = "InRuleRecoveryException"; +class Uh extends Error { + constructor(e) { + super(e), this.name = vc; + } +} +class Bh { + initRecoverable(e) { + this.firstAfterRepMap = {}, this.resyncFollows = {}, this.recoveryEnabled = C(e, "recoveryEnabled") ? e.recoveryEnabled : Xe.recoveryEnabled, this.recoveryEnabled && (this.attemptInRepetitionRecovery = Vh); + } + getTokenToInsert(e) { + const t = Ys(e, "", NaN, NaN, NaN, NaN, NaN, NaN); + return t.isInsertedInRecovery = !0, t; + } + canTokenTypeBeInsertedInRecovery(e) { + return !0; + } + canTokenTypeBeDeletedInRecovery(e) { + return !0; + } + tryInRepetitionRecovery(e, t, r, i) { + const s = this.findReSyncTokenType(), a = this.exportLexerState(), o = []; + let l = !1; + const c = this.LA(1); + let u = this.LA(1); + const d = () => { + const h = this.LA(0), f = this.errorMessageProvider.buildMismatchTokenMessage({ + expected: i, + actual: c, + previous: h, + ruleName: this.getCurrRuleFullName() + }), m = new Rc(f, c, this.LA(0)); + m.resyncedTokens = jn(o), this.SAVE_ERROR(m); + }; + for (; !l; ) + if (this.tokenMatcher(u, i)) { + d(); + return; + } else if (r.call(this)) { + d(), e.apply(this, t); + return; + } else this.tokenMatcher(u, s) ? l = !0 : (u = this.SKIP_TOKEN(), this.addToResyncTokens(u, o)); + this.importLexerState(a); + } + shouldInRepetitionRecoveryBeTried(e, t, r) { + return !(r === !1 || this.tokenMatcher(this.LA(1), e) || this.isBackTracking() || this.canPerformInRuleRecovery(e, this.getFollowsForInRuleRecovery(e, t))); + } + // Error Recovery functionality + getFollowsForInRuleRecovery(e, t) { + const r = this.getCurrentGrammarPath(e, t); + return this.getNextPossibleTokenTypes(r); + } + tryInRuleRecovery(e, t) { + if (this.canRecoverWithSingleTokenInsertion(e, t)) + return this.getTokenToInsert(e); + if (this.canRecoverWithSingleTokenDeletion(e)) { + const r = this.SKIP_TOKEN(); + return this.consumeToken(), r; + } + throw new Uh("sad sad panda"); + } + canPerformInRuleRecovery(e, t) { + return this.canRecoverWithSingleTokenInsertion(e, t) || this.canRecoverWithSingleTokenDeletion(e); + } + canRecoverWithSingleTokenInsertion(e, t) { + if (!this.canTokenTypeBeInsertedInRecovery(e) || D(t)) + return !1; + const r = this.LA(1); + return Wt(t, (s) => this.tokenMatcher(r, s)) !== void 0; + } + canRecoverWithSingleTokenDeletion(e) { + return this.canTokenTypeBeDeletedInRecovery(e) ? this.tokenMatcher(this.LA(2), e) : !1; + } + isInCurrentRuleReSyncSet(e) { + const t = this.getCurrFollowKey(), r = this.getFollowSetFromFollowKey(t); + return ue(r, e); + } + findReSyncTokenType() { + const e = this.flattenFollowSet(); + let t = this.LA(1), r = 2; + for (; ; ) { + const i = Wt(e, (s) => oc(t, s)); + if (i !== void 0) + return i; + t = this.LA(r), r++; + } + } + getCurrFollowKey() { + if (this.RULE_STACK.length === 1) + return bi; + const e = this.getLastExplicitRuleShortName(), t = this.getLastExplicitRuleOccurrenceIndex(), r = this.getPreviousExplicitRuleShortName(); + return { + ruleName: this.shortRuleNameToFullName(e), + idxInCallingRule: t, + inRule: this.shortRuleNameToFullName(r) + }; + } + buildFullFollowKeyStack() { + const e = this.RULE_STACK, t = this.RULE_OCCURRENCE_STACK; + return $(e, (r, i) => i === 0 ? bi : { + ruleName: this.shortRuleNameToFullName(r), + idxInCallingRule: t[i], + inRule: this.shortRuleNameToFullName(e[i - 1]) + }); + } + flattenFollowSet() { + const e = $(this.buildFullFollowKeyStack(), (t) => this.getFollowSetFromFollowKey(t)); + return Ce(e); + } + getFollowSetFromFollowKey(e) { + if (e === bi) + return [nt]; + const t = e.ruleName + e.idxInCallingRule + Xl + e.inRule; + return this.resyncFollows[t]; + } + // It does not make any sense to include a virtual EOF token in the list of resynced tokens + // as EOF does not really exist and thus does not contain any useful information (line/column numbers) + addToResyncTokens(e, t) { + return this.tokenMatcher(e, nt) || t.push(e), t; + } + reSyncTo(e) { + const t = []; + let r = this.LA(1); + for (; this.tokenMatcher(r, e) === !1; ) + r = this.SKIP_TOKEN(), this.addToResyncTokens(r, t); + return jn(t); + } + attemptInRepetitionRecovery(e, t, r, i, s, a, o) { + } + getCurrentGrammarPath(e, t) { + const r = this.getHumanReadableRuleStack(), i = ne(this.RULE_OCCURRENCE_STACK); + return { + ruleStack: r, + occurrenceStack: i, + lastTok: e, + lastTokOccurrence: t + }; + } + getHumanReadableRuleStack() { + return $(this.RULE_STACK, (e) => this.shortRuleNameToFullName(e)); + } +} +function Vh(n, e, t, r, i, s, a) { + const o = this.getKeyForAutomaticLookahead(r, i); + let l = this.firstAfterRepMap[o]; + if (l === void 0) { + const h = this.getCurrRuleFullName(), f = this.getGAstProductions()[h]; + l = new s(f, i).startWalking(), this.firstAfterRepMap[o] = l; + } + let c = l.token, u = l.occurrence; + const d = l.isEndOfRule; + this.RULE_STACK.length === 1 && d && c === void 0 && (c = nt, u = 1), !(c === void 0 || u === void 0) && this.shouldInRepetitionRecoveryBeTried(c, u, a) && this.tryInRepetitionRecovery(n, e, t, c); +} +const Kh = 4, st = 8, Ac = 1 << st, Ec = 2 << st, os = 3 << st, ls = 4 << st, cs = 5 << st, Nr = 6 << st; +function Pi(n, e, t) { + return t | e | n; +} +class Qs { + constructor(e) { + var t; + this.maxLookahead = (t = e == null ? void 0 : e.maxLookahead) !== null && t !== void 0 ? t : Xe.maxLookahead; + } + validate(e) { + const t = this.validateNoLeftRecursion(e.rules); + if (D(t)) { + const r = this.validateEmptyOrAlternatives(e.rules), i = this.validateAmbiguousAlternationAlternatives(e.rules, this.maxLookahead), s = this.validateSomeNonEmptyLookaheadPath(e.rules, this.maxLookahead); + return [ + ...t, + ...r, + ...i, + ...s + ]; + } + return t; + } + validateNoLeftRecursion(e) { + return Ee(e, (t) => hc(t, t, ct)); + } + validateEmptyOrAlternatives(e) { + return Ee(e, (t) => Ih(t, ct)); + } + validateAmbiguousAlternationAlternatives(e, t) { + return Ee(e, (r) => Nh(r, t, ct)); + } + validateSomeNonEmptyLookaheadPath(e, t) { + return _h(e, t, ct); + } + buildLookaheadForAlternation(e) { + return hh(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, mh); + } + buildLookaheadForOptional(e) { + return ph(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, Xs(e.prodType), gh); + } +} +class Wh { + initLooksAhead(e) { + this.dynamicTokensEnabled = C(e, "dynamicTokensEnabled") ? e.dynamicTokensEnabled : Xe.dynamicTokensEnabled, this.maxLookahead = C(e, "maxLookahead") ? e.maxLookahead : Xe.maxLookahead, this.lookaheadStrategy = C(e, "lookaheadStrategy") ? e.lookaheadStrategy : new Qs({ maxLookahead: this.maxLookahead }), this.lookAheadFuncsCache = /* @__PURE__ */ new Map(); + } + preComputeLookaheadFunctions(e) { + N(e, (t) => { + this.TRACE_INIT(`${t.name} Rule Lookahead`, () => { + const { alternation: r, repetition: i, option: s, repetitionMandatory: a, repetitionMandatoryWithSeparator: o, repetitionWithSeparator: l } = Hh(t); + N(r, (c) => { + const u = c.idx === 0 ? "" : c.idx; + this.TRACE_INIT(`${Fe(c)}${u}`, () => { + const d = this.lookaheadStrategy.buildLookaheadForAlternation({ + prodOccurrence: c.idx, + rule: t, + maxLookahead: c.maxLookahead || this.maxLookahead, + hasPredicates: c.hasPredicates, + dynamicTokensEnabled: this.dynamicTokensEnabled + }), h = Pi(this.fullRuleNameToShort[t.name], Ac, c.idx); + this.setLaFuncCache(h, d); + }); + }), N(i, (c) => { + this.computeLookaheadFunc(t, c.idx, os, "Repetition", c.maxLookahead, Fe(c)); + }), N(s, (c) => { + this.computeLookaheadFunc(t, c.idx, Ec, "Option", c.maxLookahead, Fe(c)); + }), N(a, (c) => { + this.computeLookaheadFunc(t, c.idx, ls, "RepetitionMandatory", c.maxLookahead, Fe(c)); + }), N(o, (c) => { + this.computeLookaheadFunc(t, c.idx, Nr, "RepetitionMandatoryWithSeparator", c.maxLookahead, Fe(c)); + }), N(l, (c) => { + this.computeLookaheadFunc(t, c.idx, cs, "RepetitionWithSeparator", c.maxLookahead, Fe(c)); + }); + }); + }); + } + computeLookaheadFunc(e, t, r, i, s, a) { + this.TRACE_INIT(`${a}${t === 0 ? "" : t}`, () => { + const o = this.lookaheadStrategy.buildLookaheadForOptional({ + prodOccurrence: t, + rule: e, + maxLookahead: s || this.maxLookahead, + dynamicTokensEnabled: this.dynamicTokensEnabled, + prodType: i + }), l = Pi(this.fullRuleNameToShort[e.name], r, t); + this.setLaFuncCache(l, o); + }); + } + // this actually returns a number, but it is always used as a string (object prop key) + getKeyForAutomaticLookahead(e, t) { + const r = this.getLastExplicitRuleShortName(); + return Pi(r, e, t); + } + getLaFuncFromCache(e) { + return this.lookAheadFuncsCache.get(e); + } + /* istanbul ignore next */ + setLaFuncCache(e, t) { + this.lookAheadFuncsCache.set(e, t); + } +} +class jh extends en { + constructor() { + super(...arguments), this.dslMethods = { + option: [], + alternation: [], + repetition: [], + repetitionWithSeparator: [], + repetitionMandatory: [], + repetitionMandatoryWithSeparator: [] + }; + } + reset() { + this.dslMethods = { + option: [], + alternation: [], + repetition: [], + repetitionWithSeparator: [], + repetitionMandatory: [], + repetitionMandatoryWithSeparator: [] + }; + } + visitOption(e) { + this.dslMethods.option.push(e); + } + visitRepetitionWithSeparator(e) { + this.dslMethods.repetitionWithSeparator.push(e); + } + visitRepetitionMandatory(e) { + this.dslMethods.repetitionMandatory.push(e); + } + visitRepetitionMandatoryWithSeparator(e) { + this.dslMethods.repetitionMandatoryWithSeparator.push(e); + } + visitRepetition(e) { + this.dslMethods.repetition.push(e); + } + visitAlternation(e) { + this.dslMethods.alternation.push(e); + } +} +const yr = new jh(); +function Hh(n) { + yr.reset(), n.accept(yr); + const e = yr.dslMethods; + return yr.reset(), e; +} +function Ba(n, e) { + isNaN(n.startOffset) === !0 ? (n.startOffset = e.startOffset, n.endOffset = e.endOffset) : n.endOffset < e.endOffset && (n.endOffset = e.endOffset); +} +function Va(n, e) { + isNaN(n.startOffset) === !0 ? (n.startOffset = e.startOffset, n.startColumn = e.startColumn, n.startLine = e.startLine, n.endOffset = e.endOffset, n.endColumn = e.endColumn, n.endLine = e.endLine) : n.endOffset < e.endOffset && (n.endOffset = e.endOffset, n.endColumn = e.endColumn, n.endLine = e.endLine); +} +function zh(n, e, t) { + n.children[t] === void 0 ? n.children[t] = [e] : n.children[t].push(e); +} +function qh(n, e, t) { + n.children[e] === void 0 ? n.children[e] = [t] : n.children[e].push(t); +} +const Yh = "name"; +function kc(n, e) { + Object.defineProperty(n, Yh, { + enumerable: !1, + configurable: !0, + writable: !1, + value: e + }); +} +function Xh(n, e) { + const t = Kt(n), r = t.length; + for (let i = 0; i < r; i++) { + const s = t[i], a = n[s], o = a.length; + for (let l = 0; l < o; l++) { + const c = a[l]; + c.tokenTypeIdx === void 0 && this[c.name](c.children, e); + } + } +} +function Jh(n, e) { + const t = function() { + }; + kc(t, n + "BaseSemantics"); + const r = { + visit: function(i, s) { + if (ee(i) && (i = i[0]), !qe(i)) + return this[i.name](i.children, s); + }, + validateVisitor: function() { + const i = Zh(this, e); + if (!D(i)) { + const s = $(i, (a) => a.msg); + throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>: + ${s.join(` + +`).replace(/\n/g, ` + `)}`); + } + } + }; + return t.prototype = r, t.prototype.constructor = t, t._RULE_NAMES = e, t; +} +function Qh(n, e, t) { + const r = function() { + }; + kc(r, n + "BaseSemanticsWithDefaults"); + const i = Object.create(t.prototype); + return N(e, (s) => { + i[s] = Xh; + }), r.prototype = i, r.prototype.constructor = r, r; +} +var us; +(function(n) { + n[n.REDUNDANT_METHOD = 0] = "REDUNDANT_METHOD", n[n.MISSING_METHOD = 1] = "MISSING_METHOD"; +})(us || (us = {})); +function Zh(n, e) { + return ep(n, e); +} +function ep(n, e) { + const t = xe(e, (i) => gt(n[i]) === !1), r = $(t, (i) => ({ + msg: `Missing visitor method: <${i}> on ${n.constructor.name} CST Visitor.`, + type: us.MISSING_METHOD, + methodName: i + })); + return Xn(r); +} +class tp { + initTreeBuilder(e) { + if (this.CST_STACK = [], this.outputCst = e.outputCst, this.nodeLocationTracking = C(e, "nodeLocationTracking") ? e.nodeLocationTracking : Xe.nodeLocationTracking, !this.outputCst) + this.cstInvocationStateUpdate = Y, this.cstFinallyStateUpdate = Y, this.cstPostTerminal = Y, this.cstPostNonTerminal = Y, this.cstPostRule = Y; + else if (/full/i.test(this.nodeLocationTracking)) + this.recoveryEnabled ? (this.setNodeLocationFromToken = Va, this.setNodeLocationFromNode = Va, this.cstPostRule = Y, this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery) : (this.setNodeLocationFromToken = Y, this.setNodeLocationFromNode = Y, this.cstPostRule = this.cstPostRuleFull, this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular); + else if (/onlyOffset/i.test(this.nodeLocationTracking)) + this.recoveryEnabled ? (this.setNodeLocationFromToken = Ba, this.setNodeLocationFromNode = Ba, this.cstPostRule = Y, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRecovery) : (this.setNodeLocationFromToken = Y, this.setNodeLocationFromNode = Y, this.cstPostRule = this.cstPostRuleOnlyOffset, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRegular); + else if (/none/i.test(this.nodeLocationTracking)) + this.setNodeLocationFromToken = Y, this.setNodeLocationFromNode = Y, this.cstPostRule = Y, this.setInitialNodeLocation = Y; + else + throw Error(`Invalid config option: "${e.nodeLocationTracking}"`); + } + setInitialNodeLocationOnlyOffsetRecovery(e) { + e.location = { + startOffset: NaN, + endOffset: NaN + }; + } + setInitialNodeLocationOnlyOffsetRegular(e) { + e.location = { + // without error recovery the starting Location of a new CstNode is guaranteed + // To be the next Token's startOffset (for valid inputs). + // For invalid inputs there won't be any CSTOutput so this potential + // inaccuracy does not matter + startOffset: this.LA(1).startOffset, + endOffset: NaN + }; + } + setInitialNodeLocationFullRecovery(e) { + e.location = { + startOffset: NaN, + startLine: NaN, + startColumn: NaN, + endOffset: NaN, + endLine: NaN, + endColumn: NaN + }; + } + /** + * @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work + + * @param cstNode + */ + setInitialNodeLocationFullRegular(e) { + const t = this.LA(1); + e.location = { + startOffset: t.startOffset, + startLine: t.startLine, + startColumn: t.startColumn, + endOffset: NaN, + endLine: NaN, + endColumn: NaN + }; + } + cstInvocationStateUpdate(e) { + const t = { + name: e, + children: /* @__PURE__ */ Object.create(null) + }; + this.setInitialNodeLocation(t), this.CST_STACK.push(t); + } + cstFinallyStateUpdate() { + this.CST_STACK.pop(); + } + cstPostRuleFull(e) { + const t = this.LA(0), r = e.location; + r.startOffset <= t.startOffset ? (r.endOffset = t.endOffset, r.endLine = t.endLine, r.endColumn = t.endColumn) : (r.startOffset = NaN, r.startLine = NaN, r.startColumn = NaN); + } + cstPostRuleOnlyOffset(e) { + const t = this.LA(0), r = e.location; + r.startOffset <= t.startOffset ? r.endOffset = t.endOffset : r.startOffset = NaN; + } + cstPostTerminal(e, t) { + const r = this.CST_STACK[this.CST_STACK.length - 1]; + zh(r, t, e), this.setNodeLocationFromToken(r.location, t); + } + cstPostNonTerminal(e, t) { + const r = this.CST_STACK[this.CST_STACK.length - 1]; + qh(r, t, e), this.setNodeLocationFromNode(r.location, e.location); + } + getBaseCstVisitorConstructor() { + if (qe(this.baseCstVisitorConstructor)) { + const e = Jh(this.className, Kt(this.gastProductionsCache)); + return this.baseCstVisitorConstructor = e, e; + } + return this.baseCstVisitorConstructor; + } + getBaseCstVisitorConstructorWithDefaults() { + if (qe(this.baseCstVisitorWithDefaultsConstructor)) { + const e = Qh(this.className, Kt(this.gastProductionsCache), this.getBaseCstVisitorConstructor()); + return this.baseCstVisitorWithDefaultsConstructor = e, e; + } + return this.baseCstVisitorWithDefaultsConstructor; + } + getLastExplicitRuleShortName() { + const e = this.RULE_STACK; + return e[e.length - 1]; + } + getPreviousExplicitRuleShortName() { + const e = this.RULE_STACK; + return e[e.length - 2]; + } + getLastExplicitRuleOccurrenceIndex() { + const e = this.RULE_OCCURRENCE_STACK; + return e[e.length - 1]; + } +} +class np { + initLexerAdapter() { + this.tokVector = [], this.tokVectorLength = 0, this.currIdx = -1; + } + set input(e) { + if (this.selfAnalysisDone !== !0) + throw Error("Missing invocation at the end of the Parser's constructor."); + this.reset(), this.tokVector = e, this.tokVectorLength = e.length; + } + get input() { + return this.tokVector; + } + // skips a token and returns the next token + SKIP_TOKEN() { + return this.currIdx <= this.tokVector.length - 2 ? (this.consumeToken(), this.LA(1)) : jr; + } + // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers + // or lexers dependent on parser context. + LA(e) { + const t = this.currIdx + e; + return t < 0 || this.tokVectorLength <= t ? jr : this.tokVector[t]; + } + consumeToken() { + this.currIdx++; + } + exportLexerState() { + return this.currIdx; + } + importLexerState(e) { + this.currIdx = e; + } + resetLexerState() { + this.currIdx = -1; + } + moveToTerminatedState() { + this.currIdx = this.tokVector.length - 1; + } + getLexerPosition() { + return this.exportLexerState(); + } +} +class rp { + ACTION(e) { + return e.call(this); + } + consume(e, t, r) { + return this.consumeInternal(t, e, r); + } + subrule(e, t, r) { + return this.subruleInternal(t, e, r); + } + option(e, t) { + return this.optionInternal(t, e); + } + or(e, t) { + return this.orInternal(t, e); + } + many(e, t) { + return this.manyInternal(e, t); + } + atLeastOne(e, t) { + return this.atLeastOneInternal(e, t); + } + CONSUME(e, t) { + return this.consumeInternal(e, 0, t); + } + CONSUME1(e, t) { + return this.consumeInternal(e, 1, t); + } + CONSUME2(e, t) { + return this.consumeInternal(e, 2, t); + } + CONSUME3(e, t) { + return this.consumeInternal(e, 3, t); + } + CONSUME4(e, t) { + return this.consumeInternal(e, 4, t); + } + CONSUME5(e, t) { + return this.consumeInternal(e, 5, t); + } + CONSUME6(e, t) { + return this.consumeInternal(e, 6, t); + } + CONSUME7(e, t) { + return this.consumeInternal(e, 7, t); + } + CONSUME8(e, t) { + return this.consumeInternal(e, 8, t); + } + CONSUME9(e, t) { + return this.consumeInternal(e, 9, t); + } + SUBRULE(e, t) { + return this.subruleInternal(e, 0, t); + } + SUBRULE1(e, t) { + return this.subruleInternal(e, 1, t); + } + SUBRULE2(e, t) { + return this.subruleInternal(e, 2, t); + } + SUBRULE3(e, t) { + return this.subruleInternal(e, 3, t); + } + SUBRULE4(e, t) { + return this.subruleInternal(e, 4, t); + } + SUBRULE5(e, t) { + return this.subruleInternal(e, 5, t); + } + SUBRULE6(e, t) { + return this.subruleInternal(e, 6, t); + } + SUBRULE7(e, t) { + return this.subruleInternal(e, 7, t); + } + SUBRULE8(e, t) { + return this.subruleInternal(e, 8, t); + } + SUBRULE9(e, t) { + return this.subruleInternal(e, 9, t); + } + OPTION(e) { + return this.optionInternal(e, 0); + } + OPTION1(e) { + return this.optionInternal(e, 1); + } + OPTION2(e) { + return this.optionInternal(e, 2); + } + OPTION3(e) { + return this.optionInternal(e, 3); + } + OPTION4(e) { + return this.optionInternal(e, 4); + } + OPTION5(e) { + return this.optionInternal(e, 5); + } + OPTION6(e) { + return this.optionInternal(e, 6); + } + OPTION7(e) { + return this.optionInternal(e, 7); + } + OPTION8(e) { + return this.optionInternal(e, 8); + } + OPTION9(e) { + return this.optionInternal(e, 9); + } + OR(e) { + return this.orInternal(e, 0); + } + OR1(e) { + return this.orInternal(e, 1); + } + OR2(e) { + return this.orInternal(e, 2); + } + OR3(e) { + return this.orInternal(e, 3); + } + OR4(e) { + return this.orInternal(e, 4); + } + OR5(e) { + return this.orInternal(e, 5); + } + OR6(e) { + return this.orInternal(e, 6); + } + OR7(e) { + return this.orInternal(e, 7); + } + OR8(e) { + return this.orInternal(e, 8); + } + OR9(e) { + return this.orInternal(e, 9); + } + MANY(e) { + this.manyInternal(0, e); + } + MANY1(e) { + this.manyInternal(1, e); + } + MANY2(e) { + this.manyInternal(2, e); + } + MANY3(e) { + this.manyInternal(3, e); + } + MANY4(e) { + this.manyInternal(4, e); + } + MANY5(e) { + this.manyInternal(5, e); + } + MANY6(e) { + this.manyInternal(6, e); + } + MANY7(e) { + this.manyInternal(7, e); + } + MANY8(e) { + this.manyInternal(8, e); + } + MANY9(e) { + this.manyInternal(9, e); + } + MANY_SEP(e) { + this.manySepFirstInternal(0, e); + } + MANY_SEP1(e) { + this.manySepFirstInternal(1, e); + } + MANY_SEP2(e) { + this.manySepFirstInternal(2, e); + } + MANY_SEP3(e) { + this.manySepFirstInternal(3, e); + } + MANY_SEP4(e) { + this.manySepFirstInternal(4, e); + } + MANY_SEP5(e) { + this.manySepFirstInternal(5, e); + } + MANY_SEP6(e) { + this.manySepFirstInternal(6, e); + } + MANY_SEP7(e) { + this.manySepFirstInternal(7, e); + } + MANY_SEP8(e) { + this.manySepFirstInternal(8, e); + } + MANY_SEP9(e) { + this.manySepFirstInternal(9, e); + } + AT_LEAST_ONE(e) { + this.atLeastOneInternal(0, e); + } + AT_LEAST_ONE1(e) { + return this.atLeastOneInternal(1, e); + } + AT_LEAST_ONE2(e) { + this.atLeastOneInternal(2, e); + } + AT_LEAST_ONE3(e) { + this.atLeastOneInternal(3, e); + } + AT_LEAST_ONE4(e) { + this.atLeastOneInternal(4, e); + } + AT_LEAST_ONE5(e) { + this.atLeastOneInternal(5, e); + } + AT_LEAST_ONE6(e) { + this.atLeastOneInternal(6, e); + } + AT_LEAST_ONE7(e) { + this.atLeastOneInternal(7, e); + } + AT_LEAST_ONE8(e) { + this.atLeastOneInternal(8, e); + } + AT_LEAST_ONE9(e) { + this.atLeastOneInternal(9, e); + } + AT_LEAST_ONE_SEP(e) { + this.atLeastOneSepFirstInternal(0, e); + } + AT_LEAST_ONE_SEP1(e) { + this.atLeastOneSepFirstInternal(1, e); + } + AT_LEAST_ONE_SEP2(e) { + this.atLeastOneSepFirstInternal(2, e); + } + AT_LEAST_ONE_SEP3(e) { + this.atLeastOneSepFirstInternal(3, e); + } + AT_LEAST_ONE_SEP4(e) { + this.atLeastOneSepFirstInternal(4, e); + } + AT_LEAST_ONE_SEP5(e) { + this.atLeastOneSepFirstInternal(5, e); + } + AT_LEAST_ONE_SEP6(e) { + this.atLeastOneSepFirstInternal(6, e); + } + AT_LEAST_ONE_SEP7(e) { + this.atLeastOneSepFirstInternal(7, e); + } + AT_LEAST_ONE_SEP8(e) { + this.atLeastOneSepFirstInternal(8, e); + } + AT_LEAST_ONE_SEP9(e) { + this.atLeastOneSepFirstInternal(9, e); + } + RULE(e, t, r = Hr) { + if (ue(this.definedRulesNames, e)) { + const a = { + message: ct.buildDuplicateRuleNameError({ + topLevelRule: e, + grammarName: this.className + }), + type: ce.DUPLICATE_RULE_NAME, + ruleName: e + }; + this.definitionErrors.push(a); + } + this.definedRulesNames.push(e); + const i = this.defineRule(e, t, r); + return this[e] = i, i; + } + OVERRIDE_RULE(e, t, r = Hr) { + const i = Sh(e, this.definedRulesNames, this.className); + this.definitionErrors = this.definitionErrors.concat(i); + const s = this.defineRule(e, t, r); + return this[e] = s, s; + } + BACKTRACK(e, t) { + return function() { + this.isBackTrackingStack.push(1); + const r = this.saveRecogState(); + try { + return e.apply(this, t), !0; + } catch (i) { + if (Kr(i)) + return !1; + throw i; + } finally { + this.reloadRecogState(r), this.isBackTrackingStack.pop(); + } + }; + } + // GAST export APIs + getGAstProductions() { + return this.gastProductionsCache; + } + getSerializedGastProductions() { + return ff(z(this.gastProductionsCache)); + } +} +class ip { + initRecognizerEngine(e, t) { + if (this.className = this.constructor.name, this.shortRuleNameToFull = {}, this.fullRuleNameToShort = {}, this.ruleShortNameIdx = 256, this.tokenMatcher = Vr, this.subruleIdx = 0, this.definedRulesNames = [], this.tokensMap = {}, this.isBackTrackingStack = [], this.RULE_STACK = [], this.RULE_OCCURRENCE_STACK = [], this.gastProductionsCache = {}, C(t, "serializedGrammar")) + throw Error(`The Parser's configuration can no longer contain a property. + See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0 + For Further details.`); + if (ee(e)) { + if (D(e)) + throw Error(`A Token Vocabulary cannot be empty. + Note that the first argument for the parser constructor + is no longer a Token vector (since v4.0).`); + if (typeof e[0].startOffset == "number") + throw Error(`The Parser constructor no longer accepts a token vector as the first argument. + See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0 + For Further details.`); + } + if (ee(e)) + this.tokensMap = oe(e, (s, a) => (s[a.name] = a, s), {}); + else if (C(e, "modes") && be(Ce(z(e.modes)), nh)) { + const s = Ce(z(e.modes)), a = Fs(s); + this.tokensMap = oe(a, (o, l) => (o[l.name] = l, o), {}); + } else if (_u(e)) + this.tokensMap = ne(e); + else + throw new Error(" argument must be An Array of Token constructors, A dictionary of Token constructors or an IMultiModeLexerDefinition"); + this.tokensMap.EOF = nt; + const r = C(e, "modes") ? Ce(z(e.modes)) : z(e), i = be(r, (s) => D(s.categoryMatches)); + this.tokenMatcher = i ? Vr : er, tr(z(this.tokensMap)); + } + defineRule(e, t, r) { + if (this.selfAnalysisDone) + throw Error(`Grammar rule <${e}> may not be defined after the 'performSelfAnalysis' method has been called' +Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`); + const i = C(r, "resyncEnabled") ? r.resyncEnabled : Hr.resyncEnabled, s = C(r, "recoveryValueFunc") ? r.recoveryValueFunc : Hr.recoveryValueFunc, a = this.ruleShortNameIdx << Kh + st; + this.ruleShortNameIdx++, this.shortRuleNameToFull[a] = e, this.fullRuleNameToShort[e] = a; + let o; + return this.outputCst === !0 ? o = function(...u) { + try { + this.ruleInvocationStateUpdate(a, e, this.subruleIdx), t.apply(this, u); + const d = this.CST_STACK[this.CST_STACK.length - 1]; + return this.cstPostRule(d), d; + } catch (d) { + return this.invokeRuleCatch(d, i, s); + } finally { + this.ruleFinallyStateUpdate(); + } + } : o = function(...u) { + try { + return this.ruleInvocationStateUpdate(a, e, this.subruleIdx), t.apply(this, u); + } catch (d) { + return this.invokeRuleCatch(d, i, s); + } finally { + this.ruleFinallyStateUpdate(); + } + }, Object.assign(o, { ruleName: e, originalGrammarAction: t }); + } + invokeRuleCatch(e, t, r) { + const i = this.RULE_STACK.length === 1, s = t && !this.isBackTracking() && this.recoveryEnabled; + if (Kr(e)) { + const a = e; + if (s) { + const o = this.findReSyncTokenType(); + if (this.isInCurrentRuleReSyncSet(o)) + if (a.resyncedTokens = this.reSyncTo(o), this.outputCst) { + const l = this.CST_STACK[this.CST_STACK.length - 1]; + return l.recoveredNode = !0, l; + } else + return r(e); + else { + if (this.outputCst) { + const l = this.CST_STACK[this.CST_STACK.length - 1]; + l.recoveredNode = !0, a.partialCstResult = l; + } + throw a; + } + } else { + if (i) + return this.moveToTerminatedState(), r(e); + throw a; + } + } else + throw e; + } + // Implementation of parsing DSL + optionInternal(e, t) { + const r = this.getKeyForAutomaticLookahead(Ec, t); + return this.optionInternalLogic(e, t, r); + } + optionInternalLogic(e, t, r) { + let i = this.getLaFuncFromCache(r), s; + if (typeof e != "function") { + s = e.DEF; + const a = e.GATE; + if (a !== void 0) { + const o = i; + i = () => a.call(this) && o.call(this); + } + } else + s = e; + if (i.call(this) === !0) + return s.call(this); + } + atLeastOneInternal(e, t) { + const r = this.getKeyForAutomaticLookahead(ls, e); + return this.atLeastOneInternalLogic(e, t, r); + } + atLeastOneInternalLogic(e, t, r) { + let i = this.getLaFuncFromCache(r), s; + if (typeof t != "function") { + s = t.DEF; + const a = t.GATE; + if (a !== void 0) { + const o = i; + i = () => a.call(this) && o.call(this); + } + } else + s = t; + if (i.call(this) === !0) { + let a = this.doSingleRepetition(s); + for (; i.call(this) === !0 && a === !0; ) + a = this.doSingleRepetition(s); + } else + throw this.raiseEarlyExitException(e, B.REPETITION_MANDATORY, t.ERR_MSG); + this.attemptInRepetitionRecovery(this.atLeastOneInternal, [e, t], i, ls, e, dh); + } + atLeastOneSepFirstInternal(e, t) { + const r = this.getKeyForAutomaticLookahead(Nr, e); + this.atLeastOneSepFirstInternalLogic(e, t, r); + } + atLeastOneSepFirstInternalLogic(e, t, r) { + const i = t.DEF, s = t.SEP; + if (this.getLaFuncFromCache(r).call(this) === !0) { + i.call(this); + const o = () => this.tokenMatcher(this.LA(1), s); + for (; this.tokenMatcher(this.LA(1), s) === !0; ) + this.CONSUME(s), i.call(this); + this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [ + e, + s, + o, + i, + Fa + ], o, Nr, e, Fa); + } else + throw this.raiseEarlyExitException(e, B.REPETITION_MANDATORY_WITH_SEPARATOR, t.ERR_MSG); + } + manyInternal(e, t) { + const r = this.getKeyForAutomaticLookahead(os, e); + return this.manyInternalLogic(e, t, r); + } + manyInternalLogic(e, t, r) { + let i = this.getLaFuncFromCache(r), s; + if (typeof t != "function") { + s = t.DEF; + const o = t.GATE; + if (o !== void 0) { + const l = i; + i = () => o.call(this) && l.call(this); + } + } else + s = t; + let a = !0; + for (; i.call(this) === !0 && a === !0; ) + a = this.doSingleRepetition(s); + this.attemptInRepetitionRecovery( + this.manyInternal, + [e, t], + i, + os, + e, + uh, + // The notStuck parameter is only relevant when "attemptInRepetitionRecovery" + // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP] + // An infinite loop cannot occur as: + // - Either the lookahead is guaranteed to consume something (Single Token Separator) + // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out). + a + ); + } + manySepFirstInternal(e, t) { + const r = this.getKeyForAutomaticLookahead(cs, e); + this.manySepFirstInternalLogic(e, t, r); + } + manySepFirstInternalLogic(e, t, r) { + const i = t.DEF, s = t.SEP; + if (this.getLaFuncFromCache(r).call(this) === !0) { + i.call(this); + const o = () => this.tokenMatcher(this.LA(1), s); + for (; this.tokenMatcher(this.LA(1), s) === !0; ) + this.CONSUME(s), i.call(this); + this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [ + e, + s, + o, + i, + Da + ], o, cs, e, Da); + } + } + repetitionSepSecondInternal(e, t, r, i, s) { + for (; r(); ) + this.CONSUME(t), i.call(this); + this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [ + e, + t, + r, + i, + s + ], r, Nr, e, s); + } + doSingleRepetition(e) { + const t = this.getLexerPosition(); + return e.call(this), this.getLexerPosition() > t; + } + orInternal(e, t) { + const r = this.getKeyForAutomaticLookahead(Ac, t), i = ee(e) ? e : e.DEF, a = this.getLaFuncFromCache(r).call(this, i); + if (a !== void 0) + return i[a].ALT.call(this); + this.raiseNoAltException(t, e.ERR_MSG); + } + ruleFinallyStateUpdate() { + if (this.RULE_STACK.pop(), this.RULE_OCCURRENCE_STACK.pop(), this.cstFinallyStateUpdate(), this.RULE_STACK.length === 0 && this.isAtEndOfInput() === !1) { + const e = this.LA(1), t = this.errorMessageProvider.buildNotAllInputParsedMessage({ + firstRedundant: e, + ruleName: this.getCurrRuleFullName() + }); + this.SAVE_ERROR(new Fh(t, e)); + } + } + subruleInternal(e, t, r) { + let i; + try { + const s = r !== void 0 ? r.ARGS : void 0; + return this.subruleIdx = t, i = e.apply(this, s), this.cstPostNonTerminal(i, r !== void 0 && r.LABEL !== void 0 ? r.LABEL : e.ruleName), i; + } catch (s) { + throw this.subruleInternalError(s, r, e.ruleName); + } + } + subruleInternalError(e, t, r) { + throw Kr(e) && e.partialCstResult !== void 0 && (this.cstPostNonTerminal(e.partialCstResult, t !== void 0 && t.LABEL !== void 0 ? t.LABEL : r), delete e.partialCstResult), e; + } + consumeInternal(e, t, r) { + let i; + try { + const s = this.LA(1); + this.tokenMatcher(s, e) === !0 ? (this.consumeToken(), i = s) : this.consumeInternalError(e, s, r); + } catch (s) { + i = this.consumeInternalRecovery(e, t, s); + } + return this.cstPostTerminal(r !== void 0 && r.LABEL !== void 0 ? r.LABEL : e.name, i), i; + } + consumeInternalError(e, t, r) { + let i; + const s = this.LA(0); + throw r !== void 0 && r.ERR_MSG ? i = r.ERR_MSG : i = this.errorMessageProvider.buildMismatchTokenMessage({ + expected: e, + actual: t, + previous: s, + ruleName: this.getCurrRuleFullName() + }), this.SAVE_ERROR(new Rc(i, t, s)); + } + consumeInternalRecovery(e, t, r) { + if (this.recoveryEnabled && // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions? + r.name === "MismatchedTokenException" && !this.isBackTracking()) { + const i = this.getFollowsForInRuleRecovery(e, t); + try { + return this.tryInRuleRecovery(e, i); + } catch (s) { + throw s.name === vc ? r : s; + } + } else + throw r; + } + saveRecogState() { + const e = this.errors, t = ne(this.RULE_STACK); + return { + errors: e, + lexerState: this.exportLexerState(), + RULE_STACK: t, + CST_STACK: this.CST_STACK + }; + } + reloadRecogState(e) { + this.errors = e.errors, this.importLexerState(e.lexerState), this.RULE_STACK = e.RULE_STACK; + } + ruleInvocationStateUpdate(e, t, r) { + this.RULE_OCCURRENCE_STACK.push(r), this.RULE_STACK.push(e), this.cstInvocationStateUpdate(t); + } + isBackTracking() { + return this.isBackTrackingStack.length !== 0; + } + getCurrRuleFullName() { + const e = this.getLastExplicitRuleShortName(); + return this.shortRuleNameToFull[e]; + } + shortRuleNameToFullName(e) { + return this.shortRuleNameToFull[e]; + } + isAtEndOfInput() { + return this.tokenMatcher(this.LA(1), nt); + } + reset() { + this.resetLexerState(), this.subruleIdx = 0, this.isBackTrackingStack = [], this.errors = [], this.RULE_STACK = [], this.CST_STACK = [], this.RULE_OCCURRENCE_STACK = []; + } +} +class sp { + initErrorHandler(e) { + this._errors = [], this.errorMessageProvider = C(e, "errorMessageProvider") ? e.errorMessageProvider : Xe.errorMessageProvider; + } + SAVE_ERROR(e) { + if (Kr(e)) + return e.context = { + ruleStack: this.getHumanReadableRuleStack(), + ruleOccurrenceStack: ne(this.RULE_OCCURRENCE_STACK) + }, this._errors.push(e), e; + throw Error("Trying to save an Error which is not a RecognitionException"); + } + get errors() { + return ne(this._errors); + } + set errors(e) { + this._errors = e; + } + // TODO: consider caching the error message computed information + raiseEarlyExitException(e, t, r) { + const i = this.getCurrRuleFullName(), s = this.getGAstProductions()[i], o = gi(e, s, t, this.maxLookahead)[0], l = []; + for (let u = 1; u <= this.maxLookahead; u++) + l.push(this.LA(u)); + const c = this.errorMessageProvider.buildEarlyExitMessage({ + expectedIterationPaths: o, + actual: l, + previous: this.LA(0), + customUserDescription: r, + ruleName: i + }); + throw this.SAVE_ERROR(new Gh(c, this.LA(1), this.LA(0))); + } + // TODO: consider caching the error message computed information + raiseNoAltException(e, t) { + const r = this.getCurrRuleFullName(), i = this.getGAstProductions()[r], s = mi(e, i, this.maxLookahead), a = []; + for (let c = 1; c <= this.maxLookahead; c++) + a.push(this.LA(c)); + const o = this.LA(0), l = this.errorMessageProvider.buildNoViableAltMessage({ + expectedPathsPerAlt: s, + actual: a, + previous: o, + customUserDescription: t, + ruleName: this.getCurrRuleFullName() + }); + throw this.SAVE_ERROR(new Dh(l, this.LA(1), o)); + } +} +class ap { + initContentAssist() { + } + computeContentAssist(e, t) { + const r = this.gastProductionsCache[e]; + if (qe(r)) + throw Error(`Rule ->${e}<- does not exist in this grammar.`); + return lc([r], t, this.tokenMatcher, this.maxLookahead); + } + // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'... + // TODO: should this be more explicitly part of the public API? + getNextPossibleTokenTypes(e) { + const t = Pe(e.ruleStack), i = this.getGAstProductions()[t]; + return new ch(i, e).startWalking(); + } +} +const Ti = { + description: "This Object indicates the Parser is during Recording Phase" +}; +Object.freeze(Ti); +const Ka = !0, Wa = Math.pow(2, st) - 1, xc = ac({ name: "RECORDING_PHASE_TOKEN", pattern: de.NA }); +tr([xc]); +const $c = Ys( + xc, + `This IToken indicates the Parser is in Recording Phase + See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details`, + // Using "-1" instead of NaN (as in EOF) because an actual number is less likely to + // cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase. + -1, + -1, + -1, + -1, + -1, + -1 +); +Object.freeze($c); +const op = { + name: `This CSTNode indicates the Parser is in Recording Phase + See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details`, + children: {} +}; +class lp { + initGastRecorder(e) { + this.recordingProdStack = [], this.RECORDING_PHASE = !1; + } + enableRecording() { + this.RECORDING_PHASE = !0, this.TRACE_INIT("Enable Recording", () => { + for (let e = 0; e < 10; e++) { + const t = e > 0 ? e : ""; + this[`CONSUME${t}`] = function(r, i) { + return this.consumeInternalRecord(r, e, i); + }, this[`SUBRULE${t}`] = function(r, i) { + return this.subruleInternalRecord(r, e, i); + }, this[`OPTION${t}`] = function(r) { + return this.optionInternalRecord(r, e); + }, this[`OR${t}`] = function(r) { + return this.orInternalRecord(r, e); + }, this[`MANY${t}`] = function(r) { + this.manyInternalRecord(e, r); + }, this[`MANY_SEP${t}`] = function(r) { + this.manySepFirstInternalRecord(e, r); + }, this[`AT_LEAST_ONE${t}`] = function(r) { + this.atLeastOneInternalRecord(e, r); + }, this[`AT_LEAST_ONE_SEP${t}`] = function(r) { + this.atLeastOneSepFirstInternalRecord(e, r); + }; + } + this.consume = function(e, t, r) { + return this.consumeInternalRecord(t, e, r); + }, this.subrule = function(e, t, r) { + return this.subruleInternalRecord(t, e, r); + }, this.option = function(e, t) { + return this.optionInternalRecord(t, e); + }, this.or = function(e, t) { + return this.orInternalRecord(t, e); + }, this.many = function(e, t) { + this.manyInternalRecord(e, t); + }, this.atLeastOne = function(e, t) { + this.atLeastOneInternalRecord(e, t); + }, this.ACTION = this.ACTION_RECORD, this.BACKTRACK = this.BACKTRACK_RECORD, this.LA = this.LA_RECORD; + }); + } + disableRecording() { + this.RECORDING_PHASE = !1, this.TRACE_INIT("Deleting Recording methods", () => { + const e = this; + for (let t = 0; t < 10; t++) { + const r = t > 0 ? t : ""; + delete e[`CONSUME${r}`], delete e[`SUBRULE${r}`], delete e[`OPTION${r}`], delete e[`OR${r}`], delete e[`MANY${r}`], delete e[`MANY_SEP${r}`], delete e[`AT_LEAST_ONE${r}`], delete e[`AT_LEAST_ONE_SEP${r}`]; + } + delete e.consume, delete e.subrule, delete e.option, delete e.or, delete e.many, delete e.atLeastOne, delete e.ACTION, delete e.BACKTRACK, delete e.LA; + }); + } + // Parser methods are called inside an ACTION? + // Maybe try/catch/finally on ACTIONS while disabling the recorders state changes? + // @ts-expect-error -- noop place holder + ACTION_RECORD(e) { + } + // Executing backtracking logic will break our recording logic assumptions + BACKTRACK_RECORD(e, t) { + return () => !0; + } + // LA is part of the official API and may be used for custom lookahead logic + // by end users who may forget to wrap it in ACTION or inside a GATE + LA_RECORD(e) { + return jr; + } + topLevelRuleRecord(e, t) { + try { + const r = new Zt({ definition: [], name: e }); + return r.name = e, this.recordingProdStack.push(r), t.call(this), this.recordingProdStack.pop(), r; + } catch (r) { + if (r.KNOWN_RECORDER_ERROR !== !0) + try { + r.message = r.message + ` + This error was thrown during the "grammar recording phase" For more info see: + https://chevrotain.io/docs/guide/internals.html#grammar-recording`; + } catch { + throw r; + } + throw r; + } + } + // Implementation of parsing DSL + optionInternalRecord(e, t) { + return an.call(this, te, e, t); + } + atLeastOneInternalRecord(e, t) { + an.call(this, $e, t, e); + } + atLeastOneSepFirstInternalRecord(e, t) { + an.call(this, Se, t, e, Ka); + } + manyInternalRecord(e, t) { + an.call(this, W, t, e); + } + manySepFirstInternalRecord(e, t) { + an.call(this, me, t, e, Ka); + } + orInternalRecord(e, t) { + return cp.call(this, e, t); + } + subruleInternalRecord(e, t, r) { + if (Wr(t), !e || C(e, "ruleName") === !1) { + const o = new Error(` argument is invalid expecting a Parser method reference but got: <${JSON.stringify(e)}> + inside top level rule: <${this.recordingProdStack[0].name}>`); + throw o.KNOWN_RECORDER_ERROR = !0, o; + } + const i = jt(this.recordingProdStack), s = e.ruleName, a = new le({ + idx: t, + nonTerminalName: s, + label: r == null ? void 0 : r.LABEL, + // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created + referencedRule: void 0 + }); + return i.definition.push(a), this.outputCst ? op : Ti; + } + consumeInternalRecord(e, t, r) { + if (Wr(t), !ic(e)) { + const a = new Error(` argument is invalid expecting a TokenType reference but got: <${JSON.stringify(e)}> + inside top level rule: <${this.recordingProdStack[0].name}>`); + throw a.KNOWN_RECORDER_ERROR = !0, a; + } + const i = jt(this.recordingProdStack), s = new G({ + idx: t, + terminalType: e, + label: r == null ? void 0 : r.LABEL + }); + return i.definition.push(s), $c; + } +} +function an(n, e, t, r = !1) { + Wr(t); + const i = jt(this.recordingProdStack), s = gt(e) ? e : e.DEF, a = new n({ definition: [], idx: t }); + return r && (a.separator = e.SEP), C(e, "MAX_LOOKAHEAD") && (a.maxLookahead = e.MAX_LOOKAHEAD), this.recordingProdStack.push(a), s.call(this), i.definition.push(a), this.recordingProdStack.pop(), Ti; +} +function cp(n, e) { + Wr(e); + const t = jt(this.recordingProdStack), r = ee(n) === !1, i = r === !1 ? n : n.DEF, s = new ge({ + definition: [], + idx: e, + ignoreAmbiguities: r && n.IGNORE_AMBIGUITIES === !0 + }); + C(n, "MAX_LOOKAHEAD") && (s.maxLookahead = n.MAX_LOOKAHEAD); + const a = Sl(i, (o) => gt(o.GATE)); + return s.hasPredicates = a, t.definition.push(s), N(i, (o) => { + const l = new he({ definition: [] }); + s.definition.push(l), C(o, "IGNORE_AMBIGUITIES") ? l.ignoreAmbiguities = o.IGNORE_AMBIGUITIES : C(o, "GATE") && (l.ignoreAmbiguities = !0), this.recordingProdStack.push(l), o.ALT.call(this), this.recordingProdStack.pop(); + }), Ti; +} +function ja(n) { + return n === 0 ? "" : `${n}`; +} +function Wr(n) { + if (n < 0 || n > Wa) { + const e = new Error( + // The stack trace will contain all the needed details + `Invalid DSL Method idx value: <${n}> + Idx value must be a none negative value smaller than ${Wa + 1}` + ); + throw e.KNOWN_RECORDER_ERROR = !0, e; + } +} +class up { + initPerformanceTracer(e) { + if (C(e, "traceInitPerf")) { + const t = e.traceInitPerf, r = typeof t == "number"; + this.traceInitMaxIdent = r ? t : 1 / 0, this.traceInitPerf = r ? t > 0 : t; + } else + this.traceInitMaxIdent = 0, this.traceInitPerf = Xe.traceInitPerf; + this.traceInitIndent = -1; + } + TRACE_INIT(e, t) { + if (this.traceInitPerf === !0) { + this.traceInitIndent++; + const r = new Array(this.traceInitIndent + 1).join(" "); + this.traceInitIndent < this.traceInitMaxIdent && console.log(`${r}--> <${e}>`); + const { time: i, value: s } = ql(t), a = i > 10 ? console.warn : console.log; + return this.traceInitIndent < this.traceInitMaxIdent && a(`${r}<-- <${e}> time: ${i}ms`), this.traceInitIndent--, s; + } else + return t(); + } +} +function dp(n, e) { + e.forEach((t) => { + const r = t.prototype; + Object.getOwnPropertyNames(r).forEach((i) => { + if (i === "constructor") + return; + const s = Object.getOwnPropertyDescriptor(r, i); + s && (s.get || s.set) ? Object.defineProperty(n.prototype, i, s) : n.prototype[i] = t.prototype[i]; + }); + }); +} +const jr = Ys(nt, "", NaN, NaN, NaN, NaN, NaN, NaN); +Object.freeze(jr); +const Xe = Object.freeze({ + recoveryEnabled: !1, + maxLookahead: 3, + dynamicTokensEnabled: !1, + outputCst: !0, + errorMessageProvider: St, + nodeLocationTracking: "none", + traceInitPerf: !1, + skipValidations: !1 +}), Hr = Object.freeze({ + recoveryValueFunc: () => { + }, + resyncEnabled: !0 +}); +var ce; +(function(n) { + n[n.INVALID_RULE_NAME = 0] = "INVALID_RULE_NAME", n[n.DUPLICATE_RULE_NAME = 1] = "DUPLICATE_RULE_NAME", n[n.INVALID_RULE_OVERRIDE = 2] = "INVALID_RULE_OVERRIDE", n[n.DUPLICATE_PRODUCTIONS = 3] = "DUPLICATE_PRODUCTIONS", n[n.UNRESOLVED_SUBRULE_REF = 4] = "UNRESOLVED_SUBRULE_REF", n[n.LEFT_RECURSION = 5] = "LEFT_RECURSION", n[n.NONE_LAST_EMPTY_ALT = 6] = "NONE_LAST_EMPTY_ALT", n[n.AMBIGUOUS_ALTS = 7] = "AMBIGUOUS_ALTS", n[n.CONFLICT_TOKENS_RULES_NAMESPACE = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE", n[n.INVALID_TOKEN_NAME = 9] = "INVALID_TOKEN_NAME", n[n.NO_NON_EMPTY_LOOKAHEAD = 10] = "NO_NON_EMPTY_LOOKAHEAD", n[n.AMBIGUOUS_PREFIX_ALTS = 11] = "AMBIGUOUS_PREFIX_ALTS", n[n.TOO_MANY_ALTS = 12] = "TOO_MANY_ALTS", n[n.CUSTOM_LOOKAHEAD_VALIDATION = 13] = "CUSTOM_LOOKAHEAD_VALIDATION"; +})(ce || (ce = {})); +function Ha(n = void 0) { + return function() { + return n; + }; +} +class nr { + /** + * @deprecated use the **instance** method with the same name instead + */ + static performSelfAnalysis(e) { + throw Error("The **static** `performSelfAnalysis` method has been deprecated. \nUse the **instance** method with the same name instead."); + } + performSelfAnalysis() { + this.TRACE_INIT("performSelfAnalysis", () => { + let e; + this.selfAnalysisDone = !0; + const t = this.className; + this.TRACE_INIT("toFastProps", () => { + Yl(this); + }), this.TRACE_INIT("Grammar Recording", () => { + try { + this.enableRecording(), N(this.definedRulesNames, (i) => { + const a = this[i].originalGrammarAction; + let o; + this.TRACE_INIT(`${i} Rule`, () => { + o = this.topLevelRuleRecord(i, a); + }), this.gastProductionsCache[i] = o; + }); + } finally { + this.disableRecording(); + } + }); + let r = []; + if (this.TRACE_INIT("Grammar Resolving", () => { + r = Ph({ + rules: z(this.gastProductionsCache) + }), this.definitionErrors = this.definitionErrors.concat(r); + }), this.TRACE_INIT("Grammar Validations", () => { + if (D(r) && this.skipValidations === !1) { + const i = Mh({ + rules: z(this.gastProductionsCache), + tokenTypes: z(this.tokensMap), + errMsgProvider: ct, + grammarName: t + }), s = vh({ + lookaheadStrategy: this.lookaheadStrategy, + rules: z(this.gastProductionsCache), + tokenTypes: z(this.tokensMap), + grammarName: t + }); + this.definitionErrors = this.definitionErrors.concat(i, s); + } + }), D(this.definitionErrors) && (this.recoveryEnabled && this.TRACE_INIT("computeAllProdsFollows", () => { + const i = Rf(z(this.gastProductionsCache)); + this.resyncFollows = i; + }), this.TRACE_INIT("ComputeLookaheadFunctions", () => { + var i, s; + (s = (i = this.lookaheadStrategy).initialize) === null || s === void 0 || s.call(i, { + rules: z(this.gastProductionsCache) + }), this.preComputeLookaheadFunctions(z(this.gastProductionsCache)); + })), !nr.DEFER_DEFINITION_ERRORS_HANDLING && !D(this.definitionErrors)) + throw e = $(this.definitionErrors, (i) => i.message), new Error(`Parser Definition Errors detected: + ${e.join(` +------------------------------- +`)}`); + }); + } + constructor(e, t) { + this.definitionErrors = [], this.selfAnalysisDone = !1; + const r = this; + if (r.initErrorHandler(t), r.initLexerAdapter(), r.initLooksAhead(t), r.initRecognizerEngine(e, t), r.initRecoverable(t), r.initTreeBuilder(t), r.initContentAssist(), r.initGastRecorder(t), r.initPerformanceTracer(t), C(t, "ignoredIssues")) + throw new Error(`The IParserConfig property has been deprecated. + Please use the flag on the relevant DSL method instead. + See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES + For further details.`); + this.skipValidations = C(t, "skipValidations") ? t.skipValidations : Xe.skipValidations; + } +} +nr.DEFER_DEFINITION_ERRORS_HANDLING = !1; +dp(nr, [ + Bh, + Wh, + tp, + np, + ip, + rp, + sp, + ap, + lp, + up +]); +class fp extends nr { + constructor(e, t = Xe) { + const r = ne(t); + r.outputCst = !1, super(e, r); + } +} +function Ht(n, e, t) { + return `${n.name}_${e}_${t}`; +} +const rt = 1, hp = 2, Sc = 4, Ic = 5, rr = 7, pp = 8, mp = 9, gp = 10, yp = 11, Nc = 12; +class Zs { + constructor(e) { + this.target = e; + } + isEpsilon() { + return !1; + } +} +class ea extends Zs { + constructor(e, t) { + super(e), this.tokenType = t; + } +} +class Cc extends Zs { + constructor(e) { + super(e); + } + isEpsilon() { + return !0; + } +} +class ta extends Zs { + constructor(e, t, r) { + super(e), this.rule = t, this.followState = r; + } + isEpsilon() { + return !0; + } +} +function Tp(n) { + const e = { + decisionMap: {}, + decisionStates: [], + ruleToStartState: /* @__PURE__ */ new Map(), + ruleToStopState: /* @__PURE__ */ new Map(), + states: [] + }; + Rp(e, n); + const t = n.length; + for (let r = 0; r < t; r++) { + const i = n[r], s = Tt(e, i, i); + s !== void 0 && wp(e, i, s); + } + return e; +} +function Rp(n, e) { + const t = e.length; + for (let r = 0; r < t; r++) { + const i = e[r], s = X(n, i, void 0, { + type: hp + }), a = X(n, i, void 0, { + type: rr + }); + s.stop = a, n.ruleToStartState.set(i, s), n.ruleToStopState.set(i, a); + } +} +function wc(n, e, t) { + return t instanceof G ? na(n, e, t.terminalType, t) : t instanceof le ? Cp(n, e, t) : t instanceof ge ? xp(n, e, t) : t instanceof te ? $p(n, e, t) : t instanceof W ? vp(n, e, t) : t instanceof me ? Ap(n, e, t) : t instanceof $e ? Ep(n, e, t) : t instanceof Se ? kp(n, e, t) : Tt(n, e, t); +} +function vp(n, e, t) { + const r = X(n, e, t, { + type: Ic + }); + at(n, r); + const i = tn(n, e, r, t, Tt(n, e, t)); + return Lc(n, e, t, i); +} +function Ap(n, e, t) { + const r = X(n, e, t, { + type: Ic + }); + at(n, r); + const i = tn(n, e, r, t, Tt(n, e, t)), s = na(n, e, t.separator, t); + return Lc(n, e, t, i, s); +} +function Ep(n, e, t) { + const r = X(n, e, t, { + type: Sc + }); + at(n, r); + const i = tn(n, e, r, t, Tt(n, e, t)); + return _c(n, e, t, i); +} +function kp(n, e, t) { + const r = X(n, e, t, { + type: Sc + }); + at(n, r); + const i = tn(n, e, r, t, Tt(n, e, t)), s = na(n, e, t.separator, t); + return _c(n, e, t, i, s); +} +function xp(n, e, t) { + const r = X(n, e, t, { + type: rt + }); + at(n, r); + const i = $(t.definition, (a) => wc(n, e, a)); + return tn(n, e, r, t, ...i); +} +function $p(n, e, t) { + const r = X(n, e, t, { + type: rt + }); + at(n, r); + const i = tn(n, e, r, t, Tt(n, e, t)); + return Sp(n, e, t, i); +} +function Tt(n, e, t) { + const r = xe($(t.definition, (i) => wc(n, e, i)), (i) => i !== void 0); + return r.length === 1 ? r[0] : r.length === 0 ? void 0 : Np(n, r); +} +function _c(n, e, t, r, i) { + const s = r.left, a = r.right, o = X(n, e, t, { + type: yp + }); + at(n, o); + const l = X(n, e, t, { + type: Nc + }); + return s.loopback = o, l.loopback = o, n.decisionMap[Ht(e, i ? "RepetitionMandatoryWithSeparator" : "RepetitionMandatory", t.idx)] = o, H(a, o), i === void 0 ? (H(o, s), H(o, l)) : (H(o, l), H(o, i.left), H(i.right, s)), { + left: s, + right: l + }; +} +function Lc(n, e, t, r, i) { + const s = r.left, a = r.right, o = X(n, e, t, { + type: gp + }); + at(n, o); + const l = X(n, e, t, { + type: Nc + }), c = X(n, e, t, { + type: mp + }); + return o.loopback = c, l.loopback = c, H(o, s), H(o, l), H(a, c), i !== void 0 ? (H(c, l), H(c, i.left), H(i.right, s)) : H(c, o), n.decisionMap[Ht(e, i ? "RepetitionWithSeparator" : "Repetition", t.idx)] = o, { + left: o, + right: l + }; +} +function Sp(n, e, t, r) { + const i = r.left, s = r.right; + return H(i, s), n.decisionMap[Ht(e, "Option", t.idx)] = i, r; +} +function at(n, e) { + return n.decisionStates.push(e), e.decision = n.decisionStates.length - 1, e.decision; +} +function tn(n, e, t, r, ...i) { + const s = X(n, e, r, { + type: pp, + start: t + }); + t.end = s; + for (const o of i) + o !== void 0 ? (H(t, o.left), H(o.right, s)) : H(t, s); + const a = { + left: t, + right: s + }; + return n.decisionMap[Ht(e, Ip(r), r.idx)] = t, a; +} +function Ip(n) { + if (n instanceof ge) + return "Alternation"; + if (n instanceof te) + return "Option"; + if (n instanceof W) + return "Repetition"; + if (n instanceof me) + return "RepetitionWithSeparator"; + if (n instanceof $e) + return "RepetitionMandatory"; + if (n instanceof Se) + return "RepetitionMandatoryWithSeparator"; + throw new Error("Invalid production type encountered"); +} +function Np(n, e) { + const t = e.length; + for (let s = 0; s < t - 1; s++) { + const a = e[s]; + let o; + a.left.transitions.length === 1 && (o = a.left.transitions[0]); + const l = o instanceof ta, c = o, u = e[s + 1].left; + a.left.type === rt && a.right.type === rt && o !== void 0 && (l && c.followState === a.right || o.target === a.right) ? (l ? c.followState = u : o.target = u, _p(n, a.right)) : H(a.right, u); + } + const r = e[0], i = e[t - 1]; + return { + left: r.left, + right: i.right + }; +} +function na(n, e, t, r) { + const i = X(n, e, r, { + type: rt + }), s = X(n, e, r, { + type: rt + }); + return ra(i, new ea(s, t)), { + left: i, + right: s + }; +} +function Cp(n, e, t) { + const r = t.referencedRule, i = n.ruleToStartState.get(r), s = X(n, e, t, { + type: rt + }), a = X(n, e, t, { + type: rt + }), o = new ta(i, r, a); + return ra(s, o), { + left: s, + right: a + }; +} +function wp(n, e, t) { + const r = n.ruleToStartState.get(e); + H(r, t.left); + const i = n.ruleToStopState.get(e); + return H(t.right, i), { + left: r, + right: i + }; +} +function H(n, e) { + const t = new Cc(e); + ra(n, t); +} +function X(n, e, t, r) { + const i = Object.assign({ + atn: n, + production: t, + epsilonOnlyTransitions: !1, + rule: e, + transitions: [], + nextTokenWithinRule: [], + stateNumber: n.states.length + }, r); + return n.states.push(i), i; +} +function ra(n, e) { + n.transitions.length === 0 && (n.epsilonOnlyTransitions = e.isEpsilon()), n.transitions.push(e); +} +function _p(n, e) { + n.states.splice(n.states.indexOf(e), 1); +} +const zr = {}; +class ds { + constructor() { + this.map = {}, this.configs = []; + } + get size() { + return this.configs.length; + } + finalize() { + this.map = {}; + } + add(e) { + const t = Oc(e); + t in this.map || (this.map[t] = this.configs.length, this.configs.push(e)); + } + get elements() { + return this.configs; + } + get alts() { + return $(this.configs, (e) => e.alt); + } + get key() { + let e = ""; + for (const t in this.map) + e += t + ":"; + return e; + } +} +function Oc(n, e = !0) { + return `${e ? `a${n.alt}` : ""}s${n.state.stateNumber}:${n.stack.map((t) => t.stateNumber.toString()).join("_")}`; +} +function Lp(n, e) { + const t = {}; + return (r) => { + const i = r.toString(); + let s = t[i]; + return s !== void 0 || (s = { + atnStartState: n, + decision: e, + states: {} + }, t[i] = s), s; + }; +} +class bc { + constructor() { + this.predicates = []; + } + is(e) { + return e >= this.predicates.length || this.predicates[e]; + } + set(e, t) { + this.predicates[e] = t; + } + toString() { + let e = ""; + const t = this.predicates.length; + for (let r = 0; r < t; r++) + e += this.predicates[r] === !0 ? "1" : "0"; + return e; + } +} +const za = new bc(); +class Op extends Qs { + constructor(e) { + var t; + super(), this.logging = (t = e == null ? void 0 : e.logging) !== null && t !== void 0 ? t : (r) => console.log(r); + } + initialize(e) { + this.atn = Tp(e.rules), this.dfas = bp(this.atn); + } + validateAmbiguousAlternationAlternatives() { + return []; + } + validateEmptyOrAlternatives() { + return []; + } + buildLookaheadForAlternation(e) { + const { prodOccurrence: t, rule: r, hasPredicates: i, dynamicTokensEnabled: s } = e, a = this.dfas, o = this.logging, l = Ht(r, "Alternation", t), u = this.atn.decisionMap[l].decision, d = $(Ga({ + maxLookahead: 1, + occurrence: t, + prodType: "Alternation", + rule: r + }), (h) => $(h, (f) => f[0])); + if (qa(d, !1) && !s) { + const h = oe(d, (f, m, g) => (N(m, (v) => { + v && (f[v.tokenTypeIdx] = g, N(v.categoryMatches, (y) => { + f[y] = g; + })); + }), f), {}); + return i ? function(f) { + var m; + const g = this.LA(1), v = h[g.tokenTypeIdx]; + if (f !== void 0 && v !== void 0) { + const y = (m = f[v]) === null || m === void 0 ? void 0 : m.GATE; + if (y !== void 0 && y.call(this) === !1) + return; + } + return v; + } : function() { + const f = this.LA(1); + return h[f.tokenTypeIdx]; + }; + } else return i ? function(h) { + const f = new bc(), m = h === void 0 ? 0 : h.length; + for (let v = 0; v < m; v++) { + const y = h == null ? void 0 : h[v].GATE; + f.set(v, y === void 0 || y.call(this)); + } + const g = Mi.call(this, a, u, f, o); + return typeof g == "number" ? g : void 0; + } : function() { + const h = Mi.call(this, a, u, za, o); + return typeof h == "number" ? h : void 0; + }; + } + buildLookaheadForOptional(e) { + const { prodOccurrence: t, rule: r, prodType: i, dynamicTokensEnabled: s } = e, a = this.dfas, o = this.logging, l = Ht(r, i, t), u = this.atn.decisionMap[l].decision, d = $(Ga({ + maxLookahead: 1, + occurrence: t, + prodType: i, + rule: r + }), (h) => $(h, (f) => f[0])); + if (qa(d) && d[0][0] && !s) { + const h = d[0], f = Ce(h); + if (f.length === 1 && D(f[0].categoryMatches)) { + const g = f[0].tokenTypeIdx; + return function() { + return this.LA(1).tokenTypeIdx === g; + }; + } else { + const m = oe(f, (g, v) => (v !== void 0 && (g[v.tokenTypeIdx] = !0, N(v.categoryMatches, (y) => { + g[y] = !0; + })), g), {}); + return function() { + const g = this.LA(1); + return m[g.tokenTypeIdx] === !0; + }; + } + } + return function() { + const h = Mi.call(this, a, u, za, o); + return typeof h == "object" ? !1 : h === 0; + }; + } +} +function qa(n, e = !0) { + const t = /* @__PURE__ */ new Set(); + for (const r of n) { + const i = /* @__PURE__ */ new Set(); + for (const s of r) { + if (s === void 0) { + if (e) + break; + return !1; + } + const a = [s.tokenTypeIdx].concat(s.categoryMatches); + for (const o of a) + if (t.has(o)) { + if (!i.has(o)) + return !1; + } else + t.add(o), i.add(o); + } + } + return !0; +} +function bp(n) { + const e = n.decisionStates.length, t = Array(e); + for (let r = 0; r < e; r++) + t[r] = Lp(n.decisionStates[r], r); + return t; +} +function Mi(n, e, t, r) { + const i = n[e](t); + let s = i.start; + if (s === void 0) { + const o = jp(i.atnStartState); + s = Mc(i, Pc(o)), i.start = s; + } + return Pp.apply(this, [i, s, t, r]); +} +function Pp(n, e, t, r) { + let i = e, s = 1; + const a = []; + let o = this.LA(s++); + for (; ; ) { + let l = Bp(i, o); + if (l === void 0 && (l = Mp.apply(this, [n, i, o, s, t, r])), l === zr) + return Up(a, i, o); + if (l.isAcceptState === !0) + return l.prediction; + i = l, a.push(o), o = this.LA(s++); + } +} +function Mp(n, e, t, r, i, s) { + const a = Vp(e.configs, t, i); + if (a.size === 0) + return Ya(n, e, t, zr), zr; + let o = Pc(a); + const l = Wp(a, i); + if (l !== void 0) + o.isAcceptState = !0, o.prediction = l, o.configs.uniqueAlt = l; + else if (Yp(a)) { + const c = Bu(a.alts); + o.isAcceptState = !0, o.prediction = c, o.configs.uniqueAlt = c, Dp.apply(this, [n, r, a.alts, s]); + } + return o = Ya(n, e, t, o), o; +} +function Dp(n, e, t, r) { + const i = []; + for (let c = 1; c <= e; c++) + i.push(this.LA(c).tokenType); + const s = n.atnStartState, a = s.rule, o = s.production, l = Fp({ + topLevelRule: a, + ambiguityIndices: t, + production: o, + prefixPath: i + }); + r(l); +} +function Fp(n) { + const e = $(n.prefixPath, (i) => Nt(i)).join(", "), t = n.production.idx === 0 ? "" : n.production.idx; + let r = `Ambiguous Alternatives Detected: <${n.ambiguityIndices.join(", ")}> in <${Gp(n.production)}${t}> inside <${n.topLevelRule.name}> Rule, +<${e}> may appears as a prefix path in all these alternatives. +`; + return r = r + `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES +For Further details.`, r; +} +function Gp(n) { + if (n instanceof le) + return "SUBRULE"; + if (n instanceof te) + return "OPTION"; + if (n instanceof ge) + return "OR"; + if (n instanceof $e) + return "AT_LEAST_ONE"; + if (n instanceof Se) + return "AT_LEAST_ONE_SEP"; + if (n instanceof me) + return "MANY_SEP"; + if (n instanceof W) + return "MANY"; + if (n instanceof G) + return "CONSUME"; + throw Error("non exhaustive match"); +} +function Up(n, e, t) { + const r = Ee(e.configs.elements, (s) => s.state.transitions), i = od(r.filter((s) => s instanceof ea).map((s) => s.tokenType), (s) => s.tokenTypeIdx); + return { + actualToken: t, + possibleTokenTypes: i, + tokenPath: n + }; +} +function Bp(n, e) { + return n.edges[e.tokenTypeIdx]; +} +function Vp(n, e, t) { + const r = new ds(), i = []; + for (const a of n.elements) { + if (t.is(a.alt) === !1) + continue; + if (a.state.type === rr) { + i.push(a); + continue; + } + const o = a.state.transitions.length; + for (let l = 0; l < o; l++) { + const c = a.state.transitions[l], u = Kp(c, e); + u !== void 0 && r.add({ + state: u, + alt: a.alt, + stack: a.stack + }); + } + } + let s; + if (i.length === 0 && r.size === 1 && (s = r), s === void 0) { + s = new ds(); + for (const a of r.elements) + qr(a, s); + } + if (i.length > 0 && !zp(s)) + for (const a of i) + s.add(a); + return s; +} +function Kp(n, e) { + if (n instanceof ea && oc(e, n.tokenType)) + return n.target; +} +function Wp(n, e) { + let t; + for (const r of n.elements) + if (e.is(r.alt) === !0) { + if (t === void 0) + t = r.alt; + else if (t !== r.alt) + return; + } + return t; +} +function Pc(n) { + return { + configs: n, + edges: {}, + isAcceptState: !1, + prediction: -1 + }; +} +function Ya(n, e, t, r) { + return r = Mc(n, r), e.edges[t.tokenTypeIdx] = r, r; +} +function Mc(n, e) { + if (e === zr) + return e; + const t = e.configs.key, r = n.states[t]; + return r !== void 0 ? r : (e.configs.finalize(), n.states[t] = e, e); +} +function jp(n) { + const e = new ds(), t = n.transitions.length; + for (let r = 0; r < t; r++) { + const s = { + state: n.transitions[r].target, + alt: r, + stack: [] + }; + qr(s, e); + } + return e; +} +function qr(n, e) { + const t = n.state; + if (t.type === rr) { + if (n.stack.length > 0) { + const i = [...n.stack], a = { + state: i.pop(), + alt: n.alt, + stack: i + }; + qr(a, e); + } else + e.add(n); + return; + } + t.epsilonOnlyTransitions || e.add(n); + const r = t.transitions.length; + for (let i = 0; i < r; i++) { + const s = t.transitions[i], a = Hp(n, s); + a !== void 0 && qr(a, e); + } +} +function Hp(n, e) { + if (e instanceof Cc) + return { + state: e.target, + alt: n.alt, + stack: n.stack + }; + if (e instanceof ta) { + const t = [...n.stack, e.followState]; + return { + state: e.target, + alt: n.alt, + stack: t + }; + } +} +function zp(n) { + for (const e of n.elements) + if (e.state.type === rr) + return !0; + return !1; +} +function qp(n) { + for (const e of n.elements) + if (e.state.type !== rr) + return !1; + return !0; +} +function Yp(n) { + if (qp(n)) + return !0; + const e = Xp(n.elements); + return Jp(e) && !Qp(e); +} +function Xp(n) { + const e = /* @__PURE__ */ new Map(); + for (const t of n) { + const r = Oc(t, !1); + let i = e.get(r); + i === void 0 && (i = {}, e.set(r, i)), i[t.alt] = !0; + } + return e; +} +function Jp(n) { + for (const e of Array.from(n.values())) + if (Object.keys(e).length > 1) + return !0; + return !1; +} +function Qp(n) { + for (const e of Array.from(n.values())) + if (Object.keys(e).length === 1) + return !0; + return !1; +} +var Xa; +(function(n) { + function e(t) { + return typeof t == "string"; + } + n.is = e; +})(Xa || (Xa = {})); +var fs; +(function(n) { + function e(t) { + return typeof t == "string"; + } + n.is = e; +})(fs || (fs = {})); +var Ja; +(function(n) { + n.MIN_VALUE = -2147483648, n.MAX_VALUE = 2147483647; + function e(t) { + return typeof t == "number" && n.MIN_VALUE <= t && t <= n.MAX_VALUE; + } + n.is = e; +})(Ja || (Ja = {})); +var Yr; +(function(n) { + n.MIN_VALUE = 0, n.MAX_VALUE = 2147483647; + function e(t) { + return typeof t == "number" && n.MIN_VALUE <= t && t <= n.MAX_VALUE; + } + n.is = e; +})(Yr || (Yr = {})); +var P; +(function(n) { + function e(r, i) { + return r === Number.MAX_VALUE && (r = Yr.MAX_VALUE), i === Number.MAX_VALUE && (i = Yr.MAX_VALUE), { line: r, character: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.objectLiteral(i) && p.uinteger(i.line) && p.uinteger(i.character); + } + n.is = t; +})(P || (P = {})); +var b; +(function(n) { + function e(r, i, s, a) { + if (p.uinteger(r) && p.uinteger(i) && p.uinteger(s) && p.uinteger(a)) + return { start: P.create(r, i), end: P.create(s, a) }; + if (P.is(r) && P.is(i)) + return { start: r, end: i }; + throw new Error(`Range#create called with invalid arguments[${r}, ${i}, ${s}, ${a}]`); + } + n.create = e; + function t(r) { + let i = r; + return p.objectLiteral(i) && P.is(i.start) && P.is(i.end); + } + n.is = t; +})(b || (b = {})); +var Xr; +(function(n) { + function e(r, i) { + return { uri: r, range: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.objectLiteral(i) && b.is(i.range) && (p.string(i.uri) || p.undefined(i.uri)); + } + n.is = t; +})(Xr || (Xr = {})); +var Qa; +(function(n) { + function e(r, i, s, a) { + return { targetUri: r, targetRange: i, targetSelectionRange: s, originSelectionRange: a }; + } + n.create = e; + function t(r) { + let i = r; + return p.objectLiteral(i) && b.is(i.targetRange) && p.string(i.targetUri) && b.is(i.targetSelectionRange) && (b.is(i.originSelectionRange) || p.undefined(i.originSelectionRange)); + } + n.is = t; +})(Qa || (Qa = {})); +var hs; +(function(n) { + function e(r, i, s, a) { + return { + red: r, + green: i, + blue: s, + alpha: a + }; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && p.numberRange(i.red, 0, 1) && p.numberRange(i.green, 0, 1) && p.numberRange(i.blue, 0, 1) && p.numberRange(i.alpha, 0, 1); + } + n.is = t; +})(hs || (hs = {})); +var Za; +(function(n) { + function e(r, i) { + return { + range: r, + color: i + }; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && b.is(i.range) && hs.is(i.color); + } + n.is = t; +})(Za || (Za = {})); +var eo; +(function(n) { + function e(r, i, s) { + return { + label: r, + textEdit: i, + additionalTextEdits: s + }; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && p.string(i.label) && (p.undefined(i.textEdit) || qt.is(i)) && (p.undefined(i.additionalTextEdits) || p.typedArray(i.additionalTextEdits, qt.is)); + } + n.is = t; +})(eo || (eo = {})); +var to; +(function(n) { + n.Comment = "comment", n.Imports = "imports", n.Region = "region"; +})(to || (to = {})); +var no; +(function(n) { + function e(r, i, s, a, o, l) { + const c = { + startLine: r, + endLine: i + }; + return p.defined(s) && (c.startCharacter = s), p.defined(a) && (c.endCharacter = a), p.defined(o) && (c.kind = o), p.defined(l) && (c.collapsedText = l), c; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && p.uinteger(i.startLine) && p.uinteger(i.startLine) && (p.undefined(i.startCharacter) || p.uinteger(i.startCharacter)) && (p.undefined(i.endCharacter) || p.uinteger(i.endCharacter)) && (p.undefined(i.kind) || p.string(i.kind)); + } + n.is = t; +})(no || (no = {})); +var ps; +(function(n) { + function e(r, i) { + return { + location: r, + message: i + }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && Xr.is(i.location) && p.string(i.message); + } + n.is = t; +})(ps || (ps = {})); +var ro; +(function(n) { + n.Error = 1, n.Warning = 2, n.Information = 3, n.Hint = 4; +})(ro || (ro = {})); +var io; +(function(n) { + n.Unnecessary = 1, n.Deprecated = 2; +})(io || (io = {})); +var so; +(function(n) { + function e(t) { + const r = t; + return p.objectLiteral(r) && p.string(r.href); + } + n.is = e; +})(so || (so = {})); +var Jr; +(function(n) { + function e(r, i, s, a, o, l) { + let c = { range: r, message: i }; + return p.defined(s) && (c.severity = s), p.defined(a) && (c.code = a), p.defined(o) && (c.source = o), p.defined(l) && (c.relatedInformation = l), c; + } + n.create = e; + function t(r) { + var i; + let s = r; + return p.defined(s) && b.is(s.range) && p.string(s.message) && (p.number(s.severity) || p.undefined(s.severity)) && (p.integer(s.code) || p.string(s.code) || p.undefined(s.code)) && (p.undefined(s.codeDescription) || p.string((i = s.codeDescription) === null || i === void 0 ? void 0 : i.href)) && (p.string(s.source) || p.undefined(s.source)) && (p.undefined(s.relatedInformation) || p.typedArray(s.relatedInformation, ps.is)); + } + n.is = t; +})(Jr || (Jr = {})); +var zt; +(function(n) { + function e(r, i, ...s) { + let a = { title: r, command: i }; + return p.defined(s) && s.length > 0 && (a.arguments = s), a; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.string(i.title) && p.string(i.command); + } + n.is = t; +})(zt || (zt = {})); +var qt; +(function(n) { + function e(s, a) { + return { range: s, newText: a }; + } + n.replace = e; + function t(s, a) { + return { range: { start: s, end: s }, newText: a }; + } + n.insert = t; + function r(s) { + return { range: s, newText: "" }; + } + n.del = r; + function i(s) { + const a = s; + return p.objectLiteral(a) && p.string(a.newText) && b.is(a.range); + } + n.is = i; +})(qt || (qt = {})); +var ms; +(function(n) { + function e(r, i, s) { + const a = { label: r }; + return i !== void 0 && (a.needsConfirmation = i), s !== void 0 && (a.description = s), a; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && p.string(i.label) && (p.boolean(i.needsConfirmation) || i.needsConfirmation === void 0) && (p.string(i.description) || i.description === void 0); + } + n.is = t; +})(ms || (ms = {})); +var Yt; +(function(n) { + function e(t) { + const r = t; + return p.string(r); + } + n.is = e; +})(Yt || (Yt = {})); +var ao; +(function(n) { + function e(s, a, o) { + return { range: s, newText: a, annotationId: o }; + } + n.replace = e; + function t(s, a, o) { + return { range: { start: s, end: s }, newText: a, annotationId: o }; + } + n.insert = t; + function r(s, a) { + return { range: s, newText: "", annotationId: a }; + } + n.del = r; + function i(s) { + const a = s; + return qt.is(a) && (ms.is(a.annotationId) || Yt.is(a.annotationId)); + } + n.is = i; +})(ao || (ao = {})); +var gs; +(function(n) { + function e(r, i) { + return { textDocument: r, edits: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && As.is(i.textDocument) && Array.isArray(i.edits); + } + n.is = t; +})(gs || (gs = {})); +var ys; +(function(n) { + function e(r, i, s) { + let a = { + kind: "create", + uri: r + }; + return i !== void 0 && (i.overwrite !== void 0 || i.ignoreIfExists !== void 0) && (a.options = i), s !== void 0 && (a.annotationId = s), a; + } + n.create = e; + function t(r) { + let i = r; + return i && i.kind === "create" && p.string(i.uri) && (i.options === void 0 || (i.options.overwrite === void 0 || p.boolean(i.options.overwrite)) && (i.options.ignoreIfExists === void 0 || p.boolean(i.options.ignoreIfExists))) && (i.annotationId === void 0 || Yt.is(i.annotationId)); + } + n.is = t; +})(ys || (ys = {})); +var Ts; +(function(n) { + function e(r, i, s, a) { + let o = { + kind: "rename", + oldUri: r, + newUri: i + }; + return s !== void 0 && (s.overwrite !== void 0 || s.ignoreIfExists !== void 0) && (o.options = s), a !== void 0 && (o.annotationId = a), o; + } + n.create = e; + function t(r) { + let i = r; + return i && i.kind === "rename" && p.string(i.oldUri) && p.string(i.newUri) && (i.options === void 0 || (i.options.overwrite === void 0 || p.boolean(i.options.overwrite)) && (i.options.ignoreIfExists === void 0 || p.boolean(i.options.ignoreIfExists))) && (i.annotationId === void 0 || Yt.is(i.annotationId)); + } + n.is = t; +})(Ts || (Ts = {})); +var Rs; +(function(n) { + function e(r, i, s) { + let a = { + kind: "delete", + uri: r + }; + return i !== void 0 && (i.recursive !== void 0 || i.ignoreIfNotExists !== void 0) && (a.options = i), s !== void 0 && (a.annotationId = s), a; + } + n.create = e; + function t(r) { + let i = r; + return i && i.kind === "delete" && p.string(i.uri) && (i.options === void 0 || (i.options.recursive === void 0 || p.boolean(i.options.recursive)) && (i.options.ignoreIfNotExists === void 0 || p.boolean(i.options.ignoreIfNotExists))) && (i.annotationId === void 0 || Yt.is(i.annotationId)); + } + n.is = t; +})(Rs || (Rs = {})); +var vs; +(function(n) { + function e(t) { + let r = t; + return r && (r.changes !== void 0 || r.documentChanges !== void 0) && (r.documentChanges === void 0 || r.documentChanges.every((i) => p.string(i.kind) ? ys.is(i) || Ts.is(i) || Rs.is(i) : gs.is(i))); + } + n.is = e; +})(vs || (vs = {})); +var oo; +(function(n) { + function e(r) { + return { uri: r }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.string(i.uri); + } + n.is = t; +})(oo || (oo = {})); +var lo; +(function(n) { + function e(r, i) { + return { uri: r, version: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.string(i.uri) && p.integer(i.version); + } + n.is = t; +})(lo || (lo = {})); +var As; +(function(n) { + function e(r, i) { + return { uri: r, version: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.string(i.uri) && (i.version === null || p.integer(i.version)); + } + n.is = t; +})(As || (As = {})); +var co; +(function(n) { + function e(r, i, s, a) { + return { uri: r, languageId: i, version: s, text: a }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.string(i.uri) && p.string(i.languageId) && p.integer(i.version) && p.string(i.text); + } + n.is = t; +})(co || (co = {})); +var Es; +(function(n) { + n.PlainText = "plaintext", n.Markdown = "markdown"; + function e(t) { + const r = t; + return r === n.PlainText || r === n.Markdown; + } + n.is = e; +})(Es || (Es = {})); +var zn; +(function(n) { + function e(t) { + const r = t; + return p.objectLiteral(t) && Es.is(r.kind) && p.string(r.value); + } + n.is = e; +})(zn || (zn = {})); +var uo; +(function(n) { + n.Text = 1, n.Method = 2, n.Function = 3, n.Constructor = 4, n.Field = 5, n.Variable = 6, n.Class = 7, n.Interface = 8, n.Module = 9, n.Property = 10, n.Unit = 11, n.Value = 12, n.Enum = 13, n.Keyword = 14, n.Snippet = 15, n.Color = 16, n.File = 17, n.Reference = 18, n.Folder = 19, n.EnumMember = 20, n.Constant = 21, n.Struct = 22, n.Event = 23, n.Operator = 24, n.TypeParameter = 25; +})(uo || (uo = {})); +var fo; +(function(n) { + n.PlainText = 1, n.Snippet = 2; +})(fo || (fo = {})); +var ho; +(function(n) { + n.Deprecated = 1; +})(ho || (ho = {})); +var po; +(function(n) { + function e(r, i, s) { + return { newText: r, insert: i, replace: s }; + } + n.create = e; + function t(r) { + const i = r; + return i && p.string(i.newText) && b.is(i.insert) && b.is(i.replace); + } + n.is = t; +})(po || (po = {})); +var mo; +(function(n) { + n.asIs = 1, n.adjustIndentation = 2; +})(mo || (mo = {})); +var go; +(function(n) { + function e(t) { + const r = t; + return r && (p.string(r.detail) || r.detail === void 0) && (p.string(r.description) || r.description === void 0); + } + n.is = e; +})(go || (go = {})); +var yo; +(function(n) { + function e(t) { + return { label: t }; + } + n.create = e; +})(yo || (yo = {})); +var To; +(function(n) { + function e(t, r) { + return { items: t || [], isIncomplete: !!r }; + } + n.create = e; +})(To || (To = {})); +var Qr; +(function(n) { + function e(r) { + return r.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); + } + n.fromPlainText = e; + function t(r) { + const i = r; + return p.string(i) || p.objectLiteral(i) && p.string(i.language) && p.string(i.value); + } + n.is = t; +})(Qr || (Qr = {})); +var Ro; +(function(n) { + function e(t) { + let r = t; + return !!r && p.objectLiteral(r) && (zn.is(r.contents) || Qr.is(r.contents) || p.typedArray(r.contents, Qr.is)) && (t.range === void 0 || b.is(t.range)); + } + n.is = e; +})(Ro || (Ro = {})); +var vo; +(function(n) { + function e(t, r) { + return r ? { label: t, documentation: r } : { label: t }; + } + n.create = e; +})(vo || (vo = {})); +var Ao; +(function(n) { + function e(t, r, ...i) { + let s = { label: t }; + return p.defined(r) && (s.documentation = r), p.defined(i) ? s.parameters = i : s.parameters = [], s; + } + n.create = e; +})(Ao || (Ao = {})); +var Eo; +(function(n) { + n.Text = 1, n.Read = 2, n.Write = 3; +})(Eo || (Eo = {})); +var ko; +(function(n) { + function e(t, r) { + let i = { range: t }; + return p.number(r) && (i.kind = r), i; + } + n.create = e; +})(ko || (ko = {})); +var xo; +(function(n) { + n.File = 1, n.Module = 2, n.Namespace = 3, n.Package = 4, n.Class = 5, n.Method = 6, n.Property = 7, n.Field = 8, n.Constructor = 9, n.Enum = 10, n.Interface = 11, n.Function = 12, n.Variable = 13, n.Constant = 14, n.String = 15, n.Number = 16, n.Boolean = 17, n.Array = 18, n.Object = 19, n.Key = 20, n.Null = 21, n.EnumMember = 22, n.Struct = 23, n.Event = 24, n.Operator = 25, n.TypeParameter = 26; +})(xo || (xo = {})); +var $o; +(function(n) { + n.Deprecated = 1; +})($o || ($o = {})); +var So; +(function(n) { + function e(t, r, i, s, a) { + let o = { + name: t, + kind: r, + location: { uri: s, range: i } + }; + return a && (o.containerName = a), o; + } + n.create = e; +})(So || (So = {})); +var Io; +(function(n) { + function e(t, r, i, s) { + return s !== void 0 ? { name: t, kind: r, location: { uri: i, range: s } } : { name: t, kind: r, location: { uri: i } }; + } + n.create = e; +})(Io || (Io = {})); +var No; +(function(n) { + function e(r, i, s, a, o, l) { + let c = { + name: r, + detail: i, + kind: s, + range: a, + selectionRange: o + }; + return l !== void 0 && (c.children = l), c; + } + n.create = e; + function t(r) { + let i = r; + return i && p.string(i.name) && p.number(i.kind) && b.is(i.range) && b.is(i.selectionRange) && (i.detail === void 0 || p.string(i.detail)) && (i.deprecated === void 0 || p.boolean(i.deprecated)) && (i.children === void 0 || Array.isArray(i.children)) && (i.tags === void 0 || Array.isArray(i.tags)); + } + n.is = t; +})(No || (No = {})); +var Co; +(function(n) { + n.Empty = "", n.QuickFix = "quickfix", n.Refactor = "refactor", n.RefactorExtract = "refactor.extract", n.RefactorInline = "refactor.inline", n.RefactorRewrite = "refactor.rewrite", n.Source = "source", n.SourceOrganizeImports = "source.organizeImports", n.SourceFixAll = "source.fixAll"; +})(Co || (Co = {})); +var Zr; +(function(n) { + n.Invoked = 1, n.Automatic = 2; +})(Zr || (Zr = {})); +var wo; +(function(n) { + function e(r, i, s) { + let a = { diagnostics: r }; + return i != null && (a.only = i), s != null && (a.triggerKind = s), a; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.typedArray(i.diagnostics, Jr.is) && (i.only === void 0 || p.typedArray(i.only, p.string)) && (i.triggerKind === void 0 || i.triggerKind === Zr.Invoked || i.triggerKind === Zr.Automatic); + } + n.is = t; +})(wo || (wo = {})); +var _o; +(function(n) { + function e(r, i, s) { + let a = { title: r }, o = !0; + return typeof i == "string" ? (o = !1, a.kind = i) : zt.is(i) ? a.command = i : a.edit = i, o && s !== void 0 && (a.kind = s), a; + } + n.create = e; + function t(r) { + let i = r; + return i && p.string(i.title) && (i.diagnostics === void 0 || p.typedArray(i.diagnostics, Jr.is)) && (i.kind === void 0 || p.string(i.kind)) && (i.edit !== void 0 || i.command !== void 0) && (i.command === void 0 || zt.is(i.command)) && (i.isPreferred === void 0 || p.boolean(i.isPreferred)) && (i.edit === void 0 || vs.is(i.edit)); + } + n.is = t; +})(_o || (_o = {})); +var Lo; +(function(n) { + function e(r, i) { + let s = { range: r }; + return p.defined(i) && (s.data = i), s; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && b.is(i.range) && (p.undefined(i.command) || zt.is(i.command)); + } + n.is = t; +})(Lo || (Lo = {})); +var Oo; +(function(n) { + function e(r, i) { + return { tabSize: r, insertSpaces: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && p.uinteger(i.tabSize) && p.boolean(i.insertSpaces); + } + n.is = t; +})(Oo || (Oo = {})); +var bo; +(function(n) { + function e(r, i, s) { + return { range: r, target: i, data: s }; + } + n.create = e; + function t(r) { + let i = r; + return p.defined(i) && b.is(i.range) && (p.undefined(i.target) || p.string(i.target)); + } + n.is = t; +})(bo || (bo = {})); +var Po; +(function(n) { + function e(r, i) { + return { range: r, parent: i }; + } + n.create = e; + function t(r) { + let i = r; + return p.objectLiteral(i) && b.is(i.range) && (i.parent === void 0 || n.is(i.parent)); + } + n.is = t; +})(Po || (Po = {})); +var Mo; +(function(n) { + n.namespace = "namespace", n.type = "type", n.class = "class", n.enum = "enum", n.interface = "interface", n.struct = "struct", n.typeParameter = "typeParameter", n.parameter = "parameter", n.variable = "variable", n.property = "property", n.enumMember = "enumMember", n.event = "event", n.function = "function", n.method = "method", n.macro = "macro", n.keyword = "keyword", n.modifier = "modifier", n.comment = "comment", n.string = "string", n.number = "number", n.regexp = "regexp", n.operator = "operator", n.decorator = "decorator"; +})(Mo || (Mo = {})); +var Do; +(function(n) { + n.declaration = "declaration", n.definition = "definition", n.readonly = "readonly", n.static = "static", n.deprecated = "deprecated", n.abstract = "abstract", n.async = "async", n.modification = "modification", n.documentation = "documentation", n.defaultLibrary = "defaultLibrary"; +})(Do || (Do = {})); +var Fo; +(function(n) { + function e(t) { + const r = t; + return p.objectLiteral(r) && (r.resultId === void 0 || typeof r.resultId == "string") && Array.isArray(r.data) && (r.data.length === 0 || typeof r.data[0] == "number"); + } + n.is = e; +})(Fo || (Fo = {})); +var Go; +(function(n) { + function e(r, i) { + return { range: r, text: i }; + } + n.create = e; + function t(r) { + const i = r; + return i != null && b.is(i.range) && p.string(i.text); + } + n.is = t; +})(Go || (Go = {})); +var Uo; +(function(n) { + function e(r, i, s) { + return { range: r, variableName: i, caseSensitiveLookup: s }; + } + n.create = e; + function t(r) { + const i = r; + return i != null && b.is(i.range) && p.boolean(i.caseSensitiveLookup) && (p.string(i.variableName) || i.variableName === void 0); + } + n.is = t; +})(Uo || (Uo = {})); +var Bo; +(function(n) { + function e(r, i) { + return { range: r, expression: i }; + } + n.create = e; + function t(r) { + const i = r; + return i != null && b.is(i.range) && (p.string(i.expression) || i.expression === void 0); + } + n.is = t; +})(Bo || (Bo = {})); +var Vo; +(function(n) { + function e(r, i) { + return { frameId: r, stoppedLocation: i }; + } + n.create = e; + function t(r) { + const i = r; + return p.defined(i) && b.is(r.stoppedLocation); + } + n.is = t; +})(Vo || (Vo = {})); +var ks; +(function(n) { + n.Type = 1, n.Parameter = 2; + function e(t) { + return t === 1 || t === 2; + } + n.is = e; +})(ks || (ks = {})); +var xs; +(function(n) { + function e(r) { + return { value: r }; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && (i.tooltip === void 0 || p.string(i.tooltip) || zn.is(i.tooltip)) && (i.location === void 0 || Xr.is(i.location)) && (i.command === void 0 || zt.is(i.command)); + } + n.is = t; +})(xs || (xs = {})); +var Ko; +(function(n) { + function e(r, i, s) { + const a = { position: r, label: i }; + return s !== void 0 && (a.kind = s), a; + } + n.create = e; + function t(r) { + const i = r; + return p.objectLiteral(i) && P.is(i.position) && (p.string(i.label) || p.typedArray(i.label, xs.is)) && (i.kind === void 0 || ks.is(i.kind)) && i.textEdits === void 0 || p.typedArray(i.textEdits, qt.is) && (i.tooltip === void 0 || p.string(i.tooltip) || zn.is(i.tooltip)) && (i.paddingLeft === void 0 || p.boolean(i.paddingLeft)) && (i.paddingRight === void 0 || p.boolean(i.paddingRight)); + } + n.is = t; +})(Ko || (Ko = {})); +var Wo; +(function(n) { + function e(t) { + return { kind: "snippet", value: t }; + } + n.createSnippet = e; +})(Wo || (Wo = {})); +var jo; +(function(n) { + function e(t, r, i, s) { + return { insertText: t, filterText: r, range: i, command: s }; + } + n.create = e; +})(jo || (jo = {})); +var Ho; +(function(n) { + function e(t) { + return { items: t }; + } + n.create = e; +})(Ho || (Ho = {})); +var zo; +(function(n) { + n.Invoked = 0, n.Automatic = 1; +})(zo || (zo = {})); +var qo; +(function(n) { + function e(t, r) { + return { range: t, text: r }; + } + n.create = e; +})(qo || (qo = {})); +var Yo; +(function(n) { + function e(t, r) { + return { triggerKind: t, selectedCompletionInfo: r }; + } + n.create = e; +})(Yo || (Yo = {})); +var Xo; +(function(n) { + function e(t) { + const r = t; + return p.objectLiteral(r) && fs.is(r.uri) && p.string(r.name); + } + n.is = e; +})(Xo || (Xo = {})); +var Jo; +(function(n) { + function e(s, a, o, l) { + return new Zp(s, a, o, l); + } + n.create = e; + function t(s) { + let a = s; + return !!(p.defined(a) && p.string(a.uri) && (p.undefined(a.languageId) || p.string(a.languageId)) && p.uinteger(a.lineCount) && p.func(a.getText) && p.func(a.positionAt) && p.func(a.offsetAt)); + } + n.is = t; + function r(s, a) { + let o = s.getText(), l = i(a, (u, d) => { + let h = u.range.start.line - d.range.start.line; + return h === 0 ? u.range.start.character - d.range.start.character : h; + }), c = o.length; + for (let u = l.length - 1; u >= 0; u--) { + let d = l[u], h = s.offsetAt(d.range.start), f = s.offsetAt(d.range.end); + if (f <= c) + o = o.substring(0, h) + d.newText + o.substring(f, o.length); + else + throw new Error("Overlapping edit"); + c = h; + } + return o; + } + n.applyEdits = r; + function i(s, a) { + if (s.length <= 1) + return s; + const o = s.length / 2 | 0, l = s.slice(0, o), c = s.slice(o); + i(l, a), i(c, a); + let u = 0, d = 0, h = 0; + for (; u < l.length && d < c.length; ) + a(l[u], c[d]) <= 0 ? s[h++] = l[u++] : s[h++] = c[d++]; + for (; u < l.length; ) + s[h++] = l[u++]; + for (; d < c.length; ) + s[h++] = c[d++]; + return s; + } +})(Jo || (Jo = {})); +let Zp = class { + constructor(e, t, r, i) { + this._uri = e, this._languageId = t, this._version = r, this._content = i, this._lineOffsets = void 0; + } + get uri() { + return this._uri; + } + get languageId() { + return this._languageId; + } + get version() { + return this._version; + } + getText(e) { + if (e) { + let t = this.offsetAt(e.start), r = this.offsetAt(e.end); + return this._content.substring(t, r); + } + return this._content; + } + update(e, t) { + this._content = e.text, this._version = t, this._lineOffsets = void 0; + } + getLineOffsets() { + if (this._lineOffsets === void 0) { + let e = [], t = this._content, r = !0; + for (let i = 0; i < t.length; i++) { + r && (e.push(i), r = !1); + let s = t.charAt(i); + r = s === "\r" || s === ` +`, s === "\r" && i + 1 < t.length && t.charAt(i + 1) === ` +` && i++; + } + r && t.length > 0 && e.push(t.length), this._lineOffsets = e; + } + return this._lineOffsets; + } + positionAt(e) { + e = Math.max(Math.min(e, this._content.length), 0); + let t = this.getLineOffsets(), r = 0, i = t.length; + if (i === 0) + return P.create(0, e); + for (; r < i; ) { + let a = Math.floor((r + i) / 2); + t[a] > e ? i = a : r = a + 1; + } + let s = r - 1; + return P.create(s, e - t[s]); + } + offsetAt(e) { + let t = this.getLineOffsets(); + if (e.line >= t.length) + return this._content.length; + if (e.line < 0) + return 0; + let r = t[e.line], i = e.line + 1 < t.length ? t[e.line + 1] : this._content.length; + return Math.max(Math.min(r + e.character, i), r); + } + get lineCount() { + return this.getLineOffsets().length; + } +}; +var p; +(function(n) { + const e = Object.prototype.toString; + function t(f) { + return typeof f < "u"; + } + n.defined = t; + function r(f) { + return typeof f > "u"; + } + n.undefined = r; + function i(f) { + return f === !0 || f === !1; + } + n.boolean = i; + function s(f) { + return e.call(f) === "[object String]"; + } + n.string = s; + function a(f) { + return e.call(f) === "[object Number]"; + } + n.number = a; + function o(f, m, g) { + return e.call(f) === "[object Number]" && m <= f && f <= g; + } + n.numberRange = o; + function l(f) { + return e.call(f) === "[object Number]" && -2147483648 <= f && f <= 2147483647; + } + n.integer = l; + function c(f) { + return e.call(f) === "[object Number]" && 0 <= f && f <= 2147483647; + } + n.uinteger = c; + function u(f) { + return e.call(f) === "[object Function]"; + } + n.func = u; + function d(f) { + return f !== null && typeof f == "object"; + } + n.objectLiteral = d; + function h(f, m) { + return Array.isArray(f) && f.every(m); + } + n.typedArray = h; +})(p || (p = {})); +class em { + constructor() { + this.nodeStack = []; + } + get current() { + var e; + return (e = this.nodeStack[this.nodeStack.length - 1]) !== null && e !== void 0 ? e : this.rootNode; + } + buildRootNode(e) { + return this.rootNode = new Fc(e), this.rootNode.root = this.rootNode, this.nodeStack = [this.rootNode], this.rootNode; + } + buildCompositeNode(e) { + const t = new ia(); + return t.grammarSource = e, t.root = this.rootNode, this.current.content.push(t), this.nodeStack.push(t), t; + } + buildLeafNode(e, t) { + const r = new $s(e.startOffset, e.image.length, Qi(e), e.tokenType, !t); + return r.grammarSource = t, r.root = this.rootNode, this.current.content.push(r), r; + } + removeNode(e) { + const t = e.container; + if (t) { + const r = t.content.indexOf(e); + r >= 0 && t.content.splice(r, 1); + } + } + addHiddenNodes(e) { + const t = []; + for (const s of e) { + const a = new $s(s.startOffset, s.image.length, Qi(s), s.tokenType, !0); + a.root = this.rootNode, t.push(a); + } + let r = this.current, i = !1; + if (r.content.length > 0) { + r.content.push(...t); + return; + } + for (; r.container; ) { + const s = r.container.content.indexOf(r); + if (s > 0) { + r.container.content.splice(s, 0, ...t), i = !0; + break; + } + r = r.container; + } + i || this.rootNode.content.unshift(...t); + } + construct(e) { + const t = this.current; + typeof e.$type == "string" && (this.current.astNode = e), e.$cstNode = t; + const r = this.nodeStack.pop(); + (r == null ? void 0 : r.content.length) === 0 && this.removeNode(r); + } +} +class Dc { + /** @deprecated use `container` instead. */ + get parent() { + return this.container; + } + /** @deprecated use `grammarSource` instead. */ + get feature() { + return this.grammarSource; + } + get hidden() { + return !1; + } + get astNode() { + var e, t; + const r = typeof ((e = this._astNode) === null || e === void 0 ? void 0 : e.$type) == "string" ? this._astNode : (t = this.container) === null || t === void 0 ? void 0 : t.astNode; + if (!r) + throw new Error("This node has no associated AST element"); + return r; + } + set astNode(e) { + this._astNode = e; + } + /** @deprecated use `astNode` instead. */ + get element() { + return this.astNode; + } + get text() { + return this.root.fullText.substring(this.offset, this.end); + } +} +class $s extends Dc { + get offset() { + return this._offset; + } + get length() { + return this._length; + } + get end() { + return this._offset + this._length; + } + get hidden() { + return this._hidden; + } + get tokenType() { + return this._tokenType; + } + get range() { + return this._range; + } + constructor(e, t, r, i, s = !1) { + super(), this._hidden = s, this._offset = e, this._tokenType = i, this._length = t, this._range = r; + } +} +class ia extends Dc { + constructor() { + super(...arguments), this.content = new sa(this); + } + /** @deprecated use `content` instead. */ + get children() { + return this.content; + } + get offset() { + var e, t; + return (t = (e = this.firstNonHiddenNode) === null || e === void 0 ? void 0 : e.offset) !== null && t !== void 0 ? t : 0; + } + get length() { + return this.end - this.offset; + } + get end() { + var e, t; + return (t = (e = this.lastNonHiddenNode) === null || e === void 0 ? void 0 : e.end) !== null && t !== void 0 ? t : 0; + } + get range() { + const e = this.firstNonHiddenNode, t = this.lastNonHiddenNode; + if (e && t) { + if (this._rangeCache === void 0) { + const { range: r } = e, { range: i } = t; + this._rangeCache = { start: r.start, end: i.end.line < r.start.line ? r.start : i.end }; + } + return this._rangeCache; + } else + return { start: P.create(0, 0), end: P.create(0, 0) }; + } + get firstNonHiddenNode() { + for (const e of this.content) + if (!e.hidden) + return e; + return this.content[0]; + } + get lastNonHiddenNode() { + for (let e = this.content.length - 1; e >= 0; e--) { + const t = this.content[e]; + if (!t.hidden) + return t; + } + return this.content[this.content.length - 1]; + } +} +class sa extends Array { + constructor(e) { + super(), this.parent = e, Object.setPrototypeOf(this, sa.prototype); + } + push(...e) { + return this.addParents(e), super.push(...e); + } + unshift(...e) { + return this.addParents(e), super.unshift(...e); + } + splice(e, t, ...r) { + return this.addParents(r), super.splice(e, t, ...r); + } + addParents(e) { + for (const t of e) + t.container = this.parent; + } +} +class Fc extends ia { + get text() { + return this._text.substring(this.offset, this.end); + } + get fullText() { + return this._text; + } + constructor(e) { + super(), this._text = "", this._text = e ?? ""; + } +} +const Ss = Symbol("Datatype"); +function Di(n) { + return n.$type === Ss; +} +const Qo = "​", Gc = (n) => n.endsWith(Qo) ? n : n + Qo; +class Uc { + constructor(e) { + this._unorderedGroups = /* @__PURE__ */ new Map(), this.allRules = /* @__PURE__ */ new Map(), this.lexer = e.parser.Lexer; + const t = this.lexer.definition, r = e.LanguageMetaData.mode === "production"; + this.wrapper = new sm(t, Object.assign(Object.assign({}, e.parser.ParserConfig), { skipValidations: r, errorMessageProvider: e.parser.ParserErrorMessageProvider })); + } + alternatives(e, t) { + this.wrapper.wrapOr(e, t); + } + optional(e, t) { + this.wrapper.wrapOption(e, t); + } + many(e, t) { + this.wrapper.wrapMany(e, t); + } + atLeastOne(e, t) { + this.wrapper.wrapAtLeastOne(e, t); + } + getRule(e) { + return this.allRules.get(e); + } + isRecording() { + return this.wrapper.IS_RECORDING; + } + get unorderedGroups() { + return this._unorderedGroups; + } + getRuleStack() { + return this.wrapper.RULE_STACK; + } + finalize() { + this.wrapper.wrapSelfAnalysis(); + } +} +class tm extends Uc { + get current() { + return this.stack[this.stack.length - 1]; + } + constructor(e) { + super(e), this.nodeBuilder = new em(), this.stack = [], this.assignmentMap = /* @__PURE__ */ new Map(), this.linker = e.references.Linker, this.converter = e.parser.ValueConverter, this.astReflection = e.shared.AstReflection; + } + rule(e, t) { + const r = this.computeRuleType(e), i = this.wrapper.DEFINE_RULE(Gc(e.name), this.startImplementation(r, t).bind(this)); + return this.allRules.set(e.name, i), e.entry && (this.mainRule = i), i; + } + computeRuleType(e) { + if (!e.fragment) { + if (jl(e)) + return Ss; + { + const t = Ws(e); + return t ?? e.name; + } + } + } + parse(e, t = {}) { + this.nodeBuilder.buildRootNode(e); + const r = this.lexerResult = this.lexer.tokenize(e); + this.wrapper.input = r.tokens; + const i = t.rule ? this.allRules.get(t.rule) : this.mainRule; + if (!i) + throw new Error(t.rule ? `No rule found with name '${t.rule}'` : "No main rule available."); + const s = i.call(this.wrapper, {}); + return this.nodeBuilder.addHiddenNodes(r.hidden), this.unorderedGroups.clear(), this.lexerResult = void 0, { + value: s, + lexerErrors: r.errors, + lexerReport: r.report, + parserErrors: this.wrapper.errors + }; + } + startImplementation(e, t) { + return (r) => { + const i = !this.isRecording() && e !== void 0; + if (i) { + const a = { $type: e }; + this.stack.push(a), e === Ss && (a.value = ""); + } + let s; + try { + s = t(r); + } catch { + s = void 0; + } + return s === void 0 && i && (s = this.construct()), s; + }; + } + extractHiddenTokens(e) { + const t = this.lexerResult.hidden; + if (!t.length) + return []; + const r = e.startOffset; + for (let i = 0; i < t.length; i++) + if (t[i].startOffset > r) + return t.splice(0, i); + return t.splice(0, t.length); + } + consume(e, t, r) { + const i = this.wrapper.wrapConsume(e, t); + if (!this.isRecording() && this.isValidToken(i)) { + const s = this.extractHiddenTokens(i); + this.nodeBuilder.addHiddenNodes(s); + const a = this.nodeBuilder.buildLeafNode(i, r), { assignment: o, isCrossRef: l } = this.getAssignment(r), c = this.current; + if (o) { + const u = dt(r) ? i.image : this.converter.convert(i.image, a); + this.assign(o.operator, o.feature, u, a, l); + } else if (Di(c)) { + let u = i.image; + dt(r) || (u = this.converter.convert(u, a).toString()), c.value += u; + } + } + } + /** + * Most consumed parser tokens are valid. However there are two cases in which they are not valid: + * + * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed + * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders. + */ + isValidToken(e) { + return !e.isInsertedInRecovery && !isNaN(e.startOffset) && typeof e.endOffset == "number" && !isNaN(e.endOffset); + } + subrule(e, t, r, i, s) { + let a; + !this.isRecording() && !r && (a = this.nodeBuilder.buildCompositeNode(i)); + const o = this.wrapper.wrapSubrule(e, t, s); + !this.isRecording() && a && a.length > 0 && this.performSubruleAssignment(o, i, a); + } + performSubruleAssignment(e, t, r) { + const { assignment: i, isCrossRef: s } = this.getAssignment(t); + if (i) + this.assign(i.operator, i.feature, e, r, s); + else if (!i) { + const a = this.current; + if (Di(a)) + a.value += e.toString(); + else if (typeof e == "object" && e) { + const l = this.assignWithoutOverride(e, a); + this.stack.pop(), this.stack.push(l); + } + } + } + action(e, t) { + if (!this.isRecording()) { + let r = this.current; + if (t.feature && t.operator) { + r = this.construct(), this.nodeBuilder.removeNode(r.$cstNode), this.nodeBuilder.buildCompositeNode(t).content.push(r.$cstNode); + const s = { $type: e }; + this.stack.push(s), this.assign(t.operator, t.feature, r, r.$cstNode, !1); + } else + r.$type = e; + } + } + construct() { + if (this.isRecording()) + return; + const e = this.current; + return bd(e), this.nodeBuilder.construct(e), this.stack.pop(), Di(e) ? this.converter.convert(e.value, e.$cstNode) : (Pd(this.astReflection, e), e); + } + getAssignment(e) { + if (!this.assignmentMap.has(e)) { + const t = ci(e, ut); + this.assignmentMap.set(e, { + assignment: t, + isCrossRef: t ? Us(t.terminal) : !1 + }); + } + return this.assignmentMap.get(e); + } + assign(e, t, r, i, s) { + const a = this.current; + let o; + switch (s && typeof r == "string" ? o = this.linker.buildReference(a, t, i, r) : o = r, e) { + case "=": { + a[t] = o; + break; + } + case "?=": { + a[t] = !0; + break; + } + case "+=": + Array.isArray(a[t]) || (a[t] = []), a[t].push(o); + } + } + assignWithoutOverride(e, t) { + for (const [i, s] of Object.entries(t)) { + const a = e[i]; + a === void 0 ? e[i] = s : Array.isArray(a) && Array.isArray(s) && (s.push(...a), e[i] = s); + } + const r = e.$cstNode; + return r && (r.astNode = void 0, e.$cstNode = void 0), e; + } + get definitionErrors() { + return this.wrapper.definitionErrors; + } +} +class nm { + buildMismatchTokenMessage(e) { + return St.buildMismatchTokenMessage(e); + } + buildNotAllInputParsedMessage(e) { + return St.buildNotAllInputParsedMessage(e); + } + buildNoViableAltMessage(e) { + return St.buildNoViableAltMessage(e); + } + buildEarlyExitMessage(e) { + return St.buildEarlyExitMessage(e); + } +} +class Bc extends nm { + buildMismatchTokenMessage({ expected: e, actual: t }) { + return `Expecting ${e.LABEL ? "`" + e.LABEL + "`" : e.name.endsWith(":KW") ? `keyword '${e.name.substring(0, e.name.length - 3)}'` : `token of type '${e.name}'`} but found \`${t.image}\`.`; + } + buildNotAllInputParsedMessage({ firstRedundant: e }) { + return `Expecting end of file but found \`${e.image}\`.`; + } +} +class rm extends Uc { + constructor() { + super(...arguments), this.tokens = [], this.elementStack = [], this.lastElementStack = [], this.nextTokenIndex = 0, this.stackSize = 0; + } + action() { + } + construct() { + } + parse(e) { + this.resetState(); + const t = this.lexer.tokenize(e, { mode: "partial" }); + return this.tokens = t.tokens, this.wrapper.input = [...this.tokens], this.mainRule.call(this.wrapper, {}), this.unorderedGroups.clear(), { + tokens: this.tokens, + elementStack: [...this.lastElementStack], + tokenIndex: this.nextTokenIndex + }; + } + rule(e, t) { + const r = this.wrapper.DEFINE_RULE(Gc(e.name), this.startImplementation(t).bind(this)); + return this.allRules.set(e.name, r), e.entry && (this.mainRule = r), r; + } + resetState() { + this.elementStack = [], this.lastElementStack = [], this.nextTokenIndex = 0, this.stackSize = 0; + } + startImplementation(e) { + return (t) => { + const r = this.keepStackSize(); + try { + e(t); + } finally { + this.resetStackSize(r); + } + }; + } + removeUnexpectedElements() { + this.elementStack.splice(this.stackSize); + } + keepStackSize() { + const e = this.elementStack.length; + return this.stackSize = e, e; + } + resetStackSize(e) { + this.removeUnexpectedElements(), this.stackSize = e; + } + consume(e, t, r) { + this.wrapper.wrapConsume(e, t), this.isRecording() || (this.lastElementStack = [...this.elementStack, r], this.nextTokenIndex = this.currIdx + 1); + } + subrule(e, t, r, i, s) { + this.before(i), this.wrapper.wrapSubrule(e, t, s), this.after(i); + } + before(e) { + this.isRecording() || this.elementStack.push(e); + } + after(e) { + if (!this.isRecording()) { + const t = this.elementStack.lastIndexOf(e); + t >= 0 && this.elementStack.splice(t); + } + } + get currIdx() { + return this.wrapper.currIdx; + } +} +const im = { + recoveryEnabled: !0, + nodeLocationTracking: "full", + skipValidations: !0, + errorMessageProvider: new Bc() +}; +class sm extends fp { + constructor(e, t) { + const r = t && "maxLookahead" in t; + super(e, Object.assign(Object.assign(Object.assign({}, im), { lookaheadStrategy: r ? new Qs({ maxLookahead: t.maxLookahead }) : new Op({ + // If validations are skipped, don't log the lookahead warnings + logging: t.skipValidations ? () => { + } : void 0 + }) }), t)); + } + get IS_RECORDING() { + return this.RECORDING_PHASE; + } + DEFINE_RULE(e, t) { + return this.RULE(e, t); + } + wrapSelfAnalysis() { + this.performSelfAnalysis(); + } + wrapConsume(e, t) { + return this.consume(e, t); + } + wrapSubrule(e, t, r) { + return this.subrule(e, t, { + ARGS: [r] + }); + } + wrapOr(e, t) { + this.or(e, t); + } + wrapOption(e, t) { + this.option(e, t); + } + wrapMany(e, t) { + this.many(e, t); + } + wrapAtLeastOne(e, t) { + this.atLeastOne(e, t); + } +} +function Vc(n, e, t) { + return am({ + parser: e, + tokens: t, + ruleNames: /* @__PURE__ */ new Map() + }, n), e; +} +function am(n, e) { + const t = Ul(e, !1), r = Z(e.rules).filter(we).filter((i) => t.has(i)); + for (const i of r) { + const s = Object.assign(Object.assign({}, n), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 }); + n.parser.rule(i, pt(s, i.definition)); + } +} +function pt(n, e, t = !1) { + let r; + if (dt(e)) + r = hm(n, e); + else if (li(e)) + r = om(n, e); + else if (ut(e)) + r = pt(n, e.terminal); + else if (Us(e)) + r = Kc(n, e); + else if (ft(e)) + r = lm(n, e); + else if (bl(e)) + r = um(n, e); + else if (Pl(e)) + r = dm(n, e); + else if (Bs(e)) + r = fm(n, e); + else if (Sd(e)) { + const i = n.consume++; + r = () => n.parser.consume(i, nt, e); + } else + throw new wl(e.$cstNode, `Unexpected element type: ${e.$type}`); + return Wc(n, t ? void 0 : ei(e), r, e.cardinality); +} +function om(n, e) { + const t = js(e); + return () => n.parser.action(t, e); +} +function lm(n, e) { + const t = e.rule.ref; + if (we(t)) { + const r = n.subrule++, i = t.fragment, s = e.arguments.length > 0 ? cm(t, e.arguments) : () => ({}); + return (a) => n.parser.subrule(r, jc(n, t), i, e, s(a)); + } else if (yt(t)) { + const r = n.consume++, i = Is(n, t.name); + return () => n.parser.consume(r, i, e); + } else if (t) + Jn(); + else + throw new wl(e.$cstNode, `Undefined rule: ${e.rule.$refText}`); +} +function cm(n, e) { + const t = e.map((r) => He(r.value)); + return (r) => { + const i = {}; + for (let s = 0; s < t.length; s++) { + const a = n.parameters[s], o = t[s]; + i[a.name] = o(r); + } + return i; + }; +} +function He(n) { + if (vd(n)) { + const e = He(n.left), t = He(n.right); + return (r) => e(r) || t(r); + } else if (Rd(n)) { + const e = He(n.left), t = He(n.right); + return (r) => e(r) && t(r); + } else if (Ad(n)) { + const e = He(n.value); + return (t) => !e(t); + } else if (Ed(n)) { + const e = n.parameter.ref.name; + return (t) => t !== void 0 && t[e] === !0; + } else if (Td(n)) { + const e = !!n.true; + return () => e; + } + Jn(); +} +function um(n, e) { + if (e.elements.length === 1) + return pt(n, e.elements[0]); + { + const t = []; + for (const i of e.elements) { + const s = { + // Since we handle the guard condition in the alternative already + // We can ignore the group guard condition inside + ALT: pt(n, i, !0) + }, a = ei(i); + a && (s.GATE = He(a)), t.push(s); + } + const r = n.or++; + return (i) => n.parser.alternatives(r, t.map((s) => { + const a = { + ALT: () => s.ALT(i) + }, o = s.GATE; + return o && (a.GATE = () => o(i)), a; + })); + } +} +function dm(n, e) { + if (e.elements.length === 1) + return pt(n, e.elements[0]); + const t = []; + for (const o of e.elements) { + const l = { + // Since we handle the guard condition in the alternative already + // We can ignore the group guard condition inside + ALT: pt(n, o, !0) + }, c = ei(o); + c && (l.GATE = He(c)), t.push(l); + } + const r = n.or++, i = (o, l) => { + const c = l.getRuleStack().join("-"); + return `uGroup_${o}_${c}`; + }, s = (o) => n.parser.alternatives(r, t.map((l, c) => { + const u = { ALT: () => !0 }, d = n.parser; + u.ALT = () => { + if (l.ALT(o), !d.isRecording()) { + const f = i(r, d); + d.unorderedGroups.get(f) || d.unorderedGroups.set(f, []); + const m = d.unorderedGroups.get(f); + typeof (m == null ? void 0 : m[c]) > "u" && (m[c] = !0); + } + }; + const h = l.GATE; + return h ? u.GATE = () => h(o) : u.GATE = () => { + const f = d.unorderedGroups.get(i(r, d)); + return !(f != null && f[c]); + }, u; + })), a = Wc(n, ei(e), s, "*"); + return (o) => { + a(o), n.parser.isRecording() || n.parser.unorderedGroups.delete(i(r, n.parser)); + }; +} +function fm(n, e) { + const t = e.elements.map((r) => pt(n, r)); + return (r) => t.forEach((i) => i(r)); +} +function ei(n) { + if (Bs(n)) + return n.guardCondition; +} +function Kc(n, e, t = e.terminal) { + if (t) + if (ft(t) && we(t.rule.ref)) { + const r = t.rule.ref, i = n.subrule++; + return (s) => n.parser.subrule(i, jc(n, r), !1, e, s); + } else if (ft(t) && yt(t.rule.ref)) { + const r = n.consume++, i = Is(n, t.rule.ref.name); + return () => n.parser.consume(r, i, e); + } else if (dt(t)) { + const r = n.consume++, i = Is(n, t.value); + return () => n.parser.consume(r, i, e); + } else + throw new Error("Could not build cross reference parser"); + else { + if (!e.type.ref) + throw new Error("Could not resolve reference to type: " + e.type.$refText); + const r = Kl(e.type.ref), i = r == null ? void 0 : r.terminal; + if (!i) + throw new Error("Could not find name assignment for type: " + js(e.type.ref)); + return Kc(n, e, i); + } +} +function hm(n, e) { + const t = n.consume++, r = n.tokens[e.value]; + if (!r) + throw new Error("Could not find token for keyword: " + e.value); + return () => n.parser.consume(t, r, e); +} +function Wc(n, e, t, r) { + const i = e && He(e); + if (!r) + if (i) { + const s = n.or++; + return (a) => n.parser.alternatives(s, [ + { + ALT: () => t(a), + GATE: () => i(a) + }, + { + ALT: Ha(), + GATE: () => !i(a) + } + ]); + } else + return t; + if (r === "*") { + const s = n.many++; + return (a) => n.parser.many(s, { + DEF: () => t(a), + GATE: i ? () => i(a) : void 0 + }); + } else if (r === "+") { + const s = n.many++; + if (i) { + const a = n.or++; + return (o) => n.parser.alternatives(a, [ + { + ALT: () => n.parser.atLeastOne(s, { + DEF: () => t(o) + }), + GATE: () => i(o) + }, + { + ALT: Ha(), + GATE: () => !i(o) + } + ]); + } else + return (a) => n.parser.atLeastOne(s, { + DEF: () => t(a) + }); + } else if (r === "?") { + const s = n.optional++; + return (a) => n.parser.optional(s, { + DEF: () => t(a), + GATE: i ? () => i(a) : void 0 + }); + } else + Jn(); +} +function jc(n, e) { + const t = pm(n, e), r = n.parser.getRule(t); + if (!r) + throw new Error(`Rule "${t}" not found."`); + return r; +} +function pm(n, e) { + if (we(e)) + return e.name; + if (n.ruleNames.has(e)) + return n.ruleNames.get(e); + { + let t = e, r = t.$container, i = e.$type; + for (; !we(r); ) + (Bs(r) || bl(r) || Pl(r)) && (i = r.elements.indexOf(t).toString() + ":" + i), t = r, r = r.$container; + return i = r.name + ":" + i, n.ruleNames.set(e, i), i; + } +} +function Is(n, e) { + const t = n.tokens[e]; + if (!t) + throw new Error(`Token "${e}" not found."`); + return t; +} +function mm(n) { + const e = n.Grammar, t = n.parser.Lexer, r = new rm(n); + return Vc(e, r, t.definition), r.finalize(), r; +} +function gm(n) { + const e = ym(n); + return e.finalize(), e; +} +function ym(n) { + const e = n.Grammar, t = n.parser.Lexer, r = new tm(n); + return Vc(e, r, t.definition); +} +class Hc { + constructor() { + this.diagnostics = []; + } + buildTokens(e, t) { + const r = Z(Ul(e, !1)), i = this.buildTerminalTokens(r), s = this.buildKeywordTokens(r, i, t); + return i.forEach((a) => { + const o = a.PATTERN; + typeof o == "object" && o && "test" in o && es(o) ? s.unshift(a) : s.push(a); + }), s; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + flushLexingReport(e) { + return { diagnostics: this.popDiagnostics() }; + } + popDiagnostics() { + const e = [...this.diagnostics]; + return this.diagnostics = [], e; + } + buildTerminalTokens(e) { + return e.filter(yt).filter((t) => !t.fragment).map((t) => this.buildTerminalToken(t)).toArray(); + } + buildTerminalToken(e) { + const t = Hs(e), r = this.requiresCustomPattern(t) ? this.regexPatternFunction(t) : t, i = { + name: e.name, + PATTERN: r + }; + return typeof r == "function" && (i.LINE_BREAKS = !0), e.hidden && (i.GROUP = es(t) ? de.SKIPPED : "hidden"), i; + } + requiresCustomPattern(e) { + return e.flags.includes("u") || e.flags.includes("s") ? !0 : !!(e.source.includes("?<=") || e.source.includes("? (t.lastIndex = i, t.exec(r)); + } + buildKeywordTokens(e, t, r) { + return e.filter(we).flatMap((i) => Qn(i).filter(dt)).distinct((i) => i.value).toArray().sort((i, s) => s.value.length - i.value.length).map((i) => this.buildKeywordToken(i, t, !!(r != null && r.caseInsensitive))); + } + buildKeywordToken(e, t, r) { + const i = this.buildKeywordPattern(e, r), s = { + name: e.value, + PATTERN: i, + LONGER_ALT: this.findLongerAlt(e, t) + }; + return typeof i == "function" && (s.LINE_BREAKS = !0), s; + } + buildKeywordPattern(e, t) { + return t ? new RegExp(Wd(e.value)) : e.value; + } + findLongerAlt(e, t) { + return t.reduce((r, i) => { + const s = i == null ? void 0 : i.PATTERN; + return s != null && s.source && jd("^" + s.source + "$", e.value) && r.push(i), r; + }, []); + } +} +class zc { + convert(e, t) { + let r = t.grammarSource; + if (Us(r) && (r = Yd(r)), ft(r)) { + const i = r.rule.ref; + if (!i) + throw new Error("This cst node was not parsed by a rule."); + return this.runConverter(i, e, t); + } + return e; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + runConverter(e, t, r) { + var i; + switch (e.name.toUpperCase()) { + case "INT": + return We.convertInt(t); + case "STRING": + return We.convertString(t); + case "ID": + return We.convertID(t); + } + switch ((i = nf(e)) === null || i === void 0 ? void 0 : i.toLowerCase()) { + case "number": + return We.convertNumber(t); + case "boolean": + return We.convertBoolean(t); + case "bigint": + return We.convertBigint(t); + case "date": + return We.convertDate(t); + default: + return t; + } + } +} +var We; +(function(n) { + function e(c) { + let u = ""; + for (let d = 1; d < c.length - 1; d++) { + const h = c.charAt(d); + if (h === "\\") { + const f = c.charAt(++d); + u += t(f); + } else + u += h; + } + return u; + } + n.convertString = e; + function t(c) { + switch (c) { + case "b": + return "\b"; + case "f": + return "\f"; + case "n": + return ` +`; + case "r": + return "\r"; + case "t": + return " "; + case "v": + return "\v"; + case "0": + return "\0"; + default: + return c; + } + } + function r(c) { + return c.charAt(0) === "^" ? c.substring(1) : c; + } + n.convertID = r; + function i(c) { + return parseInt(c); + } + n.convertInt = i; + function s(c) { + return BigInt(c); + } + n.convertBigint = s; + function a(c) { + return new Date(c); + } + n.convertDate = a; + function o(c) { + return Number(c); + } + n.convertNumber = o; + function l(c) { + return c.toLowerCase() === "true"; + } + n.convertBoolean = l; +})(We || (We = {})); +var qn = {}, Ri = {}; +Object.defineProperty(Ri, "__esModule", { value: !0 }); +let Ns; +function Cs() { + if (Ns === void 0) + throw new Error("No runtime abstraction layer installed"); + return Ns; +} +(function(n) { + function e(t) { + if (t === void 0) + throw new Error("No runtime abstraction layer provided"); + Ns = t; + } + n.install = e; +})(Cs || (Cs = {})); +Ri.default = Cs; +var se = {}; +Object.defineProperty(se, "__esModule", { value: !0 }); +se.stringArray = se.array = se.func = se.error = se.number = se.string = se.boolean = void 0; +function Tm(n) { + return n === !0 || n === !1; +} +se.boolean = Tm; +function qc(n) { + return typeof n == "string" || n instanceof String; +} +se.string = qc; +function Rm(n) { + return typeof n == "number" || n instanceof Number; +} +se.number = Rm; +function vm(n) { + return n instanceof Error; +} +se.error = vm; +function Am(n) { + return typeof n == "function"; +} +se.func = Am; +function Yc(n) { + return Array.isArray(n); +} +se.array = Yc; +function Em(n) { + return Yc(n) && n.every((e) => qc(e)); +} +se.stringArray = Em; +var Xt = {}; +Object.defineProperty(Xt, "__esModule", { value: !0 }); +var Xc = Xt.Emitter = Xt.Event = void 0; +const km = Ri; +var Zo; +(function(n) { + const e = { dispose() { + } }; + n.None = function() { + return e; + }; +})(Zo || (Xt.Event = Zo = {})); +class xm { + add(e, t = null, r) { + this._callbacks || (this._callbacks = [], this._contexts = []), this._callbacks.push(e), this._contexts.push(t), Array.isArray(r) && r.push({ dispose: () => this.remove(e, t) }); + } + remove(e, t = null) { + if (!this._callbacks) + return; + let r = !1; + for (let i = 0, s = this._callbacks.length; i < s; i++) + if (this._callbacks[i] === e) + if (this._contexts[i] === t) { + this._callbacks.splice(i, 1), this._contexts.splice(i, 1); + return; + } else + r = !0; + if (r) + throw new Error("When adding a listener with a context, you should remove it with the same context"); + } + invoke(...e) { + if (!this._callbacks) + return []; + const t = [], r = this._callbacks.slice(0), i = this._contexts.slice(0); + for (let s = 0, a = r.length; s < a; s++) + try { + t.push(r[s].apply(i[s], e)); + } catch (o) { + (0, km.default)().console.error(o); + } + return t; + } + isEmpty() { + return !this._callbacks || this._callbacks.length === 0; + } + dispose() { + this._callbacks = void 0, this._contexts = void 0; + } +} +class vi { + constructor(e) { + this._options = e; + } + /** + * For the public to allow to subscribe + * to events from this Emitter + */ + get event() { + return this._event || (this._event = (e, t, r) => { + this._callbacks || (this._callbacks = new xm()), this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty() && this._options.onFirstListenerAdd(this), this._callbacks.add(e, t); + const i = { + dispose: () => { + this._callbacks && (this._callbacks.remove(e, t), i.dispose = vi._noop, this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty() && this._options.onLastListenerRemove(this)); + } + }; + return Array.isArray(r) && r.push(i), i; + }), this._event; + } + /** + * To be kept private to fire an event to + * subscribers + */ + fire(e) { + this._callbacks && this._callbacks.invoke.call(this._callbacks, e); + } + dispose() { + this._callbacks && (this._callbacks.dispose(), this._callbacks = void 0); + } +} +Xc = Xt.Emitter = vi; +vi._noop = function() { +}; +var V; +Object.defineProperty(qn, "__esModule", { value: !0 }); +var aa = qn.CancellationTokenSource = V = qn.CancellationToken = void 0; +const $m = Ri, Sm = se, ws = Xt; +var ti; +(function(n) { + n.None = Object.freeze({ + isCancellationRequested: !1, + onCancellationRequested: ws.Event.None + }), n.Cancelled = Object.freeze({ + isCancellationRequested: !0, + onCancellationRequested: ws.Event.None + }); + function e(t) { + const r = t; + return r && (r === n.None || r === n.Cancelled || Sm.boolean(r.isCancellationRequested) && !!r.onCancellationRequested); + } + n.is = e; +})(ti || (V = qn.CancellationToken = ti = {})); +const Im = Object.freeze(function(n, e) { + const t = (0, $m.default)().timer.setTimeout(n.bind(e), 0); + return { dispose() { + t.dispose(); + } }; +}); +class el { + constructor() { + this._isCancelled = !1; + } + cancel() { + this._isCancelled || (this._isCancelled = !0, this._emitter && (this._emitter.fire(void 0), this.dispose())); + } + get isCancellationRequested() { + return this._isCancelled; + } + get onCancellationRequested() { + return this._isCancelled ? Im : (this._emitter || (this._emitter = new ws.Emitter()), this._emitter.event); + } + dispose() { + this._emitter && (this._emitter.dispose(), this._emitter = void 0); + } +} +class Nm { + get token() { + return this._token || (this._token = new el()), this._token; + } + cancel() { + this._token ? this._token.cancel() : this._token = ti.Cancelled; + } + dispose() { + this._token ? this._token instanceof el && this._token.dispose() : this._token = ti.None; + } +} +aa = qn.CancellationTokenSource = Nm; +function Cm() { + return new Promise((n) => { + typeof setImmediate > "u" ? setTimeout(n, 0) : setImmediate(n); + }); +} +let Cr = 0, wm = 10; +function _m() { + return Cr = performance.now(), new aa(); +} +const ni = Symbol("OperationCancelled"); +function Ai(n) { + return n === ni; +} +async function Ae(n) { + if (n === V.None) + return; + const e = performance.now(); + if (e - Cr >= wm && (Cr = e, await Cm(), Cr = performance.now()), n.isCancellationRequested) + throw ni; +} +class oa { + constructor() { + this.promise = new Promise((e, t) => { + this.resolve = (r) => (e(r), this), this.reject = (r) => (t(r), this); + }); + } +} +class Yn { + constructor(e, t, r, i) { + this._uri = e, this._languageId = t, this._version = r, this._content = i, this._lineOffsets = void 0; + } + get uri() { + return this._uri; + } + get languageId() { + return this._languageId; + } + get version() { + return this._version; + } + getText(e) { + if (e) { + const t = this.offsetAt(e.start), r = this.offsetAt(e.end); + return this._content.substring(t, r); + } + return this._content; + } + update(e, t) { + for (const r of e) + if (Yn.isIncremental(r)) { + const i = Qc(r.range), s = this.offsetAt(i.start), a = this.offsetAt(i.end); + this._content = this._content.substring(0, s) + r.text + this._content.substring(a, this._content.length); + const o = Math.max(i.start.line, 0), l = Math.max(i.end.line, 0); + let c = this._lineOffsets; + const u = tl(r.text, !1, s); + if (l - o === u.length) + for (let h = 0, f = u.length; h < f; h++) + c[h + o + 1] = u[h]; + else + u.length < 1e4 ? c.splice(o + 1, l - o, ...u) : this._lineOffsets = c = c.slice(0, o + 1).concat(u, c.slice(l + 1)); + const d = r.text.length - (a - s); + if (d !== 0) + for (let h = o + 1 + u.length, f = c.length; h < f; h++) + c[h] = c[h] + d; + } else if (Yn.isFull(r)) + this._content = r.text, this._lineOffsets = void 0; + else + throw new Error("Unknown change event received"); + this._version = t; + } + getLineOffsets() { + return this._lineOffsets === void 0 && (this._lineOffsets = tl(this._content, !0)), this._lineOffsets; + } + positionAt(e) { + e = Math.max(Math.min(e, this._content.length), 0); + const t = this.getLineOffsets(); + let r = 0, i = t.length; + if (i === 0) + return { line: 0, character: e }; + for (; r < i; ) { + const a = Math.floor((r + i) / 2); + t[a] > e ? i = a : r = a + 1; + } + const s = r - 1; + return e = this.ensureBeforeEOL(e, t[s]), { line: s, character: e - t[s] }; + } + offsetAt(e) { + const t = this.getLineOffsets(); + if (e.line >= t.length) + return this._content.length; + if (e.line < 0) + return 0; + const r = t[e.line]; + if (e.character <= 0) + return r; + const i = e.line + 1 < t.length ? t[e.line + 1] : this._content.length, s = Math.min(r + e.character, i); + return this.ensureBeforeEOL(s, r); + } + ensureBeforeEOL(e, t) { + for (; e > t && Jc(this._content.charCodeAt(e - 1)); ) + e--; + return e; + } + get lineCount() { + return this.getLineOffsets().length; + } + static isIncremental(e) { + const t = e; + return t != null && typeof t.text == "string" && t.range !== void 0 && (t.rangeLength === void 0 || typeof t.rangeLength == "number"); + } + static isFull(e) { + const t = e; + return t != null && typeof t.text == "string" && t.range === void 0 && t.rangeLength === void 0; + } +} +var _s; +(function(n) { + function e(i, s, a, o) { + return new Yn(i, s, a, o); + } + n.create = e; + function t(i, s, a) { + if (i instanceof Yn) + return i.update(s, a), i; + throw new Error("TextDocument.update: document must be created by TextDocument.create"); + } + n.update = t; + function r(i, s) { + const a = i.getText(), o = Ls(s.map(Lm), (u, d) => { + const h = u.range.start.line - d.range.start.line; + return h === 0 ? u.range.start.character - d.range.start.character : h; + }); + let l = 0; + const c = []; + for (const u of o) { + const d = i.offsetAt(u.range.start); + if (d < l) + throw new Error("Overlapping edit"); + d > l && c.push(a.substring(l, d)), u.newText.length && c.push(u.newText), l = i.offsetAt(u.range.end); + } + return c.push(a.substr(l)), c.join(""); + } + n.applyEdits = r; +})(_s || (_s = {})); +function Ls(n, e) { + if (n.length <= 1) + return n; + const t = n.length / 2 | 0, r = n.slice(0, t), i = n.slice(t); + Ls(r, e), Ls(i, e); + let s = 0, a = 0, o = 0; + for (; s < r.length && a < i.length; ) + e(r[s], i[a]) <= 0 ? n[o++] = r[s++] : n[o++] = i[a++]; + for (; s < r.length; ) + n[o++] = r[s++]; + for (; a < i.length; ) + n[o++] = i[a++]; + return n; +} +function tl(n, e, t = 0) { + const r = e ? [t] : []; + for (let i = 0; i < n.length; i++) { + const s = n.charCodeAt(i); + Jc(s) && (s === 13 && i + 1 < n.length && n.charCodeAt(i + 1) === 10 && i++, r.push(t + i + 1)); + } + return r; +} +function Jc(n) { + return n === 13 || n === 10; +} +function Qc(n) { + const e = n.start, t = n.end; + return e.line > t.line || e.line === t.line && e.character > t.character ? { start: t, end: e } : n; +} +function Lm(n) { + const e = Qc(n.range); + return e !== n.range ? { newText: n.newText, range: e } : n; +} +var Zc; +(() => { + var n = { 470: (i) => { + function s(l) { + if (typeof l != "string") throw new TypeError("Path must be a string. Received " + JSON.stringify(l)); + } + function a(l, c) { + for (var u, d = "", h = 0, f = -1, m = 0, g = 0; g <= l.length; ++g) { + if (g < l.length) u = l.charCodeAt(g); + else { + if (u === 47) break; + u = 47; + } + if (u === 47) { + if (!(f === g - 1 || m === 1)) if (f !== g - 1 && m === 2) { + if (d.length < 2 || h !== 2 || d.charCodeAt(d.length - 1) !== 46 || d.charCodeAt(d.length - 2) !== 46) { + if (d.length > 2) { + var v = d.lastIndexOf("/"); + if (v !== d.length - 1) { + v === -1 ? (d = "", h = 0) : h = (d = d.slice(0, v)).length - 1 - d.lastIndexOf("/"), f = g, m = 0; + continue; + } + } else if (d.length === 2 || d.length === 1) { + d = "", h = 0, f = g, m = 0; + continue; + } + } + c && (d.length > 0 ? d += "/.." : d = "..", h = 2); + } else d.length > 0 ? d += "/" + l.slice(f + 1, g) : d = l.slice(f + 1, g), h = g - f - 1; + f = g, m = 0; + } else u === 46 && m !== -1 ? ++m : m = -1; + } + return d; + } + var o = { resolve: function() { + for (var l, c = "", u = !1, d = arguments.length - 1; d >= -1 && !u; d--) { + var h; + d >= 0 ? h = arguments[d] : (l === void 0 && (l = process.cwd()), h = l), s(h), h.length !== 0 && (c = h + "/" + c, u = h.charCodeAt(0) === 47); + } + return c = a(c, !u), u ? c.length > 0 ? "/" + c : "/" : c.length > 0 ? c : "."; + }, normalize: function(l) { + if (s(l), l.length === 0) return "."; + var c = l.charCodeAt(0) === 47, u = l.charCodeAt(l.length - 1) === 47; + return (l = a(l, !c)).length !== 0 || c || (l = "."), l.length > 0 && u && (l += "/"), c ? "/" + l : l; + }, isAbsolute: function(l) { + return s(l), l.length > 0 && l.charCodeAt(0) === 47; + }, join: function() { + if (arguments.length === 0) return "."; + for (var l, c = 0; c < arguments.length; ++c) { + var u = arguments[c]; + s(u), u.length > 0 && (l === void 0 ? l = u : l += "/" + u); + } + return l === void 0 ? "." : o.normalize(l); + }, relative: function(l, c) { + if (s(l), s(c), l === c || (l = o.resolve(l)) === (c = o.resolve(c))) return ""; + for (var u = 1; u < l.length && l.charCodeAt(u) === 47; ++u) ; + for (var d = l.length, h = d - u, f = 1; f < c.length && c.charCodeAt(f) === 47; ++f) ; + for (var m = c.length - f, g = h < m ? h : m, v = -1, y = 0; y <= g; ++y) { + if (y === g) { + if (m > g) { + if (c.charCodeAt(f + y) === 47) return c.slice(f + y + 1); + if (y === 0) return c.slice(f + y); + } else h > g && (l.charCodeAt(u + y) === 47 ? v = y : y === 0 && (v = 0)); + break; + } + var A = l.charCodeAt(u + y); + if (A !== c.charCodeAt(f + y)) break; + A === 47 && (v = y); + } + var R = ""; + for (y = u + v + 1; y <= d; ++y) y !== d && l.charCodeAt(y) !== 47 || (R.length === 0 ? R += ".." : R += "/.."); + return R.length > 0 ? R + c.slice(f + v) : (f += v, c.charCodeAt(f) === 47 && ++f, c.slice(f)); + }, _makeLong: function(l) { + return l; + }, dirname: function(l) { + if (s(l), l.length === 0) return "."; + for (var c = l.charCodeAt(0), u = c === 47, d = -1, h = !0, f = l.length - 1; f >= 1; --f) if ((c = l.charCodeAt(f)) === 47) { + if (!h) { + d = f; + break; + } + } else h = !1; + return d === -1 ? u ? "/" : "." : u && d === 1 ? "//" : l.slice(0, d); + }, basename: function(l, c) { + if (c !== void 0 && typeof c != "string") throw new TypeError('"ext" argument must be a string'); + s(l); + var u, d = 0, h = -1, f = !0; + if (c !== void 0 && c.length > 0 && c.length <= l.length) { + if (c.length === l.length && c === l) return ""; + var m = c.length - 1, g = -1; + for (u = l.length - 1; u >= 0; --u) { + var v = l.charCodeAt(u); + if (v === 47) { + if (!f) { + d = u + 1; + break; + } + } else g === -1 && (f = !1, g = u + 1), m >= 0 && (v === c.charCodeAt(m) ? --m == -1 && (h = u) : (m = -1, h = g)); + } + return d === h ? h = g : h === -1 && (h = l.length), l.slice(d, h); + } + for (u = l.length - 1; u >= 0; --u) if (l.charCodeAt(u) === 47) { + if (!f) { + d = u + 1; + break; + } + } else h === -1 && (f = !1, h = u + 1); + return h === -1 ? "" : l.slice(d, h); + }, extname: function(l) { + s(l); + for (var c = -1, u = 0, d = -1, h = !0, f = 0, m = l.length - 1; m >= 0; --m) { + var g = l.charCodeAt(m); + if (g !== 47) d === -1 && (h = !1, d = m + 1), g === 46 ? c === -1 ? c = m : f !== 1 && (f = 1) : c !== -1 && (f = -1); + else if (!h) { + u = m + 1; + break; + } + } + return c === -1 || d === -1 || f === 0 || f === 1 && c === d - 1 && c === u + 1 ? "" : l.slice(c, d); + }, format: function(l) { + if (l === null || typeof l != "object") throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof l); + return function(c, u) { + var d = u.dir || u.root, h = u.base || (u.name || "") + (u.ext || ""); + return d ? d === u.root ? d + h : d + "/" + h : h; + }(0, l); + }, parse: function(l) { + s(l); + var c = { root: "", dir: "", base: "", ext: "", name: "" }; + if (l.length === 0) return c; + var u, d = l.charCodeAt(0), h = d === 47; + h ? (c.root = "/", u = 1) : u = 0; + for (var f = -1, m = 0, g = -1, v = !0, y = l.length - 1, A = 0; y >= u; --y) if ((d = l.charCodeAt(y)) !== 47) g === -1 && (v = !1, g = y + 1), d === 46 ? f === -1 ? f = y : A !== 1 && (A = 1) : f !== -1 && (A = -1); + else if (!v) { + m = y + 1; + break; + } + return f === -1 || g === -1 || A === 0 || A === 1 && f === g - 1 && f === m + 1 ? g !== -1 && (c.base = c.name = m === 0 && h ? l.slice(1, g) : l.slice(m, g)) : (m === 0 && h ? (c.name = l.slice(1, f), c.base = l.slice(1, g)) : (c.name = l.slice(m, f), c.base = l.slice(m, g)), c.ext = l.slice(f, g)), m > 0 ? c.dir = l.slice(0, m - 1) : h && (c.dir = "/"), c; + }, sep: "/", delimiter: ":", win32: null, posix: null }; + o.posix = o, i.exports = o; + } }, e = {}; + function t(i) { + var s = e[i]; + if (s !== void 0) return s.exports; + var a = e[i] = { exports: {} }; + return n[i](a, a.exports, t), a.exports; + } + t.d = (i, s) => { + for (var a in s) t.o(s, a) && !t.o(i, a) && Object.defineProperty(i, a, { enumerable: !0, get: s[a] }); + }, t.o = (i, s) => Object.prototype.hasOwnProperty.call(i, s), t.r = (i) => { + typeof Symbol < "u" && Symbol.toStringTag && Object.defineProperty(i, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(i, "__esModule", { value: !0 }); + }; + var r = {}; + (() => { + let i; + t.r(r), t.d(r, { URI: () => h, Utils: () => Ie }), typeof process == "object" ? i = process.platform === "win32" : typeof navigator == "object" && (i = navigator.userAgent.indexOf("Windows") >= 0); + const s = /^\w[\w\d+.-]*$/, a = /^\//, o = /^\/\//; + function l(x, T) { + if (!x.scheme && T) throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${x.authority}", path: "${x.path}", query: "${x.query}", fragment: "${x.fragment}"}`); + if (x.scheme && !s.test(x.scheme)) throw new Error("[UriError]: Scheme contains illegal characters."); + if (x.path) { + if (x.authority) { + if (!a.test(x.path)) throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character'); + } else if (o.test(x.path)) throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")'); + } + } + const c = "", u = "/", d = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/; + class h { + constructor(T, E, S, O, L, _ = !1) { + Qe(this, "scheme"); + Qe(this, "authority"); + Qe(this, "path"); + Qe(this, "query"); + Qe(this, "fragment"); + typeof T == "object" ? (this.scheme = T.scheme || c, this.authority = T.authority || c, this.path = T.path || c, this.query = T.query || c, this.fragment = T.fragment || c) : (this.scheme = /* @__PURE__ */ function(Te, q) { + return Te || q ? Te : "file"; + }(T, _), this.authority = E || c, this.path = function(Te, q) { + switch (Te) { + case "https": + case "http": + case "file": + q ? q[0] !== u && (q = u + q) : q = u; + } + return q; + }(this.scheme, S || c), this.query = O || c, this.fragment = L || c, l(this, _)); + } + static isUri(T) { + return T instanceof h || !!T && typeof T.authority == "string" && typeof T.fragment == "string" && typeof T.path == "string" && typeof T.query == "string" && typeof T.scheme == "string" && typeof T.fsPath == "string" && typeof T.with == "function" && typeof T.toString == "function"; + } + get fsPath() { + return A(this); + } + with(T) { + if (!T) return this; + let { scheme: E, authority: S, path: O, query: L, fragment: _ } = T; + return E === void 0 ? E = this.scheme : E === null && (E = c), S === void 0 ? S = this.authority : S === null && (S = c), O === void 0 ? O = this.path : O === null && (O = c), L === void 0 ? L = this.query : L === null && (L = c), _ === void 0 ? _ = this.fragment : _ === null && (_ = c), E === this.scheme && S === this.authority && O === this.path && L === this.query && _ === this.fragment ? this : new m(E, S, O, L, _); + } + static parse(T, E = !1) { + const S = d.exec(T); + return S ? new m(S[2] || c, re(S[4] || c), re(S[5] || c), re(S[7] || c), re(S[9] || c), E) : new m(c, c, c, c, c); + } + static file(T) { + let E = c; + if (i && (T = T.replace(/\\/g, u)), T[0] === u && T[1] === u) { + const S = T.indexOf(u, 2); + S === -1 ? (E = T.substring(2), T = u) : (E = T.substring(2, S), T = T.substring(S) || u); + } + return new m("file", E, T, c, c); + } + static from(T) { + const E = new m(T.scheme, T.authority, T.path, T.query, T.fragment); + return l(E, !0), E; + } + toString(T = !1) { + return R(this, T); + } + toJSON() { + return this; + } + static revive(T) { + if (T) { + if (T instanceof h) return T; + { + const E = new m(T); + return E._formatted = T.external, E._fsPath = T._sep === f ? T.fsPath : null, E; + } + } + return T; + } + } + const f = i ? 1 : void 0; + class m extends h { + constructor() { + super(...arguments); + Qe(this, "_formatted", null); + Qe(this, "_fsPath", null); + } + get fsPath() { + return this._fsPath || (this._fsPath = A(this)), this._fsPath; + } + toString(E = !1) { + return E ? R(this, !0) : (this._formatted || (this._formatted = R(this, !1)), this._formatted); + } + toJSON() { + const E = { $mid: 1 }; + return this._fsPath && (E.fsPath = this._fsPath, E._sep = f), this._formatted && (E.external = this._formatted), this.path && (E.path = this.path), this.scheme && (E.scheme = this.scheme), this.authority && (E.authority = this.authority), this.query && (E.query = this.query), this.fragment && (E.fragment = this.fragment), E; + } + } + const g = { 58: "%3A", 47: "%2F", 63: "%3F", 35: "%23", 91: "%5B", 93: "%5D", 64: "%40", 33: "%21", 36: "%24", 38: "%26", 39: "%27", 40: "%28", 41: "%29", 42: "%2A", 43: "%2B", 44: "%2C", 59: "%3B", 61: "%3D", 32: "%20" }; + function v(x, T, E) { + let S, O = -1; + for (let L = 0; L < x.length; L++) { + const _ = x.charCodeAt(L); + if (_ >= 97 && _ <= 122 || _ >= 65 && _ <= 90 || _ >= 48 && _ <= 57 || _ === 45 || _ === 46 || _ === 95 || _ === 126 || T && _ === 47 || E && _ === 91 || E && _ === 93 || E && _ === 58) O !== -1 && (S += encodeURIComponent(x.substring(O, L)), O = -1), S !== void 0 && (S += x.charAt(L)); + else { + S === void 0 && (S = x.substr(0, L)); + const Te = g[_]; + Te !== void 0 ? (O !== -1 && (S += encodeURIComponent(x.substring(O, L)), O = -1), S += Te) : O === -1 && (O = L); + } + } + return O !== -1 && (S += encodeURIComponent(x.substring(O))), S !== void 0 ? S : x; + } + function y(x) { + let T; + for (let E = 0; E < x.length; E++) { + const S = x.charCodeAt(E); + S === 35 || S === 63 ? (T === void 0 && (T = x.substr(0, E)), T += g[S]) : T !== void 0 && (T += x[E]); + } + return T !== void 0 ? T : x; + } + function A(x, T) { + let E; + return E = x.authority && x.path.length > 1 && x.scheme === "file" ? `//${x.authority}${x.path}` : x.path.charCodeAt(0) === 47 && (x.path.charCodeAt(1) >= 65 && x.path.charCodeAt(1) <= 90 || x.path.charCodeAt(1) >= 97 && x.path.charCodeAt(1) <= 122) && x.path.charCodeAt(2) === 58 ? x.path[1].toLowerCase() + x.path.substr(2) : x.path, i && (E = E.replace(/\//g, "\\")), E; + } + function R(x, T) { + const E = T ? y : v; + let S = "", { scheme: O, authority: L, path: _, query: Te, fragment: q } = x; + if (O && (S += O, S += ":"), (L || O === "file") && (S += u, S += u), L) { + let K = L.indexOf("@"); + if (K !== -1) { + const ot = L.substr(0, K); + L = L.substr(K + 1), K = ot.lastIndexOf(":"), K === -1 ? S += E(ot, !1, !1) : (S += E(ot.substr(0, K), !1, !1), S += ":", S += E(ot.substr(K + 1), !1, !0)), S += "@"; + } + L = L.toLowerCase(), K = L.lastIndexOf(":"), K === -1 ? S += E(L, !1, !0) : (S += E(L.substr(0, K), !1, !0), S += L.substr(K)); + } + if (_) { + if (_.length >= 3 && _.charCodeAt(0) === 47 && _.charCodeAt(2) === 58) { + const K = _.charCodeAt(1); + K >= 65 && K <= 90 && (_ = `/${String.fromCharCode(K + 32)}:${_.substr(3)}`); + } else if (_.length >= 2 && _.charCodeAt(1) === 58) { + const K = _.charCodeAt(0); + K >= 65 && K <= 90 && (_ = `${String.fromCharCode(K + 32)}:${_.substr(2)}`); + } + S += E(_, !0, !1); + } + return Te && (S += "?", S += E(Te, !1, !1)), q && (S += "#", S += T ? q : v(q, !1, !1)), S; + } + function I(x) { + try { + return decodeURIComponent(x); + } catch { + return x.length > 3 ? x.substr(0, 3) + I(x.substr(3)) : x; + } + } + const F = /(%[0-9A-Za-z][0-9A-Za-z])+/g; + function re(x) { + return x.match(F) ? x.replace(F, (T) => I(T)) : x; + } + var _e = t(470); + const ye = _e.posix || _e, De = "/"; + var Ie; + (function(x) { + x.joinPath = function(T, ...E) { + return T.with({ path: ye.join(T.path, ...E) }); + }, x.resolvePath = function(T, ...E) { + let S = T.path, O = !1; + S[0] !== De && (S = De + S, O = !0); + let L = ye.resolve(S, ...E); + return O && L[0] === De && !T.authority && (L = L.substring(1)), T.with({ path: L }); + }, x.dirname = function(T) { + if (T.path.length === 0 || T.path === De) return T; + let E = ye.dirname(T.path); + return E.length === 1 && E.charCodeAt(0) === 46 && (E = ""), T.with({ path: E }); + }, x.basename = function(T) { + return ye.basename(T.path); + }, x.extname = function(T) { + return ye.extname(T.path); + }; + })(Ie || (Ie = {})); + })(), Zc = r; +})(); +const { URI: mt, Utils: on } = Zc; +var it; +(function(n) { + n.basename = on.basename, n.dirname = on.dirname, n.extname = on.extname, n.joinPath = on.joinPath, n.resolvePath = on.resolvePath; + function e(i, s) { + return (i == null ? void 0 : i.toString()) === (s == null ? void 0 : s.toString()); + } + n.equals = e; + function t(i, s) { + const a = typeof i == "string" ? i : i.path, o = typeof s == "string" ? s : s.path, l = a.split("/").filter((f) => f.length > 0), c = o.split("/").filter((f) => f.length > 0); + let u = 0; + for (; u < l.length && l[u] === c[u]; u++) + ; + const d = "../".repeat(l.length - u), h = c.slice(u).join("/"); + return d + h; + } + n.relative = t; + function r(i) { + return mt.parse(i.toString()).toString(); + } + n.normalize = r; +})(it || (it = {})); +var U; +(function(n) { + n[n.Changed = 0] = "Changed", n[n.Parsed = 1] = "Parsed", n[n.IndexedContent = 2] = "IndexedContent", n[n.ComputedScopes = 3] = "ComputedScopes", n[n.Linked = 4] = "Linked", n[n.IndexedReferences = 5] = "IndexedReferences", n[n.Validated = 6] = "Validated"; +})(U || (U = {})); +class Om { + constructor(e) { + this.serviceRegistry = e.ServiceRegistry, this.textDocuments = e.workspace.TextDocuments, this.fileSystemProvider = e.workspace.FileSystemProvider; + } + async fromUri(e, t = V.None) { + const r = await this.fileSystemProvider.readFile(e); + return this.createAsync(e, r, t); + } + fromTextDocument(e, t, r) { + return t = t ?? mt.parse(e.uri), V.is(r) ? this.createAsync(t, e, r) : this.create(t, e, r); + } + fromString(e, t, r) { + return V.is(r) ? this.createAsync(t, e, r) : this.create(t, e, r); + } + fromModel(e, t) { + return this.create(t, { $model: e }); + } + create(e, t, r) { + if (typeof t == "string") { + const i = this.parse(e, t, r); + return this.createLangiumDocument(i, e, void 0, t); + } else if ("$model" in t) { + const i = { value: t.$model, parserErrors: [], lexerErrors: [] }; + return this.createLangiumDocument(i, e); + } else { + const i = this.parse(e, t.getText(), r); + return this.createLangiumDocument(i, e, t); + } + } + async createAsync(e, t, r) { + if (typeof t == "string") { + const i = await this.parseAsync(e, t, r); + return this.createLangiumDocument(i, e, void 0, t); + } else { + const i = await this.parseAsync(e, t.getText(), r); + return this.createLangiumDocument(i, e, t); + } + } + /** + * Create a LangiumDocument from a given parse result. + * + * A TextDocument is created on demand if it is not provided as argument here. Usually this + * should not be necessary because the main purpose of the TextDocument is to convert between + * text ranges and offsets, which is done solely in LSP request handling. + * + * With the introduction of {@link update} below this method is supposed to be mainly called + * during workspace initialization and on addition/recognition of new files, while changes in + * existing documents are processed via {@link update}. + */ + createLangiumDocument(e, t, r, i) { + let s; + if (r) + s = { + parseResult: e, + uri: t, + state: U.Parsed, + references: [], + textDocument: r + }; + else { + const a = this.createTextDocumentGetter(t, i); + s = { + parseResult: e, + uri: t, + state: U.Parsed, + references: [], + get textDocument() { + return a(); + } + }; + } + return e.value.$document = s, s; + } + async update(e, t) { + var r, i; + const s = (r = e.parseResult.value.$cstNode) === null || r === void 0 ? void 0 : r.root.fullText, a = (i = this.textDocuments) === null || i === void 0 ? void 0 : i.get(e.uri.toString()), o = a ? a.getText() : await this.fileSystemProvider.readFile(e.uri); + if (a) + Object.defineProperty(e, "textDocument", { + value: a + }); + else { + const l = this.createTextDocumentGetter(e.uri, o); + Object.defineProperty(e, "textDocument", { + get: l + }); + } + return s !== o && (e.parseResult = await this.parseAsync(e.uri, o, t), e.parseResult.value.$document = e), e.state = U.Parsed, e; + } + parse(e, t, r) { + return this.serviceRegistry.getServices(e).parser.LangiumParser.parse(t, r); + } + parseAsync(e, t, r) { + return this.serviceRegistry.getServices(e).parser.AsyncParser.parse(t, r); + } + createTextDocumentGetter(e, t) { + const r = this.serviceRegistry; + let i; + return () => i ?? (i = _s.create(e.toString(), r.getServices(e).LanguageMetaData.languageId, 0, t ?? "")); + } +} +class bm { + constructor(e) { + this.documentMap = /* @__PURE__ */ new Map(), this.langiumDocumentFactory = e.workspace.LangiumDocumentFactory, this.serviceRegistry = e.ServiceRegistry; + } + get all() { + return Z(this.documentMap.values()); + } + addDocument(e) { + const t = e.uri.toString(); + if (this.documentMap.has(t)) + throw new Error(`A document with the URI '${t}' is already present.`); + this.documentMap.set(t, e); + } + getDocument(e) { + const t = e.toString(); + return this.documentMap.get(t); + } + async getOrCreateDocument(e, t) { + let r = this.getDocument(e); + return r || (r = await this.langiumDocumentFactory.fromUri(e, t), this.addDocument(r), r); + } + createDocument(e, t, r) { + if (r) + return this.langiumDocumentFactory.fromString(t, e, r).then((i) => (this.addDocument(i), i)); + { + const i = this.langiumDocumentFactory.fromString(t, e); + return this.addDocument(i), i; + } + } + hasDocument(e) { + return this.documentMap.has(e.toString()); + } + invalidateDocument(e) { + const t = e.toString(), r = this.documentMap.get(t); + return r && (this.serviceRegistry.getServices(e).references.Linker.unlink(r), r.state = U.Changed, r.precomputedScopes = void 0, r.diagnostics = void 0), r; + } + deleteDocument(e) { + const t = e.toString(), r = this.documentMap.get(t); + return r && (r.state = U.Changed, this.documentMap.delete(t)), r; + } +} +const Fi = Symbol("ref_resolving"); +class Pm { + constructor(e) { + this.reflection = e.shared.AstReflection, this.langiumDocuments = () => e.shared.workspace.LangiumDocuments, this.scopeProvider = e.references.ScopeProvider, this.astNodeLocator = e.workspace.AstNodeLocator; + } + async link(e, t = V.None) { + for (const r of It(e.parseResult.value)) + await Ae(t), Dl(r).forEach((i) => this.doLink(i, e)); + } + doLink(e, t) { + var r; + const i = e.reference; + if (i._ref === void 0) { + i._ref = Fi; + try { + const s = this.getCandidate(e); + if (Er(s)) + i._ref = s; + else if (i._nodeDescription = s, this.langiumDocuments().hasDocument(s.documentUri)) { + const a = this.loadAstNode(s); + i._ref = a ?? this.createLinkingError(e, s); + } else + i._ref = void 0; + } catch (s) { + console.error(`An error occurred while resolving reference to '${i.$refText}':`, s); + const a = (r = s.message) !== null && r !== void 0 ? r : String(s); + i._ref = Object.assign(Object.assign({}, e), { message: `An error occurred while resolving reference to '${i.$refText}': ${a}` }); + } + t.references.push(i); + } + } + unlink(e) { + for (const t of e.references) + delete t._ref, delete t._nodeDescription; + e.references = []; + } + getCandidate(e) { + const r = this.scopeProvider.getScope(e).getElement(e.reference.$refText); + return r ?? this.createLinkingError(e); + } + buildReference(e, t, r, i) { + const s = this, a = { + $refNode: r, + $refText: i, + get ref() { + var o; + if (ae(this._ref)) + return this._ref; + if (ld(this._nodeDescription)) { + const l = s.loadAstNode(this._nodeDescription); + this._ref = l ?? s.createLinkingError({ reference: a, container: e, property: t }, this._nodeDescription); + } else if (this._ref === void 0) { + this._ref = Fi; + const l = Zi(e).$document, c = s.getLinkedNode({ reference: a, container: e, property: t }); + if (c.error && l && l.state < U.ComputedScopes) + return this._ref = void 0; + this._ref = (o = c.node) !== null && o !== void 0 ? o : c.error, this._nodeDescription = c.descr, l == null || l.references.push(this); + } else if (this._ref === Fi) + throw new Error(`Cyclic reference resolution detected: ${s.astNodeLocator.getAstNodePath(e)}/${t} (symbol '${i}')`); + return ae(this._ref) ? this._ref : void 0; + }, + get $nodeDescription() { + return this._nodeDescription; + }, + get error() { + return Er(this._ref) ? this._ref : void 0; + } + }; + return a; + } + getLinkedNode(e) { + var t; + try { + const r = this.getCandidate(e); + if (Er(r)) + return { error: r }; + const i = this.loadAstNode(r); + return i ? { node: i, descr: r } : { + descr: r, + error: this.createLinkingError(e, r) + }; + } catch (r) { + console.error(`An error occurred while resolving reference to '${e.reference.$refText}':`, r); + const i = (t = r.message) !== null && t !== void 0 ? t : String(r); + return { + error: Object.assign(Object.assign({}, e), { message: `An error occurred while resolving reference to '${e.reference.$refText}': ${i}` }) + }; + } + } + loadAstNode(e) { + if (e.node) + return e.node; + const t = this.langiumDocuments().getDocument(e.documentUri); + if (t) + return this.astNodeLocator.getAstNode(t.parseResult.value, e.path); + } + createLinkingError(e, t) { + const r = Zi(e.container).$document; + r && r.state < U.ComputedScopes && console.warn(`Attempted reference resolution before document reached ComputedScopes state (${r.uri}).`); + const i = this.reflection.getReferenceType(e); + return Object.assign(Object.assign({}, e), { message: `Could not resolve reference to ${i} named '${e.reference.$refText}'.`, targetDescription: t }); + } +} +function Mm(n) { + return typeof n.name == "string"; +} +class Dm { + getName(e) { + if (Mm(e)) + return e.name; + } + getNameNode(e) { + return Vl(e.$cstNode, "name"); + } +} +class Fm { + constructor(e) { + this.nameProvider = e.references.NameProvider, this.index = e.shared.workspace.IndexManager, this.nodeLocator = e.workspace.AstNodeLocator; + } + findDeclaration(e) { + if (e) { + const t = ef(e), r = e.astNode; + if (t && r) { + const i = r[t.feature]; + if (Ge(i)) + return i.ref; + if (Array.isArray(i)) { + for (const s of i) + if (Ge(s) && s.$refNode && s.$refNode.offset <= e.offset && s.$refNode.end >= e.end) + return s.ref; + } + } + if (r) { + const i = this.nameProvider.getNameNode(r); + if (i && (i === e || dd(e, i))) + return r; + } + } + } + findDeclarationNode(e) { + const t = this.findDeclaration(e); + if (t != null && t.$cstNode) { + const r = this.nameProvider.getNameNode(t); + return r ?? t.$cstNode; + } + } + findReferences(e, t) { + const r = []; + if (t.includeDeclaration) { + const s = this.getReferenceToSelf(e); + s && r.push(s); + } + let i = this.index.findAllReferences(e, this.nodeLocator.getAstNodePath(e)); + return t.documentUri && (i = i.filter((s) => it.equals(s.sourceUri, t.documentUri))), r.push(...i), Z(r); + } + getReferenceToSelf(e) { + const t = this.nameProvider.getNameNode(e); + if (t) { + const r = et(e), i = this.nodeLocator.getAstNodePath(e); + return { + sourceUri: r.uri, + sourcePath: i, + targetUri: r.uri, + targetPath: i, + segment: Dr(t), + local: !0 + }; + } + } +} +class ri { + constructor(e) { + if (this.map = /* @__PURE__ */ new Map(), e) + for (const [t, r] of e) + this.add(t, r); + } + /** + * The total number of values in the multimap. + */ + get size() { + return Xi.sum(Z(this.map.values()).map((e) => e.length)); + } + /** + * Clear all entries in the multimap. + */ + clear() { + this.map.clear(); + } + /** + * Operates differently depending on whether a `value` is given: + * * With a value, this method deletes the specific key / value pair from the multimap. + * * Without a value, all values associated with the given key are deleted. + * + * @returns `true` if a value existed and has been removed, or `false` if the specified + * key / value does not exist. + */ + delete(e, t) { + if (t === void 0) + return this.map.delete(e); + { + const r = this.map.get(e); + if (r) { + const i = r.indexOf(t); + if (i >= 0) + return r.length === 1 ? this.map.delete(e) : r.splice(i, 1), !0; + } + return !1; + } + } + /** + * Returns an array of all values associated with the given key. If no value exists, + * an empty array is returned. + * + * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a + * value and `delete` to remove a value from the multimap. + */ + get(e) { + var t; + return (t = this.map.get(e)) !== null && t !== void 0 ? t : []; + } + /** + * Operates differently depending on whether a `value` is given: + * * With a value, this method returns `true` if the specific key / value pair is present in the multimap. + * * Without a value, this method returns `true` if the given key is present in the multimap. + */ + has(e, t) { + if (t === void 0) + return this.map.has(e); + { + const r = this.map.get(e); + return r ? r.indexOf(t) >= 0 : !1; + } + } + /** + * Add the given key / value pair to the multimap. + */ + add(e, t) { + return this.map.has(e) ? this.map.get(e).push(t) : this.map.set(e, [t]), this; + } + /** + * Add the given set of key / value pairs to the multimap. + */ + addAll(e, t) { + return this.map.has(e) ? this.map.get(e).push(...t) : this.map.set(e, Array.from(t)), this; + } + /** + * Invokes the given callback function for every key / value pair in the multimap. + */ + forEach(e) { + this.map.forEach((t, r) => t.forEach((i) => e(i, r, this))); + } + /** + * Returns an iterator of key, value pairs for every entry in the map. + */ + [Symbol.iterator]() { + return this.entries().iterator(); + } + /** + * Returns a stream of key, value pairs for every entry in the map. + */ + entries() { + return Z(this.map.entries()).flatMap(([e, t]) => t.map((r) => [e, r])); + } + /** + * Returns a stream of keys in the map. + */ + keys() { + return Z(this.map.keys()); + } + /** + * Returns a stream of values in the map. + */ + values() { + return Z(this.map.values()).flat(); + } + /** + * Returns a stream of key, value set pairs for every key in the map. + */ + entriesGroupedByKey() { + return Z(this.map.entries()); + } +} +class nl { + get size() { + return this.map.size; + } + constructor(e) { + if (this.map = /* @__PURE__ */ new Map(), this.inverse = /* @__PURE__ */ new Map(), e) + for (const [t, r] of e) + this.set(t, r); + } + clear() { + this.map.clear(), this.inverse.clear(); + } + set(e, t) { + return this.map.set(e, t), this.inverse.set(t, e), this; + } + get(e) { + return this.map.get(e); + } + getKey(e) { + return this.inverse.get(e); + } + delete(e) { + const t = this.map.get(e); + return t !== void 0 ? (this.map.delete(e), this.inverse.delete(t), !0) : !1; + } +} +class Gm { + constructor(e) { + this.nameProvider = e.references.NameProvider, this.descriptions = e.workspace.AstNodeDescriptionProvider; + } + async computeExports(e, t = V.None) { + return this.computeExportsForNode(e.parseResult.value, e, void 0, t); + } + /** + * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children. + * The list of children to be considered is determined by the function parameter {@link children}. + * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported. + * + * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list. + * @param document The document containing the AST node to be exported. + * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}. + * @param cancelToken Indicates when to cancel the current operation. + * @throws `OperationCancelled` if a user action occurs during execution. + * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index. + */ + async computeExportsForNode(e, t, r = Vs, i = V.None) { + const s = []; + this.exportNode(e, s, t); + for (const a of r(e)) + await Ae(i), this.exportNode(a, s, t); + return s; + } + /** + * Add a single node to the list of exports if it has a name. Override this method to change how + * symbols are exported, e.g. by modifying their exported name. + */ + exportNode(e, t, r) { + const i = this.nameProvider.getName(e); + i && t.push(this.descriptions.createDescription(e, i, r)); + } + async computeLocalScopes(e, t = V.None) { + const r = e.parseResult.value, i = new ri(); + for (const s of Qn(r)) + await Ae(t), this.processNode(s, e, i); + return i; + } + /** + * Process a single node during scopes computation. The default implementation makes the node visible + * in the subtree of its container (if the node has a name). Override this method to change this, + * e.g. by increasing the visibility to a higher level in the AST. + */ + processNode(e, t, r) { + const i = e.$container; + if (i) { + const s = this.nameProvider.getName(e); + s && r.add(i, this.descriptions.createDescription(e, s, t)); + } + } +} +class rl { + constructor(e, t, r) { + var i; + this.elements = e, this.outerScope = t, this.caseInsensitive = (i = r == null ? void 0 : r.caseInsensitive) !== null && i !== void 0 ? i : !1; + } + getAllElements() { + return this.outerScope ? this.elements.concat(this.outerScope.getAllElements()) : this.elements; + } + getElement(e) { + const t = this.caseInsensitive ? this.elements.find((r) => r.name.toLowerCase() === e.toLowerCase()) : this.elements.find((r) => r.name === e); + if (t) + return t; + if (this.outerScope) + return this.outerScope.getElement(e); + } +} +class Um { + constructor(e, t, r) { + var i; + this.elements = /* @__PURE__ */ new Map(), this.caseInsensitive = (i = r == null ? void 0 : r.caseInsensitive) !== null && i !== void 0 ? i : !1; + for (const s of e) { + const a = this.caseInsensitive ? s.name.toLowerCase() : s.name; + this.elements.set(a, s); + } + this.outerScope = t; + } + getElement(e) { + const t = this.caseInsensitive ? e.toLowerCase() : e, r = this.elements.get(t); + if (r) + return r; + if (this.outerScope) + return this.outerScope.getElement(e); + } + getAllElements() { + let e = Z(this.elements.values()); + return this.outerScope && (e = e.concat(this.outerScope.getAllElements())), e; + } +} +class eu { + constructor() { + this.toDispose = [], this.isDisposed = !1; + } + onDispose(e) { + this.toDispose.push(e); + } + dispose() { + this.throwIfDisposed(), this.clear(), this.isDisposed = !0, this.toDispose.forEach((e) => e.dispose()); + } + throwIfDisposed() { + if (this.isDisposed) + throw new Error("This cache has already been disposed"); + } +} +class Bm extends eu { + constructor() { + super(...arguments), this.cache = /* @__PURE__ */ new Map(); + } + has(e) { + return this.throwIfDisposed(), this.cache.has(e); + } + set(e, t) { + this.throwIfDisposed(), this.cache.set(e, t); + } + get(e, t) { + if (this.throwIfDisposed(), this.cache.has(e)) + return this.cache.get(e); + if (t) { + const r = t(); + return this.cache.set(e, r), r; + } else + return; + } + delete(e) { + return this.throwIfDisposed(), this.cache.delete(e); + } + clear() { + this.throwIfDisposed(), this.cache.clear(); + } +} +class Vm extends eu { + constructor(e) { + super(), this.cache = /* @__PURE__ */ new Map(), this.converter = e ?? ((t) => t); + } + has(e, t) { + return this.throwIfDisposed(), this.cacheForContext(e).has(t); + } + set(e, t, r) { + this.throwIfDisposed(), this.cacheForContext(e).set(t, r); + } + get(e, t, r) { + this.throwIfDisposed(); + const i = this.cacheForContext(e); + if (i.has(t)) + return i.get(t); + if (r) { + const s = r(); + return i.set(t, s), s; + } else + return; + } + delete(e, t) { + return this.throwIfDisposed(), this.cacheForContext(e).delete(t); + } + clear(e) { + if (this.throwIfDisposed(), e) { + const t = this.converter(e); + this.cache.delete(t); + } else + this.cache.clear(); + } + cacheForContext(e) { + const t = this.converter(e); + let r = this.cache.get(t); + return r || (r = /* @__PURE__ */ new Map(), this.cache.set(t, r)), r; + } +} +class Km extends Bm { + /** + * Creates a new workspace cache. + * + * @param sharedServices Service container instance to hook into document lifecycle events. + * @param state Optional document state on which the cache should evict. + * If not provided, the cache will evict on `DocumentBuilder#onUpdate`. + * *Deleted* documents are considered in both cases. + */ + constructor(e, t) { + super(), t ? (this.toDispose.push(e.workspace.DocumentBuilder.onBuildPhase(t, () => { + this.clear(); + })), this.toDispose.push(e.workspace.DocumentBuilder.onUpdate((r, i) => { + i.length > 0 && this.clear(); + }))) : this.toDispose.push(e.workspace.DocumentBuilder.onUpdate(() => { + this.clear(); + })); + } +} +class Wm { + constructor(e) { + this.reflection = e.shared.AstReflection, this.nameProvider = e.references.NameProvider, this.descriptions = e.workspace.AstNodeDescriptionProvider, this.indexManager = e.shared.workspace.IndexManager, this.globalScopeCache = new Km(e.shared); + } + getScope(e) { + const t = [], r = this.reflection.getReferenceType(e), i = et(e.container).precomputedScopes; + if (i) { + let a = e.container; + do { + const o = i.get(a); + o.length > 0 && t.push(Z(o).filter((l) => this.reflection.isSubtype(l.type, r))), a = a.$container; + } while (a); + } + let s = this.getGlobalScope(r, e); + for (let a = t.length - 1; a >= 0; a--) + s = this.createScope(t[a], s); + return s; + } + /** + * Create a scope for the given collection of AST node descriptions. + */ + createScope(e, t, r) { + return new rl(Z(e), t, r); + } + /** + * Create a scope for the given collection of AST nodes, which need to be transformed into respective + * descriptions first. This is done using the `NameProvider` and `AstNodeDescriptionProvider` services. + */ + createScopeForNodes(e, t, r) { + const i = Z(e).map((s) => { + const a = this.nameProvider.getName(s); + if (a) + return this.descriptions.createDescription(s, a); + }).nonNullable(); + return new rl(i, t, r); + } + /** + * Create a global scope filtered for the given reference type. + */ + getGlobalScope(e, t) { + return this.globalScopeCache.get(e, () => new Um(this.indexManager.allElements(e))); + } +} +function jm(n) { + return typeof n.$comment == "string"; +} +function il(n) { + return typeof n == "object" && !!n && ("$ref" in n || "$error" in n); +} +class Hm { + constructor(e) { + this.ignoreProperties = /* @__PURE__ */ new Set(["$container", "$containerProperty", "$containerIndex", "$document", "$cstNode"]), this.langiumDocuments = e.shared.workspace.LangiumDocuments, this.astNodeLocator = e.workspace.AstNodeLocator, this.nameProvider = e.references.NameProvider, this.commentProvider = e.documentation.CommentProvider; + } + serialize(e, t) { + const r = t ?? {}, i = t == null ? void 0 : t.replacer, s = (o, l) => this.replacer(o, l, r), a = i ? (o, l) => i(o, l, s) : s; + try { + return this.currentDocument = et(e), JSON.stringify(e, a, t == null ? void 0 : t.space); + } finally { + this.currentDocument = void 0; + } + } + deserialize(e, t) { + const r = t ?? {}, i = JSON.parse(e); + return this.linkNode(i, i, r), i; + } + replacer(e, t, { refText: r, sourceText: i, textRegions: s, comments: a, uriConverter: o }) { + var l, c, u, d; + if (!this.ignoreProperties.has(e)) + if (Ge(t)) { + const h = t.ref, f = r ? t.$refText : void 0; + if (h) { + const m = et(h); + let g = ""; + this.currentDocument && this.currentDocument !== m && (o ? g = o(m.uri, t) : g = m.uri.toString()); + const v = this.astNodeLocator.getAstNodePath(h); + return { + $ref: `${g}#${v}`, + $refText: f + }; + } else + return { + $error: (c = (l = t.error) === null || l === void 0 ? void 0 : l.message) !== null && c !== void 0 ? c : "Could not resolve reference", + $refText: f + }; + } else if (ae(t)) { + let h; + if (s && (h = this.addAstNodeRegionWithAssignmentsTo(Object.assign({}, t)), (!e || t.$document) && (h != null && h.$textRegion) && (h.$textRegion.documentURI = (u = this.currentDocument) === null || u === void 0 ? void 0 : u.uri.toString())), i && !e && (h ?? (h = Object.assign({}, t)), h.$sourceText = (d = t.$cstNode) === null || d === void 0 ? void 0 : d.text), a) { + h ?? (h = Object.assign({}, t)); + const f = this.commentProvider.getComment(t); + f && (h.$comment = f.replace(/\r/g, "")); + } + return h ?? t; + } else + return t; + } + addAstNodeRegionWithAssignmentsTo(e) { + const t = (r) => ({ + offset: r.offset, + end: r.end, + length: r.length, + range: r.range + }); + if (e.$cstNode) { + const r = e.$textRegion = t(e.$cstNode), i = r.assignments = {}; + return Object.keys(e).filter((s) => !s.startsWith("$")).forEach((s) => { + const a = Jd(e.$cstNode, s).map(t); + a.length !== 0 && (i[s] = a); + }), e; + } + } + linkNode(e, t, r, i, s, a) { + for (const [l, c] of Object.entries(e)) + if (Array.isArray(c)) + for (let u = 0; u < c.length; u++) { + const d = c[u]; + il(d) ? c[u] = this.reviveReference(e, l, t, d, r) : ae(d) && this.linkNode(d, t, r, e, l, u); + } + else il(c) ? e[l] = this.reviveReference(e, l, t, c, r) : ae(c) && this.linkNode(c, t, r, e, l); + const o = e; + o.$container = i, o.$containerProperty = s, o.$containerIndex = a; + } + reviveReference(e, t, r, i, s) { + let a = i.$refText, o = i.$error; + if (i.$ref) { + const l = this.getRefNode(r, i.$ref, s.uriConverter); + if (ae(l)) + return a || (a = this.nameProvider.getName(l)), { + $refText: a ?? "", + ref: l + }; + o = l; + } + if (o) { + const l = { + $refText: a ?? "" + }; + return l.error = { + container: e, + property: t, + message: o, + reference: l + }, l; + } else + return; + } + getRefNode(e, t, r) { + try { + const i = t.indexOf("#"); + if (i === 0) { + const l = this.astNodeLocator.getAstNode(e, t.substring(1)); + return l || "Could not resolve path: " + t; + } + if (i < 0) { + const l = r ? r(t) : mt.parse(t), c = this.langiumDocuments.getDocument(l); + return c ? c.parseResult.value : "Could not find document for URI: " + t; + } + const s = r ? r(t.substring(0, i)) : mt.parse(t.substring(0, i)), a = this.langiumDocuments.getDocument(s); + if (!a) + return "Could not find document for URI: " + t; + if (i === t.length - 1) + return a.parseResult.value; + const o = this.astNodeLocator.getAstNode(a.parseResult.value, t.substring(i + 1)); + return o || "Could not resolve URI: " + t; + } catch (i) { + return String(i); + } + } +} +class zm { + /** + * @deprecated Use the new `fileExtensionMap` (or `languageIdMap`) property instead. + */ + get map() { + return this.fileExtensionMap; + } + constructor(e) { + this.languageIdMap = /* @__PURE__ */ new Map(), this.fileExtensionMap = /* @__PURE__ */ new Map(), this.textDocuments = e == null ? void 0 : e.workspace.TextDocuments; + } + register(e) { + const t = e.LanguageMetaData; + for (const r of t.fileExtensions) + this.fileExtensionMap.has(r) && console.warn(`The file extension ${r} is used by multiple languages. It is now assigned to '${t.languageId}'.`), this.fileExtensionMap.set(r, e); + this.languageIdMap.set(t.languageId, e), this.languageIdMap.size === 1 ? this.singleton = e : this.singleton = void 0; + } + getServices(e) { + var t, r; + if (this.singleton !== void 0) + return this.singleton; + if (this.languageIdMap.size === 0) + throw new Error("The service registry is empty. Use `register` to register the services of a language."); + const i = (r = (t = this.textDocuments) === null || t === void 0 ? void 0 : t.get(e)) === null || r === void 0 ? void 0 : r.languageId; + if (i !== void 0) { + const o = this.languageIdMap.get(i); + if (o) + return o; + } + const s = it.extname(e), a = this.fileExtensionMap.get(s); + if (!a) + throw i ? new Error(`The service registry contains no services for the extension '${s}' for language '${i}'.`) : new Error(`The service registry contains no services for the extension '${s}'.`); + return a; + } + hasServices(e) { + try { + return this.getServices(e), !0; + } catch { + return !1; + } + } + get all() { + return Array.from(this.languageIdMap.values()); + } +} +function Gn(n) { + return { code: n }; +} +var ii; +(function(n) { + n.all = ["fast", "slow", "built-in"]; +})(ii || (ii = {})); +class qm { + constructor(e) { + this.entries = new ri(), this.entriesBefore = [], this.entriesAfter = [], this.reflection = e.shared.AstReflection; + } + /** + * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function) + * or an array of validation checks. + * + * @param checksRecord Set of validation checks to register. + * @param category Optional category for the validation checks (defaults to `'fast'`). + * @param thisObj Optional object to be used as `this` when calling the validation check functions. + */ + register(e, t = this, r = "fast") { + if (r === "built-in") + throw new Error("The 'built-in' category is reserved for lexer, parser, and linker errors."); + for (const [i, s] of Object.entries(e)) { + const a = s; + if (Array.isArray(a)) + for (const o of a) { + const l = { + check: this.wrapValidationException(o, t), + category: r + }; + this.addEntry(i, l); + } + else if (typeof a == "function") { + const o = { + check: this.wrapValidationException(a, t), + category: r + }; + this.addEntry(i, o); + } else + Jn(); + } + } + wrapValidationException(e, t) { + return async (r, i, s) => { + await this.handleException(() => e.call(t, r, i, s), "An error occurred during validation", i, r); + }; + } + async handleException(e, t, r, i) { + try { + await e(); + } catch (s) { + if (Ai(s)) + throw s; + console.error(`${t}:`, s), s instanceof Error && s.stack && console.error(s.stack); + const a = s instanceof Error ? s.message : String(s); + r("error", `${t}: ${a}`, { node: i }); + } + } + addEntry(e, t) { + if (e === "AstNode") { + this.entries.add("AstNode", t); + return; + } + for (const r of this.reflection.getAllSubTypes(e)) + this.entries.add(r, t); + } + getChecks(e, t) { + let r = Z(this.entries.get(e)).concat(this.entries.get("AstNode")); + return t && (r = r.filter((i) => t.includes(i.category))), r.map((i) => i.check); + } + /** + * Register logic which will be executed once before validating all the nodes of an AST/Langium document. + * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes. + * + * As an example, for validating unique fully-qualified names of nodes in the AST, + * here the map for mapping names to nodes could be established. + * During the usual checks on the nodes, they are put into this map with their name. + * + * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation. + * Therefore it is recommended to clear stored information + * _before_ validating an AST to validate each AST unaffected from other ASTs + * AND _after_ validating the AST to free memory by information which are no longer used. + * + * @param checkBefore a set-up function which will be called once before actually validating an AST + * @param thisObj Optional object to be used as `this` when calling the validation check functions. + */ + registerBeforeDocument(e, t = this) { + this.entriesBefore.push(this.wrapPreparationException(e, "An error occurred during set-up of the validation", t)); + } + /** + * Register logic which will be executed once after validating all the nodes of an AST/Langium document. + * This helps to finally evaluate information which are collected during the checks on the AstNodes. + * + * As an example, for validating unique fully-qualified names of nodes in the AST, + * here the map with all the collected nodes and their names is checked + * and validation hints are created for all nodes with the same name. + * + * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation. + * Therefore it is recommended to clear stored information + * _before_ validating an AST to validate each AST unaffected from other ASTs + * AND _after_ validating the AST to free memory by information which are no longer used. + * + * @param checkBefore a set-up function which will be called once before actually validating an AST + * @param thisObj Optional object to be used as `this` when calling the validation check functions. + */ + registerAfterDocument(e, t = this) { + this.entriesAfter.push(this.wrapPreparationException(e, "An error occurred during tear-down of the validation", t)); + } + wrapPreparationException(e, t, r) { + return async (i, s, a, o) => { + await this.handleException(() => e.call(r, i, s, a, o), t, s, i); + }; + } + get checksBefore() { + return this.entriesBefore; + } + get checksAfter() { + return this.entriesAfter; + } +} +class Ym { + constructor(e) { + this.validationRegistry = e.validation.ValidationRegistry, this.metadata = e.LanguageMetaData; + } + async validateDocument(e, t = {}, r = V.None) { + const i = e.parseResult, s = []; + if (await Ae(r), (!t.categories || t.categories.includes("built-in")) && (this.processLexingErrors(i, s, t), t.stopAfterLexingErrors && s.some((a) => { + var o; + return ((o = a.data) === null || o === void 0 ? void 0 : o.code) === Oe.LexingError; + }) || (this.processParsingErrors(i, s, t), t.stopAfterParsingErrors && s.some((a) => { + var o; + return ((o = a.data) === null || o === void 0 ? void 0 : o.code) === Oe.ParsingError; + })) || (this.processLinkingErrors(e, s, t), t.stopAfterLinkingErrors && s.some((a) => { + var o; + return ((o = a.data) === null || o === void 0 ? void 0 : o.code) === Oe.LinkingError; + })))) + return s; + try { + s.push(...await this.validateAst(i.value, t, r)); + } catch (a) { + if (Ai(a)) + throw a; + console.error("An error occurred during validation:", a); + } + return await Ae(r), s; + } + processLexingErrors(e, t, r) { + var i, s, a; + const o = [...e.lexerErrors, ...(s = (i = e.lexerReport) === null || i === void 0 ? void 0 : i.diagnostics) !== null && s !== void 0 ? s : []]; + for (const l of o) { + const c = (a = l.severity) !== null && a !== void 0 ? a : "error", u = { + severity: Gi(c), + range: { + start: { + line: l.line - 1, + character: l.column - 1 + }, + end: { + line: l.line - 1, + character: l.column + l.length - 1 + } + }, + message: l.message, + data: Jm(c), + source: this.getSource() + }; + t.push(u); + } + } + processParsingErrors(e, t, r) { + for (const i of e.parserErrors) { + let s; + if (isNaN(i.token.startOffset)) { + if ("previousToken" in i) { + const a = i.previousToken; + if (isNaN(a.startOffset)) { + const o = { line: 0, character: 0 }; + s = { start: o, end: o }; + } else { + const o = { line: a.endLine - 1, character: a.endColumn }; + s = { start: o, end: o }; + } + } + } else + s = Qi(i.token); + if (s) { + const a = { + severity: Gi("error"), + range: s, + message: i.message, + data: Gn(Oe.ParsingError), + source: this.getSource() + }; + t.push(a); + } + } + } + processLinkingErrors(e, t, r) { + for (const i of e.references) { + const s = i.error; + if (s) { + const a = { + node: s.container, + property: s.property, + index: s.index, + data: { + code: Oe.LinkingError, + containerType: s.container.$type, + property: s.property, + refText: s.reference.$refText + } + }; + t.push(this.toDiagnostic("error", s.message, a)); + } + } + } + async validateAst(e, t, r = V.None) { + const i = [], s = (a, o, l) => { + i.push(this.toDiagnostic(a, o, l)); + }; + return await this.validateAstBefore(e, t, s, r), await this.validateAstNodes(e, t, s, r), await this.validateAstAfter(e, t, s, r), i; + } + async validateAstBefore(e, t, r, i = V.None) { + var s; + const a = this.validationRegistry.checksBefore; + for (const o of a) + await Ae(i), await o(e, r, (s = t.categories) !== null && s !== void 0 ? s : [], i); + } + async validateAstNodes(e, t, r, i = V.None) { + await Promise.all(It(e).map(async (s) => { + await Ae(i); + const a = this.validationRegistry.getChecks(s.$type, t.categories); + for (const o of a) + await o(s, r, i); + })); + } + async validateAstAfter(e, t, r, i = V.None) { + var s; + const a = this.validationRegistry.checksAfter; + for (const o of a) + await Ae(i), await o(e, r, (s = t.categories) !== null && s !== void 0 ? s : [], i); + } + toDiagnostic(e, t, r) { + return { + message: t, + range: Xm(r), + severity: Gi(e), + code: r.code, + codeDescription: r.codeDescription, + tags: r.tags, + relatedInformation: r.relatedInformation, + data: r.data, + source: this.getSource() + }; + } + getSource() { + return this.metadata.languageId; + } +} +function Xm(n) { + if (n.range) + return n.range; + let e; + return typeof n.property == "string" ? e = Vl(n.node.$cstNode, n.property, n.index) : typeof n.keyword == "string" && (e = Qd(n.node.$cstNode, n.keyword, n.index)), e ?? (e = n.node.$cstNode), e ? e.range : { + start: { line: 0, character: 0 }, + end: { line: 0, character: 0 } + }; +} +function Gi(n) { + switch (n) { + case "error": + return 1; + case "warning": + return 2; + case "info": + return 3; + case "hint": + return 4; + default: + throw new Error("Invalid diagnostic severity: " + n); + } +} +function Jm(n) { + switch (n) { + case "error": + return Gn(Oe.LexingError); + case "warning": + return Gn(Oe.LexingWarning); + case "info": + return Gn(Oe.LexingInfo); + case "hint": + return Gn(Oe.LexingHint); + default: + throw new Error("Invalid diagnostic severity: " + n); + } +} +var Oe; +(function(n) { + n.LexingError = "lexing-error", n.LexingWarning = "lexing-warning", n.LexingInfo = "lexing-info", n.LexingHint = "lexing-hint", n.ParsingError = "parsing-error", n.LinkingError = "linking-error"; +})(Oe || (Oe = {})); +class Qm { + constructor(e) { + this.astNodeLocator = e.workspace.AstNodeLocator, this.nameProvider = e.references.NameProvider; + } + createDescription(e, t, r) { + const i = r ?? et(e); + t ?? (t = this.nameProvider.getName(e)); + const s = this.astNodeLocator.getAstNodePath(e); + if (!t) + throw new Error(`Node at path ${s} has no name.`); + let a; + const o = () => { + var l; + return a ?? (a = Dr((l = this.nameProvider.getNameNode(e)) !== null && l !== void 0 ? l : e.$cstNode)); + }; + return { + node: e, + name: t, + get nameSegment() { + return o(); + }, + selectionSegment: Dr(e.$cstNode), + type: e.$type, + documentUri: i.uri, + path: s + }; + } +} +class Zm { + constructor(e) { + this.nodeLocator = e.workspace.AstNodeLocator; + } + async createDescriptions(e, t = V.None) { + const r = [], i = e.parseResult.value; + for (const s of It(i)) + await Ae(t), Dl(s).filter((a) => !Er(a)).forEach((a) => { + const o = this.createDescription(a); + o && r.push(o); + }); + return r; + } + createDescription(e) { + const t = e.reference.$nodeDescription, r = e.reference.$refNode; + if (!t || !r) + return; + const i = et(e.container).uri; + return { + sourceUri: i, + sourcePath: this.nodeLocator.getAstNodePath(e.container), + targetUri: t.documentUri, + targetPath: t.path, + segment: Dr(r), + local: it.equals(t.documentUri, i) + }; + } +} +class eg { + constructor() { + this.segmentSeparator = "/", this.indexSeparator = "@"; + } + getAstNodePath(e) { + if (e.$container) { + const t = this.getAstNodePath(e.$container), r = this.getPathSegment(e); + return t + this.segmentSeparator + r; + } + return ""; + } + getPathSegment({ $containerProperty: e, $containerIndex: t }) { + if (!e) + throw new Error("Missing '$containerProperty' in AST node."); + return t !== void 0 ? e + this.indexSeparator + t : e; + } + getAstNode(e, t) { + return t.split(this.segmentSeparator).reduce((i, s) => { + if (!i || s.length === 0) + return i; + const a = s.indexOf(this.indexSeparator); + if (a > 0) { + const o = s.substring(0, a), l = parseInt(s.substring(a + 1)), c = i[o]; + return c == null ? void 0 : c[l]; + } + return i[s]; + }, e); + } +} +class tg { + constructor(e) { + this._ready = new oa(), this.settings = {}, this.workspaceConfig = !1, this.onConfigurationSectionUpdateEmitter = new Xc(), this.serviceRegistry = e.ServiceRegistry; + } + get ready() { + return this._ready.promise; + } + initialize(e) { + var t, r; + this.workspaceConfig = (r = (t = e.capabilities.workspace) === null || t === void 0 ? void 0 : t.configuration) !== null && r !== void 0 ? r : !1; + } + async initialized(e) { + if (this.workspaceConfig) { + if (e.register) { + const t = this.serviceRegistry.all; + e.register({ + // Listen to configuration changes for all languages + section: t.map((r) => this.toSectionName(r.LanguageMetaData.languageId)) + }); + } + if (e.fetchConfiguration) { + const t = this.serviceRegistry.all.map((i) => ({ + // Fetch the configuration changes for all languages + section: this.toSectionName(i.LanguageMetaData.languageId) + })), r = await e.fetchConfiguration(t); + t.forEach((i, s) => { + this.updateSectionConfiguration(i.section, r[s]); + }); + } + } + this._ready.resolve(); + } + /** + * Updates the cached configurations using the `change` notification parameters. + * + * @param change The parameters of a change configuration notification. + * `settings` property of the change object could be expressed as `Record>` + */ + updateConfiguration(e) { + e.settings && Object.keys(e.settings).forEach((t) => { + const r = e.settings[t]; + this.updateSectionConfiguration(t, r), this.onConfigurationSectionUpdateEmitter.fire({ section: t, configuration: r }); + }); + } + updateSectionConfiguration(e, t) { + this.settings[e] = t; + } + /** + * Returns a configuration value stored for the given language. + * + * @param language The language id + * @param configuration Configuration name + */ + async getConfiguration(e, t) { + await this.ready; + const r = this.toSectionName(e); + if (this.settings[r]) + return this.settings[r][t]; + } + toSectionName(e) { + return `${e}`; + } + get onConfigurationSectionUpdate() { + return this.onConfigurationSectionUpdateEmitter.event; + } +} +var Wn; +(function(n) { + function e(t) { + return { + dispose: async () => await t() + }; + } + n.create = e; +})(Wn || (Wn = {})); +class ng { + constructor(e) { + this.updateBuildOptions = { + // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category) + validation: { + categories: ["built-in", "fast"] + } + }, this.updateListeners = [], this.buildPhaseListeners = new ri(), this.documentPhaseListeners = new ri(), this.buildState = /* @__PURE__ */ new Map(), this.documentBuildWaiters = /* @__PURE__ */ new Map(), this.currentState = U.Changed, this.langiumDocuments = e.workspace.LangiumDocuments, this.langiumDocumentFactory = e.workspace.LangiumDocumentFactory, this.textDocuments = e.workspace.TextDocuments, this.indexManager = e.workspace.IndexManager, this.serviceRegistry = e.ServiceRegistry; + } + async build(e, t = {}, r = V.None) { + var i, s; + for (const a of e) { + const o = a.uri.toString(); + if (a.state === U.Validated) { + if (typeof t.validation == "boolean" && t.validation) + a.state = U.IndexedReferences, a.diagnostics = void 0, this.buildState.delete(o); + else if (typeof t.validation == "object") { + const l = this.buildState.get(o), c = (i = l == null ? void 0 : l.result) === null || i === void 0 ? void 0 : i.validationChecks; + if (c) { + const d = ((s = t.validation.categories) !== null && s !== void 0 ? s : ii.all).filter((h) => !c.includes(h)); + d.length > 0 && (this.buildState.set(o, { + completed: !1, + options: { + validation: Object.assign(Object.assign({}, t.validation), { categories: d }) + }, + result: l.result + }), a.state = U.IndexedReferences); + } + } + } else + this.buildState.delete(o); + } + this.currentState = U.Changed, await this.emitUpdate(e.map((a) => a.uri), []), await this.buildDocuments(e, t, r); + } + async update(e, t, r = V.None) { + this.currentState = U.Changed; + for (const a of t) + this.langiumDocuments.deleteDocument(a), this.buildState.delete(a.toString()), this.indexManager.remove(a); + for (const a of e) { + if (!this.langiumDocuments.invalidateDocument(a)) { + const l = this.langiumDocumentFactory.fromModel({ $type: "INVALID" }, a); + l.state = U.Changed, this.langiumDocuments.addDocument(l); + } + this.buildState.delete(a.toString()); + } + const i = Z(e).concat(t).map((a) => a.toString()).toSet(); + this.langiumDocuments.all.filter((a) => !i.has(a.uri.toString()) && this.shouldRelink(a, i)).forEach((a) => { + this.serviceRegistry.getServices(a.uri).references.Linker.unlink(a), a.state = Math.min(a.state, U.ComputedScopes), a.diagnostics = void 0; + }), await this.emitUpdate(e, t), await Ae(r); + const s = this.sortDocuments(this.langiumDocuments.all.filter((a) => { + var o; + return a.state < U.Linked || !(!((o = this.buildState.get(a.uri.toString())) === null || o === void 0) && o.completed); + }).toArray()); + await this.buildDocuments(s, this.updateBuildOptions, r); + } + async emitUpdate(e, t) { + await Promise.all(this.updateListeners.map((r) => r(e, t))); + } + /** + * Sort the given documents by priority. By default, documents with an open text document are prioritized. + * This is useful to ensure that visible documents show their diagnostics before all other documents. + * + * This improves the responsiveness in large workspaces as users usually don't care about diagnostics + * in files that are currently not opened in the editor. + */ + sortDocuments(e) { + let t = 0, r = e.length - 1; + for (; t < r; ) { + for (; t < e.length && this.hasTextDocument(e[t]); ) + t++; + for (; r >= 0 && !this.hasTextDocument(e[r]); ) + r--; + t < r && ([e[t], e[r]] = [e[r], e[t]]); + } + return e; + } + hasTextDocument(e) { + var t; + return !!(!((t = this.textDocuments) === null || t === void 0) && t.get(e.uri)); + } + /** + * Check whether the given document should be relinked after changes were found in the given URIs. + */ + shouldRelink(e, t) { + return e.references.some((r) => r.error !== void 0) ? !0 : this.indexManager.isAffected(e, t); + } + onUpdate(e) { + return this.updateListeners.push(e), Wn.create(() => { + const t = this.updateListeners.indexOf(e); + t >= 0 && this.updateListeners.splice(t, 1); + }); + } + /** + * Build the given documents by stepping through all build phases. If a document's state indicates + * that a certain build phase is already done, the phase is skipped for that document. + * + * @param documents The documents to build. + * @param options the {@link BuildOptions} to use. + * @param cancelToken A cancellation token that can be used to cancel the build. + * @returns A promise that resolves when the build is done. + */ + async buildDocuments(e, t, r) { + this.prepareBuild(e, t), await this.runCancelable(e, U.Parsed, r, (s) => this.langiumDocumentFactory.update(s, r)), await this.runCancelable(e, U.IndexedContent, r, (s) => this.indexManager.updateContent(s, r)), await this.runCancelable(e, U.ComputedScopes, r, async (s) => { + const a = this.serviceRegistry.getServices(s.uri).references.ScopeComputation; + s.precomputedScopes = await a.computeLocalScopes(s, r); + }), await this.runCancelable(e, U.Linked, r, (s) => this.serviceRegistry.getServices(s.uri).references.Linker.link(s, r)), await this.runCancelable(e, U.IndexedReferences, r, (s) => this.indexManager.updateReferences(s, r)); + const i = e.filter((s) => this.shouldValidate(s)); + await this.runCancelable(i, U.Validated, r, (s) => this.validate(s, r)); + for (const s of e) { + const a = this.buildState.get(s.uri.toString()); + a && (a.completed = !0); + } + } + /** + * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document + * + * @param documents collection of documents to be built + * @param options the {@link BuildOptions} to use + */ + prepareBuild(e, t) { + for (const r of e) { + const i = r.uri.toString(), s = this.buildState.get(i); + (!s || s.completed) && this.buildState.set(i, { + completed: !1, + options: t, + result: s == null ? void 0 : s.result + }); + } + } + /** + * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}. + * + * @param documents The array of documents to process. + * @param targetState The target {@link DocumentState} to bring the documents to. + * @param cancelToken A token that can be used to cancel the operation. + * @param callback A function to be called for each document. + * @returns A promise that resolves when all documents have been processed or the operation is canceled. + * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`. + */ + async runCancelable(e, t, r, i) { + const s = e.filter((o) => o.state < t); + for (const o of s) + await Ae(r), await i(o), o.state = t, await this.notifyDocumentPhase(o, t, r); + const a = e.filter((o) => o.state === t); + await this.notifyBuildPhase(a, t, r), this.currentState = t; + } + onBuildPhase(e, t) { + return this.buildPhaseListeners.add(e, t), Wn.create(() => { + this.buildPhaseListeners.delete(e, t); + }); + } + onDocumentPhase(e, t) { + return this.documentPhaseListeners.add(e, t), Wn.create(() => { + this.documentPhaseListeners.delete(e, t); + }); + } + waitUntil(e, t, r) { + let i; + if (t && "path" in t ? i = t : r = t, r ?? (r = V.None), i) { + const s = this.langiumDocuments.getDocument(i); + if (s && s.state > e) + return Promise.resolve(i); + } + return this.currentState >= e ? Promise.resolve(void 0) : r.isCancellationRequested ? Promise.reject(ni) : new Promise((s, a) => { + const o = this.onBuildPhase(e, () => { + if (o.dispose(), l.dispose(), i) { + const c = this.langiumDocuments.getDocument(i); + s(c == null ? void 0 : c.uri); + } else + s(void 0); + }), l = r.onCancellationRequested(() => { + o.dispose(), l.dispose(), a(ni); + }); + }); + } + async notifyDocumentPhase(e, t, r) { + const s = this.documentPhaseListeners.get(t).slice(); + for (const a of s) + try { + await a(e, r); + } catch (o) { + if (!Ai(o)) + throw o; + } + } + async notifyBuildPhase(e, t, r) { + if (e.length === 0) + return; + const s = this.buildPhaseListeners.get(t).slice(); + for (const a of s) + await Ae(r), await a(e, r); + } + /** + * Determine whether the given document should be validated during a build. The default + * implementation checks the `validation` property of the build options. If it's set to `true` + * or a `ValidationOptions` object, the document is included in the validation phase. + */ + shouldValidate(e) { + return !!this.getBuildOptions(e).validation; + } + /** + * Run validation checks on the given document and store the resulting diagnostics in the document. + * If the document already contains diagnostics, the new ones are added to the list. + */ + async validate(e, t) { + var r, i; + const s = this.serviceRegistry.getServices(e.uri).validation.DocumentValidator, a = this.getBuildOptions(e).validation, o = typeof a == "object" ? a : void 0, l = await s.validateDocument(e, o, t); + e.diagnostics ? e.diagnostics.push(...l) : e.diagnostics = l; + const c = this.buildState.get(e.uri.toString()); + if (c) { + (r = c.result) !== null && r !== void 0 || (c.result = {}); + const u = (i = o == null ? void 0 : o.categories) !== null && i !== void 0 ? i : ii.all; + c.result.validationChecks ? c.result.validationChecks.push(...u) : c.result.validationChecks = [...u]; + } + } + getBuildOptions(e) { + var t, r; + return (r = (t = this.buildState.get(e.uri.toString())) === null || t === void 0 ? void 0 : t.options) !== null && r !== void 0 ? r : {}; + } +} +class rg { + constructor(e) { + this.symbolIndex = /* @__PURE__ */ new Map(), this.symbolByTypeIndex = new Vm(), this.referenceIndex = /* @__PURE__ */ new Map(), this.documents = e.workspace.LangiumDocuments, this.serviceRegistry = e.ServiceRegistry, this.astReflection = e.AstReflection; + } + findAllReferences(e, t) { + const r = et(e).uri, i = []; + return this.referenceIndex.forEach((s) => { + s.forEach((a) => { + it.equals(a.targetUri, r) && a.targetPath === t && i.push(a); + }); + }), Z(i); + } + allElements(e, t) { + let r = Z(this.symbolIndex.keys()); + return t && (r = r.filter((i) => !t || t.has(i))), r.map((i) => this.getFileDescriptions(i, e)).flat(); + } + getFileDescriptions(e, t) { + var r; + return t ? this.symbolByTypeIndex.get(e, t, () => { + var s; + return ((s = this.symbolIndex.get(e)) !== null && s !== void 0 ? s : []).filter((o) => this.astReflection.isSubtype(o.type, t)); + }) : (r = this.symbolIndex.get(e)) !== null && r !== void 0 ? r : []; + } + remove(e) { + const t = e.toString(); + this.symbolIndex.delete(t), this.symbolByTypeIndex.clear(t), this.referenceIndex.delete(t); + } + async updateContent(e, t = V.None) { + const i = await this.serviceRegistry.getServices(e.uri).references.ScopeComputation.computeExports(e, t), s = e.uri.toString(); + this.symbolIndex.set(s, i), this.symbolByTypeIndex.clear(s); + } + async updateReferences(e, t = V.None) { + const i = await this.serviceRegistry.getServices(e.uri).workspace.ReferenceDescriptionProvider.createDescriptions(e, t); + this.referenceIndex.set(e.uri.toString(), i); + } + isAffected(e, t) { + const r = this.referenceIndex.get(e.uri.toString()); + return r ? r.some((i) => !i.local && t.has(i.targetUri.toString())) : !1; + } +} +class ig { + constructor(e) { + this.initialBuildOptions = {}, this._ready = new oa(), this.serviceRegistry = e.ServiceRegistry, this.langiumDocuments = e.workspace.LangiumDocuments, this.documentBuilder = e.workspace.DocumentBuilder, this.fileSystemProvider = e.workspace.FileSystemProvider, this.mutex = e.workspace.WorkspaceLock; + } + get ready() { + return this._ready.promise; + } + get workspaceFolders() { + return this.folders; + } + initialize(e) { + var t; + this.folders = (t = e.workspaceFolders) !== null && t !== void 0 ? t : void 0; + } + initialized(e) { + return this.mutex.write((t) => { + var r; + return this.initializeWorkspace((r = this.folders) !== null && r !== void 0 ? r : [], t); + }); + } + async initializeWorkspace(e, t = V.None) { + const r = await this.performStartup(e); + await Ae(t), await this.documentBuilder.build(r, this.initialBuildOptions, t); + } + /** + * Performs the uninterruptable startup sequence of the workspace manager. + * This methods loads all documents in the workspace and other documents and returns them. + */ + async performStartup(e) { + const t = this.serviceRegistry.all.flatMap((s) => s.LanguageMetaData.fileExtensions), r = [], i = (s) => { + r.push(s), this.langiumDocuments.hasDocument(s.uri) || this.langiumDocuments.addDocument(s); + }; + return await this.loadAdditionalDocuments(e, i), await Promise.all(e.map((s) => [s, this.getRootFolder(s)]).map(async (s) => this.traverseFolder(...s, t, i))), this._ready.resolve(), r; + } + /** + * Load all additional documents that shall be visible in the context of the given workspace + * folders and add them to the collector. This can be used to include built-in libraries of + * your language, which can be either loaded from provided files or constructed in memory. + */ + loadAdditionalDocuments(e, t) { + return Promise.resolve(); + } + /** + * Determine the root folder of the source documents in the given workspace folder. + * The default implementation returns the URI of the workspace folder, but you can override + * this to return a subfolder like `src` instead. + */ + getRootFolder(e) { + return mt.parse(e.uri); + } + /** + * Traverse the file system folder identified by the given URI and its subfolders. All + * contained files that match the file extensions are added to the collector. + */ + async traverseFolder(e, t, r, i) { + const s = await this.fileSystemProvider.readDirectory(t); + await Promise.all(s.map(async (a) => { + if (this.includeEntry(e, a, r)) { + if (a.isDirectory) + await this.traverseFolder(e, a.uri, r, i); + else if (a.isFile) { + const o = await this.langiumDocuments.getOrCreateDocument(a.uri); + i(o); + } + } + })); + } + /** + * Determine whether the given folder entry shall be included while indexing the workspace. + */ + includeEntry(e, t, r) { + const i = it.basename(t.uri); + if (i.startsWith(".")) + return !1; + if (t.isDirectory) + return i !== "node_modules" && i !== "out"; + if (t.isFile) { + const s = it.extname(t.uri); + return r.includes(s); + } + return !1; + } +} +class sg { + buildUnexpectedCharactersMessage(e, t, r, i, s) { + return is.buildUnexpectedCharactersMessage(e, t, r, i, s); + } + buildUnableToPopLexerModeMessage(e) { + return is.buildUnableToPopLexerModeMessage(e); + } +} +const ag = { mode: "full" }; +class og { + constructor(e) { + this.errorMessageProvider = e.parser.LexerErrorMessageProvider, this.tokenBuilder = e.parser.TokenBuilder; + const t = this.tokenBuilder.buildTokens(e.Grammar, { + caseInsensitive: e.LanguageMetaData.caseInsensitive + }); + this.tokenTypes = this.toTokenTypeDictionary(t); + const r = sl(t) ? Object.values(t) : t, i = e.LanguageMetaData.mode === "production"; + this.chevrotainLexer = new de(r, { + positionTracking: "full", + skipValidations: i, + errorMessageProvider: this.errorMessageProvider + }); + } + get definition() { + return this.tokenTypes; + } + tokenize(e, t = ag) { + var r, i, s; + const a = this.chevrotainLexer.tokenize(e); + return { + tokens: a.tokens, + errors: a.errors, + hidden: (r = a.groups.hidden) !== null && r !== void 0 ? r : [], + report: (s = (i = this.tokenBuilder).flushLexingReport) === null || s === void 0 ? void 0 : s.call(i, e) + }; + } + toTokenTypeDictionary(e) { + if (sl(e)) + return e; + const t = tu(e) ? Object.values(e.modes).flat() : e, r = {}; + return t.forEach((i) => r[i.name] = i), r; + } +} +function lg(n) { + return Array.isArray(n) && (n.length === 0 || "name" in n[0]); +} +function tu(n) { + return n && "modes" in n && "defaultMode" in n; +} +function sl(n) { + return !lg(n) && !tu(n); +} +function cg(n, e, t) { + let r, i; + typeof n == "string" ? (i = e, r = t) : (i = n.range.start, r = e), i || (i = P.create(0, 0)); + const s = nu(n), a = la(r), o = fg({ + lines: s, + position: i, + options: a + }); + return yg({ + index: 0, + tokens: o, + position: i + }); +} +function ug(n, e) { + const t = la(e), r = nu(n); + if (r.length === 0) + return !1; + const i = r[0], s = r[r.length - 1], a = t.start, o = t.end; + return !!(a != null && a.exec(i)) && !!(o != null && o.exec(s)); +} +function nu(n) { + let e = ""; + return typeof n == "string" ? e = n : e = n.text, e.split(Gd); +} +const al = /\s*(@([\p{L}][\p{L}\p{N}]*)?)/uy, dg = /\{(@[\p{L}][\p{L}\p{N}]*)(\s*)([^\r\n}]+)?\}/gu; +function fg(n) { + var e, t, r; + const i = []; + let s = n.position.line, a = n.position.character; + for (let o = 0; o < n.lines.length; o++) { + const l = o === 0, c = o === n.lines.length - 1; + let u = n.lines[o], d = 0; + if (l && n.options.start) { + const f = (e = n.options.start) === null || e === void 0 ? void 0 : e.exec(u); + f && (d = f.index + f[0].length); + } else { + const f = (t = n.options.line) === null || t === void 0 ? void 0 : t.exec(u); + f && (d = f.index + f[0].length); + } + if (c) { + const f = (r = n.options.end) === null || r === void 0 ? void 0 : r.exec(u); + f && (u = u.substring(0, f.index)); + } + if (u = u.substring(0, gg(u)), Os(u, d) >= u.length) { + if (i.length > 0) { + const f = P.create(s, a); + i.push({ + type: "break", + content: "", + range: b.create(f, f) + }); + } + } else { + al.lastIndex = d; + const f = al.exec(u); + if (f) { + const m = f[0], g = f[1], v = P.create(s, a + d), y = P.create(s, a + d + m.length); + i.push({ + type: "tag", + content: g, + range: b.create(v, y) + }), d += m.length, d = Os(u, d); + } + if (d < u.length) { + const m = u.substring(d), g = Array.from(m.matchAll(dg)); + i.push(...hg(g, m, s, a + d)); + } + } + s++, a = 0; + } + return i.length > 0 && i[i.length - 1].type === "break" ? i.slice(0, -1) : i; +} +function hg(n, e, t, r) { + const i = []; + if (n.length === 0) { + const s = P.create(t, r), a = P.create(t, r + e.length); + i.push({ + type: "text", + content: e, + range: b.create(s, a) + }); + } else { + let s = 0; + for (const o of n) { + const l = o.index, c = e.substring(s, l); + c.length > 0 && i.push({ + type: "text", + content: e.substring(s, l), + range: b.create(P.create(t, s + r), P.create(t, l + r)) + }); + let u = c.length + 1; + const d = o[1]; + if (i.push({ + type: "inline-tag", + content: d, + range: b.create(P.create(t, s + u + r), P.create(t, s + u + d.length + r)) + }), u += d.length, o.length === 4) { + u += o[2].length; + const h = o[3]; + i.push({ + type: "text", + content: h, + range: b.create(P.create(t, s + u + r), P.create(t, s + u + h.length + r)) + }); + } else + i.push({ + type: "text", + content: "", + range: b.create(P.create(t, s + u + r), P.create(t, s + u + r)) + }); + s = l + o[0].length; + } + const a = e.substring(s); + a.length > 0 && i.push({ + type: "text", + content: a, + range: b.create(P.create(t, s + r), P.create(t, s + r + a.length)) + }); + } + return i; +} +const pg = /\S/, mg = /\s*$/; +function Os(n, e) { + const t = n.substring(e).match(pg); + return t ? e + t.index : n.length; +} +function gg(n) { + const e = n.match(mg); + if (e && typeof e.index == "number") + return e.index; +} +function yg(n) { + var e, t, r, i; + const s = P.create(n.position.line, n.position.character); + if (n.tokens.length === 0) + return new ol([], b.create(s, s)); + const a = []; + for (; n.index < n.tokens.length; ) { + const c = Tg(n, a[a.length - 1]); + c && a.push(c); + } + const o = (t = (e = a[0]) === null || e === void 0 ? void 0 : e.range.start) !== null && t !== void 0 ? t : s, l = (i = (r = a[a.length - 1]) === null || r === void 0 ? void 0 : r.range.end) !== null && i !== void 0 ? i : s; + return new ol(a, b.create(o, l)); +} +function Tg(n, e) { + const t = n.tokens[n.index]; + if (t.type === "tag") + return iu(n, !1); + if (t.type === "text" || t.type === "inline-tag") + return ru(n); + Rg(t, e), n.index++; +} +function Rg(n, e) { + if (e) { + const t = new au("", n.range); + "inlines" in e ? e.inlines.push(t) : e.content.inlines.push(t); + } +} +function ru(n) { + let e = n.tokens[n.index]; + const t = e; + let r = e; + const i = []; + for (; e && e.type !== "break" && e.type !== "tag"; ) + i.push(vg(n)), r = e, e = n.tokens[n.index]; + return new bs(i, b.create(t.range.start, r.range.end)); +} +function vg(n) { + return n.tokens[n.index].type === "inline-tag" ? iu(n, !0) : su(n); +} +function iu(n, e) { + const t = n.tokens[n.index++], r = t.content.substring(1), i = n.tokens[n.index]; + if ((i == null ? void 0 : i.type) === "text") + if (e) { + const s = su(n); + return new Bi(r, new bs([s], s.range), e, b.create(t.range.start, s.range.end)); + } else { + const s = ru(n); + return new Bi(r, s, e, b.create(t.range.start, s.range.end)); + } + else { + const s = t.range; + return new Bi(r, new bs([], s), e, s); + } +} +function su(n) { + const e = n.tokens[n.index++]; + return new au(e.content, e.range); +} +function la(n) { + if (!n) + return la({ + start: "/**", + end: "*/", + line: "*" + }); + const { start: e, end: t, line: r } = n; + return { + start: Ui(e, !0), + end: Ui(t, !1), + line: Ui(r, !0) + }; +} +function Ui(n, e) { + if (typeof n == "string" || typeof n == "object") { + const t = typeof n == "string" ? di(n) : n.source; + return e ? new RegExp(`^\\s*${t}`) : new RegExp(`\\s*${t}\\s*$`); + } else + return n; +} +class ol { + constructor(e, t) { + this.elements = e, this.range = t; + } + getTag(e) { + return this.getAllTags().find((t) => t.name === e); + } + getTags(e) { + return this.getAllTags().filter((t) => t.name === e); + } + getAllTags() { + return this.elements.filter((e) => "name" in e); + } + toString() { + let e = ""; + for (const t of this.elements) + if (e.length === 0) + e = t.toString(); + else { + const r = t.toString(); + e += ll(e) + r; + } + return e.trim(); + } + toMarkdown(e) { + let t = ""; + for (const r of this.elements) + if (t.length === 0) + t = r.toMarkdown(e); + else { + const i = r.toMarkdown(e); + t += ll(t) + i; + } + return t.trim(); + } +} +class Bi { + constructor(e, t, r, i) { + this.name = e, this.content = t, this.inline = r, this.range = i; + } + toString() { + let e = `@${this.name}`; + const t = this.content.toString(); + return this.content.inlines.length === 1 ? e = `${e} ${t}` : this.content.inlines.length > 1 && (e = `${e} +${t}`), this.inline ? `{${e}}` : e; + } + toMarkdown(e) { + var t, r; + return (r = (t = e == null ? void 0 : e.renderTag) === null || t === void 0 ? void 0 : t.call(e, this)) !== null && r !== void 0 ? r : this.toMarkdownDefault(e); + } + toMarkdownDefault(e) { + const t = this.content.toMarkdown(e); + if (this.inline) { + const s = Ag(this.name, t, e ?? {}); + if (typeof s == "string") + return s; + } + let r = ""; + (e == null ? void 0 : e.tag) === "italic" || (e == null ? void 0 : e.tag) === void 0 ? r = "*" : (e == null ? void 0 : e.tag) === "bold" ? r = "**" : (e == null ? void 0 : e.tag) === "bold-italic" && (r = "***"); + let i = `${r}@${this.name}${r}`; + return this.content.inlines.length === 1 ? i = `${i} — ${t}` : this.content.inlines.length > 1 && (i = `${i} +${t}`), this.inline ? `{${i}}` : i; + } +} +function Ag(n, e, t) { + var r, i; + if (n === "linkplain" || n === "linkcode" || n === "link") { + const s = e.indexOf(" "); + let a = e; + if (s > 0) { + const l = Os(e, s); + a = e.substring(l), e = e.substring(0, s); + } + return (n === "linkcode" || n === "link" && t.link === "code") && (a = `\`${a}\``), (i = (r = t.renderLink) === null || r === void 0 ? void 0 : r.call(t, e, a)) !== null && i !== void 0 ? i : Eg(e, a); + } +} +function Eg(n, e) { + try { + return mt.parse(n, !0), `[${e}](${n})`; + } catch { + return n; + } +} +class bs { + constructor(e, t) { + this.inlines = e, this.range = t; + } + toString() { + let e = ""; + for (let t = 0; t < this.inlines.length; t++) { + const r = this.inlines[t], i = this.inlines[t + 1]; + e += r.toString(), i && i.range.start.line > r.range.start.line && (e += ` +`); + } + return e; + } + toMarkdown(e) { + let t = ""; + for (let r = 0; r < this.inlines.length; r++) { + const i = this.inlines[r], s = this.inlines[r + 1]; + t += i.toMarkdown(e), s && s.range.start.line > i.range.start.line && (t += ` +`); + } + return t; + } +} +class au { + constructor(e, t) { + this.text = e, this.range = t; + } + toString() { + return this.text; + } + toMarkdown() { + return this.text; + } +} +function ll(n) { + return n.endsWith(` +`) ? ` +` : ` + +`; +} +class kg { + constructor(e) { + this.indexManager = e.shared.workspace.IndexManager, this.commentProvider = e.documentation.CommentProvider; + } + getDocumentation(e) { + const t = this.commentProvider.getComment(e); + if (t && ug(t)) + return cg(t).toMarkdown({ + renderLink: (i, s) => this.documentationLinkRenderer(e, i, s), + renderTag: (i) => this.documentationTagRenderer(e, i) + }); + } + documentationLinkRenderer(e, t, r) { + var i; + const s = (i = this.findNameInPrecomputedScopes(e, t)) !== null && i !== void 0 ? i : this.findNameInGlobalScope(e, t); + if (s && s.nameSegment) { + const a = s.nameSegment.range.start.line + 1, o = s.nameSegment.range.start.character + 1, l = s.documentUri.with({ fragment: `L${a},${o}` }); + return `[${r}](${l.toString()})`; + } else + return; + } + documentationTagRenderer(e, t) { + } + findNameInPrecomputedScopes(e, t) { + const i = et(e).precomputedScopes; + if (!i) + return; + let s = e; + do { + const o = i.get(s).find((l) => l.name === t); + if (o) + return o; + s = s.$container; + } while (s); + } + findNameInGlobalScope(e, t) { + return this.indexManager.allElements().find((i) => i.name === t); + } +} +class xg { + constructor(e) { + this.grammarConfig = () => e.parser.GrammarConfig; + } + getComment(e) { + var t; + return jm(e) ? e.$comment : (t = md(e.$cstNode, this.grammarConfig().multilineCommentRules)) === null || t === void 0 ? void 0 : t.text; + } +} +class $g { + constructor(e) { + this.syncParser = e.parser.LangiumParser; + } + parse(e, t) { + return Promise.resolve(this.syncParser.parse(e)); + } +} +class Sg { + constructor() { + this.previousTokenSource = new aa(), this.writeQueue = [], this.readQueue = [], this.done = !0; + } + write(e) { + this.cancelWrite(); + const t = _m(); + return this.previousTokenSource = t, this.enqueue(this.writeQueue, e, t.token); + } + read(e) { + return this.enqueue(this.readQueue, e); + } + enqueue(e, t, r = V.None) { + const i = new oa(), s = { + action: t, + deferred: i, + cancellationToken: r + }; + return e.push(s), this.performNextOperation(), i.promise; + } + async performNextOperation() { + if (!this.done) + return; + const e = []; + if (this.writeQueue.length > 0) + e.push(this.writeQueue.shift()); + else if (this.readQueue.length > 0) + e.push(...this.readQueue.splice(0, this.readQueue.length)); + else + return; + this.done = !1, await Promise.all(e.map(async ({ action: t, deferred: r, cancellationToken: i }) => { + try { + const s = await Promise.resolve().then(() => t(i)); + r.resolve(s); + } catch (s) { + Ai(s) ? r.resolve(void 0) : r.reject(s); + } + })), this.done = !0, this.performNextOperation(); + } + cancelWrite() { + this.previousTokenSource.cancel(); + } +} +class Ig { + constructor(e) { + this.grammarElementIdMap = new nl(), this.tokenTypeIdMap = new nl(), this.grammar = e.Grammar, this.lexer = e.parser.Lexer, this.linker = e.references.Linker; + } + dehydrate(e) { + return { + lexerErrors: e.lexerErrors, + lexerReport: e.lexerReport ? this.dehydrateLexerReport(e.lexerReport) : void 0, + // We need to create shallow copies of the errors + // The original errors inherit from the `Error` class, which is not transferable across worker threads + parserErrors: e.parserErrors.map((t) => Object.assign(Object.assign({}, t), { message: t.message })), + value: this.dehydrateAstNode(e.value, this.createDehyrationContext(e.value)) + }; + } + dehydrateLexerReport(e) { + return e; + } + createDehyrationContext(e) { + const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(); + for (const i of It(e)) + t.set(i, {}); + if (e.$cstNode) + for (const i of Ji(e.$cstNode)) + r.set(i, {}); + return { + astNodes: t, + cstNodes: r + }; + } + dehydrateAstNode(e, t) { + const r = t.astNodes.get(e); + r.$type = e.$type, r.$containerIndex = e.$containerIndex, r.$containerProperty = e.$containerProperty, e.$cstNode !== void 0 && (r.$cstNode = this.dehydrateCstNode(e.$cstNode, t)); + for (const [i, s] of Object.entries(e)) + if (!i.startsWith("$")) + if (Array.isArray(s)) { + const a = []; + r[i] = a; + for (const o of s) + ae(o) ? a.push(this.dehydrateAstNode(o, t)) : Ge(o) ? a.push(this.dehydrateReference(o, t)) : a.push(o); + } else ae(s) ? r[i] = this.dehydrateAstNode(s, t) : Ge(s) ? r[i] = this.dehydrateReference(s, t) : s !== void 0 && (r[i] = s); + return r; + } + dehydrateReference(e, t) { + const r = {}; + return r.$refText = e.$refText, e.$refNode && (r.$refNode = t.cstNodes.get(e.$refNode)), r; + } + dehydrateCstNode(e, t) { + const r = t.cstNodes.get(e); + return Cl(e) ? r.fullText = e.fullText : r.grammarSource = this.getGrammarElementId(e.grammarSource), r.hidden = e.hidden, r.astNode = t.astNodes.get(e.astNode), Hn(e) ? r.content = e.content.map((i) => this.dehydrateCstNode(i, t)) : Nl(e) && (r.tokenType = e.tokenType.name, r.offset = e.offset, r.length = e.length, r.startLine = e.range.start.line, r.startColumn = e.range.start.character, r.endLine = e.range.end.line, r.endColumn = e.range.end.character), r; + } + hydrate(e) { + const t = e.value, r = this.createHydrationContext(t); + return "$cstNode" in t && this.hydrateCstNode(t.$cstNode, r), { + lexerErrors: e.lexerErrors, + lexerReport: e.lexerReport, + parserErrors: e.parserErrors, + value: this.hydrateAstNode(t, r) + }; + } + createHydrationContext(e) { + const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(); + for (const s of It(e)) + t.set(s, {}); + let i; + if (e.$cstNode) + for (const s of Ji(e.$cstNode)) { + let a; + "fullText" in s ? (a = new Fc(s.fullText), i = a) : "content" in s ? a = new ia() : "tokenType" in s && (a = this.hydrateCstLeafNode(s)), a && (r.set(s, a), a.root = i); + } + return { + astNodes: t, + cstNodes: r + }; + } + hydrateAstNode(e, t) { + const r = t.astNodes.get(e); + r.$type = e.$type, r.$containerIndex = e.$containerIndex, r.$containerProperty = e.$containerProperty, e.$cstNode && (r.$cstNode = t.cstNodes.get(e.$cstNode)); + for (const [i, s] of Object.entries(e)) + if (!i.startsWith("$")) + if (Array.isArray(s)) { + const a = []; + r[i] = a; + for (const o of s) + ae(o) ? a.push(this.setParent(this.hydrateAstNode(o, t), r)) : Ge(o) ? a.push(this.hydrateReference(o, r, i, t)) : a.push(o); + } else ae(s) ? r[i] = this.setParent(this.hydrateAstNode(s, t), r) : Ge(s) ? r[i] = this.hydrateReference(s, r, i, t) : s !== void 0 && (r[i] = s); + return r; + } + setParent(e, t) { + return e.$container = t, e; + } + hydrateReference(e, t, r, i) { + return this.linker.buildReference(t, r, i.cstNodes.get(e.$refNode), e.$refText); + } + hydrateCstNode(e, t, r = 0) { + const i = t.cstNodes.get(e); + if (typeof e.grammarSource == "number" && (i.grammarSource = this.getGrammarElement(e.grammarSource)), i.astNode = t.astNodes.get(e.astNode), Hn(i)) + for (const s of e.content) { + const a = this.hydrateCstNode(s, t, r++); + i.content.push(a); + } + return i; + } + hydrateCstLeafNode(e) { + const t = this.getTokenType(e.tokenType), r = e.offset, i = e.length, s = e.startLine, a = e.startColumn, o = e.endLine, l = e.endColumn, c = e.hidden; + return new $s(r, i, { + start: { + line: s, + character: a + }, + end: { + line: o, + character: l + } + }, t, c); + } + getTokenType(e) { + return this.lexer.definition[e]; + } + getGrammarElementId(e) { + if (e) + return this.grammarElementIdMap.size === 0 && this.createGrammarElementIdMap(), this.grammarElementIdMap.get(e); + } + getGrammarElement(e) { + return this.grammarElementIdMap.size === 0 && this.createGrammarElementIdMap(), this.grammarElementIdMap.getKey(e); + } + createGrammarElementIdMap() { + let e = 0; + for (const t of It(this.grammar)) + yd(t) && this.grammarElementIdMap.set(t, e++); + } +} +function Rt(n) { + return { + documentation: { + CommentProvider: (e) => new xg(e), + DocumentationProvider: (e) => new kg(e) + }, + parser: { + AsyncParser: (e) => new $g(e), + GrammarConfig: (e) => cf(e), + LangiumParser: (e) => gm(e), + CompletionParser: (e) => mm(e), + ValueConverter: () => new zc(), + TokenBuilder: () => new Hc(), + Lexer: (e) => new og(e), + ParserErrorMessageProvider: () => new Bc(), + LexerErrorMessageProvider: () => new sg() + }, + workspace: { + AstNodeLocator: () => new eg(), + AstNodeDescriptionProvider: (e) => new Qm(e), + ReferenceDescriptionProvider: (e) => new Zm(e) + }, + references: { + Linker: (e) => new Pm(e), + NameProvider: () => new Dm(), + ScopeProvider: (e) => new Wm(e), + ScopeComputation: (e) => new Gm(e), + References: (e) => new Fm(e) + }, + serializer: { + Hydrator: (e) => new Ig(e), + JsonSerializer: (e) => new Hm(e) + }, + validation: { + DocumentValidator: (e) => new Ym(e), + ValidationRegistry: (e) => new qm(e) + }, + shared: () => n.shared + }; +} +function vt(n) { + return { + ServiceRegistry: (e) => new zm(e), + workspace: { + LangiumDocuments: (e) => new bm(e), + LangiumDocumentFactory: (e) => new Om(e), + DocumentBuilder: (e) => new ng(e), + IndexManager: (e) => new rg(e), + WorkspaceManager: (e) => new ig(e), + FileSystemProvider: (e) => n.fileSystemProvider(e), + WorkspaceLock: () => new Sg(), + ConfigurationProvider: (e) => new tg(e) + } + }; +} +var cl; +(function(n) { + n.merge = (e, t) => si(si({}, e), t); +})(cl || (cl = {})); +function pe(n, e, t, r, i, s, a, o, l) { + const c = [n, e, t, r, i, s, a, o, l].reduce(si, {}); + return ou(c); +} +const Ng = Symbol("isProxy"); +function ou(n, e) { + const t = new Proxy({}, { + deleteProperty: () => !1, + set: () => { + throw new Error("Cannot set property on injected service container"); + }, + get: (r, i) => i === Ng ? !0 : dl(r, i, n, e || t), + getOwnPropertyDescriptor: (r, i) => (dl(r, i, n, e || t), Object.getOwnPropertyDescriptor(r, i)), + // used by for..in + has: (r, i) => i in n, + // used by ..in.. + ownKeys: () => [...Object.getOwnPropertyNames(n)] + // used by for..in + }); + return t; +} +const ul = Symbol(); +function dl(n, e, t, r) { + if (e in n) { + if (n[e] instanceof Error) + throw new Error("Construction failure. Please make sure that your dependencies are constructable.", { cause: n[e] }); + if (n[e] === ul) + throw new Error('Cycle detected. Please make "' + String(e) + '" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies'); + return n[e]; + } else if (e in t) { + const i = t[e]; + n[e] = ul; + try { + n[e] = typeof i == "function" ? i(r) : ou(i, r); + } catch (s) { + throw n[e] = s instanceof Error ? s : void 0, s; + } + return n[e]; + } else + return; +} +function si(n, e) { + if (e) { + for (const [t, r] of Object.entries(e)) + if (r !== void 0) { + const i = n[t]; + i !== null && r !== null && typeof i == "object" && typeof r == "object" ? n[t] = si(i, r) : n[t] = r; + } + } + return n; +} +class Cg { + readFile() { + throw new Error("No file system is available."); + } + async readDirectory() { + return []; + } +} +const At = { + fileSystemProvider: () => new Cg() +}, wg = { + Grammar: () => { + }, + LanguageMetaData: () => ({ + caseInsensitive: !1, + fileExtensions: [".langium"], + languageId: "langium" + }) +}, _g = { + AstReflection: () => new Ml() +}; +function Lg() { + const n = pe(vt(At), _g), e = pe(Rt({ shared: n }), wg); + return n.ServiceRegistry.register(e), e; +} +function nn(n) { + var e; + const t = Lg(), r = t.serializer.JsonSerializer.deserialize(n); + return t.shared.workspace.LangiumDocumentFactory.fromModel(r, mt.parse(`memory://${(e = r.name) !== null && e !== void 0 ? e : "grammar"}.langium`)), r; +} +var Og = Object.defineProperty, k = (n, e) => Og(n, "name", { value: e, configurable: !0 }), fl = "Statement", wr = "Architecture"; +function bg(n) { + return Be.isInstance(n, wr); +} +k(bg, "isArchitecture"); +var Tr = "Axis", Un = "Branch"; +function Pg(n) { + return Be.isInstance(n, Un); +} +k(Pg, "isBranch"); +var Rr = "Checkout", vr = "CherryPicking", Bn = "Commit"; +function Mg(n) { + return Be.isInstance(n, Bn); +} +k(Mg, "isCommit"); +var Vi = "Curve", Ki = "Edge", Wi = "Entry", Vn = "GitGraph"; +function Dg(n) { + return Be.isInstance(n, Vn); +} +k(Dg, "isGitGraph"); +var ji = "Group", _r = "Info"; +function Fg(n) { + return Be.isInstance(n, _r); +} +k(Fg, "isInfo"); +var Hi = "Junction", Kn = "Merge"; +function Gg(n) { + return Be.isInstance(n, Kn); +} +k(Gg, "isMerge"); +var zi = "Option", Lr = "Packet"; +function Ug(n) { + return Be.isInstance(n, Lr); +} +k(Ug, "isPacket"); +var Or = "PacketBlock"; +function Bg(n) { + return Be.isInstance(n, Or); +} +k(Bg, "isPacketBlock"); +var br = "Pie"; +function Vg(n) { + return Be.isInstance(n, br); +} +k(Vg, "isPie"); +var Pr = "PieSection"; +function Kg(n) { + return Be.isInstance(n, Pr); +} +k(Kg, "isPieSection"); +var qi = "Radar", Yi = "Service", Ar = "Direction", Ct, lu = (Ct = class extends Il { + getAllTypes() { + return [wr, Tr, Un, Rr, vr, Bn, Vi, Ar, Ki, Wi, Vn, ji, _r, Hi, Kn, zi, Lr, Or, br, Pr, qi, Yi, fl]; + } + computeIsSubtype(e, t) { + switch (e) { + case Un: + case Rr: + case vr: + case Bn: + case Kn: + return this.isSubtype(fl, t); + case Ar: + return this.isSubtype(Vn, t); + default: + return !1; + } + } + getReferenceType(e) { + const t = `${e.container.$type}:${e.property}`; + switch (t) { + case "Entry:axis": + return Tr; + default: + throw new Error(`${t} is not a valid reference id.`); + } + } + getTypeMetaData(e) { + switch (e) { + case wr: + return { + name: wr, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "edges", defaultValue: [] }, + { name: "groups", defaultValue: [] }, + { name: "junctions", defaultValue: [] }, + { name: "services", defaultValue: [] }, + { name: "title" } + ] + }; + case Tr: + return { + name: Tr, + properties: [ + { name: "label" }, + { name: "name" } + ] + }; + case Un: + return { + name: Un, + properties: [ + { name: "name" }, + { name: "order" } + ] + }; + case Rr: + return { + name: Rr, + properties: [ + { name: "branch" } + ] + }; + case vr: + return { + name: vr, + properties: [ + { name: "id" }, + { name: "parent" }, + { name: "tags", defaultValue: [] } + ] + }; + case Bn: + return { + name: Bn, + properties: [ + { name: "id" }, + { name: "message" }, + { name: "tags", defaultValue: [] }, + { name: "type" } + ] + }; + case Vi: + return { + name: Vi, + properties: [ + { name: "entries", defaultValue: [] }, + { name: "label" }, + { name: "name" } + ] + }; + case Ki: + return { + name: Ki, + properties: [ + { name: "lhsDir" }, + { name: "lhsGroup", defaultValue: !1 }, + { name: "lhsId" }, + { name: "lhsInto", defaultValue: !1 }, + { name: "rhsDir" }, + { name: "rhsGroup", defaultValue: !1 }, + { name: "rhsId" }, + { name: "rhsInto", defaultValue: !1 }, + { name: "title" } + ] + }; + case Wi: + return { + name: Wi, + properties: [ + { name: "axis" }, + { name: "value" } + ] + }; + case Vn: + return { + name: Vn, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "statements", defaultValue: [] }, + { name: "title" } + ] + }; + case ji: + return { + name: ji, + properties: [ + { name: "icon" }, + { name: "id" }, + { name: "in" }, + { name: "title" } + ] + }; + case _r: + return { + name: _r, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "title" } + ] + }; + case Hi: + return { + name: Hi, + properties: [ + { name: "id" }, + { name: "in" } + ] + }; + case Kn: + return { + name: Kn, + properties: [ + { name: "branch" }, + { name: "id" }, + { name: "tags", defaultValue: [] }, + { name: "type" } + ] + }; + case zi: + return { + name: zi, + properties: [ + { name: "name" }, + { name: "value", defaultValue: !1 } + ] + }; + case Lr: + return { + name: Lr, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "blocks", defaultValue: [] }, + { name: "title" } + ] + }; + case Or: + return { + name: Or, + properties: [ + { name: "bits" }, + { name: "end" }, + { name: "label" }, + { name: "start" } + ] + }; + case br: + return { + name: br, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "sections", defaultValue: [] }, + { name: "showData", defaultValue: !1 }, + { name: "title" } + ] + }; + case Pr: + return { + name: Pr, + properties: [ + { name: "label" }, + { name: "value" } + ] + }; + case qi: + return { + name: qi, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "axes", defaultValue: [] }, + { name: "curves", defaultValue: [] }, + { name: "options", defaultValue: [] }, + { name: "title" } + ] + }; + case Yi: + return { + name: Yi, + properties: [ + { name: "icon" }, + { name: "iconText" }, + { name: "id" }, + { name: "in" }, + { name: "title" } + ] + }; + case Ar: + return { + name: Ar, + properties: [ + { name: "accDescr" }, + { name: "accTitle" }, + { name: "dir" }, + { name: "statements", defaultValue: [] }, + { name: "title" } + ] + }; + default: + return { + name: e, + properties: [] + }; + } + } +}, k(Ct, "MermaidAstReflection"), Ct), Be = new lu(), hl, Wg = /* @__PURE__ */ k(() => hl ?? (hl = nn(`{"$type":"Grammar","isDeclared":true,"name":"Info","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Info","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"info"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Keyword","value":"showInfo"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"?"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@7"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@8"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[],"types":[],"usedGrammars":[]}`)), "InfoGrammar"), pl, jg = /* @__PURE__ */ k(() => pl ?? (pl = nn(`{"$type":"Grammar","isDeclared":true,"name":"Packet","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Packet","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"packet-beta"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]},{"$type":"Assignment","feature":"blocks","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"PacketBlock","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Assignment","feature":"start","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"end","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}],"cardinality":"?"}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"+"},{"$type":"Assignment","feature":"bits","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]}]},{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@8"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@9"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[],"types":[],"usedGrammars":[]}`)), "PacketGrammar"), ml, Hg = /* @__PURE__ */ k(() => ml ?? (ml = nn(`{"$type":"Grammar","isDeclared":true,"name":"Pie","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Pie","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"pie"},{"$type":"Assignment","feature":"showData","operator":"?=","terminal":{"$type":"Keyword","value":"showData"},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]},{"$type":"Assignment","feature":"sections","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"PieSection","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@8"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@9"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[],"types":[],"usedGrammars":[]}`)), "PieGrammar"), gl, zg = /* @__PURE__ */ k(() => gl ?? (gl = nn(`{"$type":"Grammar","isDeclared":true,"name":"Architecture","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Architecture","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"architecture-beta"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"groups","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"services","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"junctions","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Assignment","feature":"edges","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"LeftPort","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"lhsDir","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"RightPort","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"rhsDir","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Keyword","value":":"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Arrow","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]},{"$type":"Assignment","feature":"lhsInto","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"--"},{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]}},{"$type":"Keyword","value":"-"}]}]},{"$type":"Assignment","feature":"rhsInto","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Group","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"group"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Assignment","feature":"icon","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@28"},"arguments":[]},"cardinality":"?"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]},"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Service","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"service"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"iconText","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]}},{"$type":"Assignment","feature":"icon","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@28"},"arguments":[]}}],"cardinality":"?"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@29"},"arguments":[]},"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Junction","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"junction"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Edge","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"lhsId","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Assignment","feature":"lhsGroup","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Assignment","feature":"rhsId","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Assignment","feature":"rhsGroup","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"ARROW_DIRECTION","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"L"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"R"}}]},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"T"}}]},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"B"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW_GROUP","definition":{"$type":"RegexToken","regex":"/\\\\{group\\\\}/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW_INTO","definition":{"$type":"RegexToken","regex":"/<|>/"},"fragment":false,"hidden":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@23"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@18"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@19"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false},{"$type":"TerminalRule","name":"ARCH_ICON","definition":{"$type":"RegexToken","regex":"/\\\\([\\\\w-:]+\\\\)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARCH_TITLE","definition":{"$type":"RegexToken","regex":"/\\\\[[\\\\w ]+\\\\]/"},"fragment":false,"hidden":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[],"types":[],"usedGrammars":[]}`)), "ArchitectureGrammar"), yl, qg = /* @__PURE__ */ k(() => yl ?? (yl = nn(`{"$type":"Grammar","isDeclared":true,"name":"GitGraph","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"GitGraph","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"Group","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"Keyword","value":":"}]},{"$type":"Keyword","value":"gitGraph:"},{"$type":"Group","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]},{"$type":"Keyword","value":":"}]}]},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]},{"$type":"Assignment","feature":"statements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Direction","definition":{"$type":"Assignment","feature":"dir","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"LR"},{"$type":"Keyword","value":"TB"},{"$type":"Keyword","value":"BT"}]}},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Commit","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"commit"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"msg:","cardinality":"?"},{"$type":"Assignment","feature":"message","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"type:"},{"$type":"Assignment","feature":"type","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"NORMAL"},{"$type":"Keyword","value":"REVERSE"},{"$type":"Keyword","value":"HIGHLIGHT"}]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Branch","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"branch"},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"order:"},{"$type":"Assignment","feature":"order","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Merge","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"merge"},{"$type":"Assignment","feature":"branch","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]}},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"type:"},{"$type":"Assignment","feature":"type","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"NORMAL"},{"$type":"Keyword","value":"REVERSE"},{"$type":"Keyword","value":"HIGHLIGHT"}]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Checkout","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"checkout"},{"$type":"Keyword","value":"switch"}]},{"$type":"Assignment","feature":"branch","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@24"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"CherryPicking","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"cherry-pick"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"parent:"},{"$type":"Assignment","feature":"parent","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@14"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@15"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false},{"$type":"TerminalRule","name":"REFERENCE","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\\\w([-\\\\./\\\\w]*[-\\\\w])?/"},"fragment":false,"hidden":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[],"types":[],"usedGrammars":[]}`)), "GitGraphGrammar"), Tl, Yg = /* @__PURE__ */ k(() => Tl ?? (Tl = nn(`{"$type":"Grammar","isDeclared":true,"name":"Radar","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Radar","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"radar-beta"},{"$type":"Keyword","value":"radar-beta:"},{"$type":"Group","elements":[{"$type":"Keyword","value":"radar-beta"},{"$type":"Keyword","value":":"}]}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]},{"$type":"Group","elements":[{"$type":"Keyword","value":"axis"},{"$type":"Assignment","feature":"axes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"axes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"curve"},{"$type":"Assignment","feature":"curves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"curves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"options","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"options","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Label","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}},{"$type":"Keyword","value":"]"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Axis","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[],"cardinality":"?"}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Curve","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[],"cardinality":"?"},{"$type":"Keyword","value":"{"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Keyword","value":"}"}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Entries","definition":{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"*"}]}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"DetailedEntry","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"axis","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@2"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},"deprecatedSyntax":false}},{"$type":"Keyword","value":":","cardinality":"?"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"NumberEntry","returnType":{"$ref":"#/interfaces@0"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Option","definition":{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"showLegend"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"ticks"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"max"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"min"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"graticule"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}}]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"GRATICULE","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"circle"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"polygon"}}]},"fragment":false,"hidden":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@15"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@16"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"interfaces":[{"$type":"Interface","name":"Entry","attributes":[{"$type":"TypeAttribute","name":"axis","isOptional":true,"type":{"$type":"ReferenceType","referenceType":{"$type":"SimpleType","typeRef":{"$ref":"#/rules@2"}}}},{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"number"},"isOptional":false}],"superTypes":[]}],"definesHiddenTokens":false,"hiddenTokens":[],"types":[],"usedGrammars":[]}`)), "RadarGrammar"), Xg = { + languageId: "info", + fileExtensions: [".mmd", ".mermaid"], + caseInsensitive: !1, + mode: "production" +}, Jg = { + languageId: "packet", + fileExtensions: [".mmd", ".mermaid"], + caseInsensitive: !1, + mode: "production" +}, Qg = { + languageId: "pie", + fileExtensions: [".mmd", ".mermaid"], + caseInsensitive: !1, + mode: "production" +}, Zg = { + languageId: "architecture", + fileExtensions: [".mmd", ".mermaid"], + caseInsensitive: !1, + mode: "production" +}, ey = { + languageId: "gitGraph", + fileExtensions: [".mmd", ".mermaid"], + caseInsensitive: !1, + mode: "production" +}, ty = { + languageId: "radar", + fileExtensions: [".mmd", ".mermaid"], + caseInsensitive: !1, + mode: "production" +}, rn = { + AstReflection: /* @__PURE__ */ k(() => new lu(), "AstReflection") +}, ny = { + Grammar: /* @__PURE__ */ k(() => Wg(), "Grammar"), + LanguageMetaData: /* @__PURE__ */ k(() => Xg, "LanguageMetaData"), + parser: {} +}, ry = { + Grammar: /* @__PURE__ */ k(() => jg(), "Grammar"), + LanguageMetaData: /* @__PURE__ */ k(() => Jg, "LanguageMetaData"), + parser: {} +}, iy = { + Grammar: /* @__PURE__ */ k(() => Hg(), "Grammar"), + LanguageMetaData: /* @__PURE__ */ k(() => Qg, "LanguageMetaData"), + parser: {} +}, sy = { + Grammar: /* @__PURE__ */ k(() => zg(), "Grammar"), + LanguageMetaData: /* @__PURE__ */ k(() => Zg, "LanguageMetaData"), + parser: {} +}, ay = { + Grammar: /* @__PURE__ */ k(() => qg(), "Grammar"), + LanguageMetaData: /* @__PURE__ */ k(() => ey, "LanguageMetaData"), + parser: {} +}, oy = { + Grammar: /* @__PURE__ */ k(() => Yg(), "Grammar"), + LanguageMetaData: /* @__PURE__ */ k(() => ty, "LanguageMetaData"), + parser: {} +}, ly = /accDescr(?:[\t ]*:([^\n\r]*)|\s*{([^}]*)})/, cy = /accTitle[\t ]*:([^\n\r]*)/, uy = /title([\t ][^\n\r]*|)/, dy = { + ACC_DESCR: ly, + ACC_TITLE: cy, + TITLE: uy +}, wt, ca = (wt = class extends zc { + runConverter(e, t, r) { + let i = this.runCommonConverter(e, t, r); + return i === void 0 && (i = this.runCustomConverter(e, t, r)), i === void 0 ? super.runConverter(e, t, r) : i; + } + runCommonConverter(e, t, r) { + const i = dy[e.name]; + if (i === void 0) + return; + const s = i.exec(t); + if (s !== null) { + if (s[1] !== void 0) + return s[1].trim().replace(/[\t ]{2,}/gm, " "); + if (s[2] !== void 0) + return s[2].replace(/^\s*/gm, "").replace(/\s+$/gm, "").replace(/[\t ]{2,}/gm, " ").replace(/[\n\r]{2,}/gm, ` +`); + } + } +}, k(wt, "AbstractMermaidValueConverter"), wt), _t, Ei = (_t = class extends ca { + runCustomConverter(e, t, r) { + } +}, k(_t, "CommonValueConverter"), _t), Lt, Et = (Lt = class extends Hc { + constructor(e) { + super(), this.keywords = new Set(e); + } + buildKeywordTokens(e, t, r) { + const i = super.buildKeywordTokens(e, t, r); + return i.forEach((s) => { + this.keywords.has(s.name) && s.PATTERN !== void 0 && (s.PATTERN = new RegExp(s.PATTERN.toString() + "(?:(?=%%)|(?!\\S))")); + }), i; + } +}, k(Lt, "AbstractMermaidTokenBuilder"), Lt), Ot; +Ot = class extends Et { +}, k(Ot, "CommonTokenBuilder"); +var bt, fy = (bt = class extends Et { + constructor() { + super(["gitGraph"]); + } +}, k(bt, "GitGraphTokenBuilder"), bt), cu = { + parser: { + TokenBuilder: /* @__PURE__ */ k(() => new fy(), "TokenBuilder"), + ValueConverter: /* @__PURE__ */ k(() => new Ei(), "ValueConverter") + } +}; +function uu(n = At) { + const e = pe( + vt(n), + rn + ), t = pe( + Rt({ shared: e }), + ay, + cu + ); + return e.ServiceRegistry.register(t), { shared: e, GitGraph: t }; +} +k(uu, "createGitGraphServices"); +var Pt, hy = (Pt = class extends Et { + constructor() { + super(["info", "showInfo"]); + } +}, k(Pt, "InfoTokenBuilder"), Pt), du = { + parser: { + TokenBuilder: /* @__PURE__ */ k(() => new hy(), "TokenBuilder"), + ValueConverter: /* @__PURE__ */ k(() => new Ei(), "ValueConverter") + } +}; +function fu(n = At) { + const e = pe( + vt(n), + rn + ), t = pe( + Rt({ shared: e }), + ny, + du + ); + return e.ServiceRegistry.register(t), { shared: e, Info: t }; +} +k(fu, "createInfoServices"); +var Mt, py = (Mt = class extends Et { + constructor() { + super(["packet-beta"]); + } +}, k(Mt, "PacketTokenBuilder"), Mt), hu = { + parser: { + TokenBuilder: /* @__PURE__ */ k(() => new py(), "TokenBuilder"), + ValueConverter: /* @__PURE__ */ k(() => new Ei(), "ValueConverter") + } +}; +function pu(n = At) { + const e = pe( + vt(n), + rn + ), t = pe( + Rt({ shared: e }), + ry, + hu + ); + return e.ServiceRegistry.register(t), { shared: e, Packet: t }; +} +k(pu, "createPacketServices"); +var Dt, my = (Dt = class extends Et { + constructor() { + super(["pie", "showData"]); + } +}, k(Dt, "PieTokenBuilder"), Dt), Ft, gy = (Ft = class extends ca { + runCustomConverter(e, t, r) { + if (e.name === "PIE_SECTION_LABEL") + return t.replace(/"/g, "").trim(); + } +}, k(Ft, "PieValueConverter"), Ft), mu = { + parser: { + TokenBuilder: /* @__PURE__ */ k(() => new my(), "TokenBuilder"), + ValueConverter: /* @__PURE__ */ k(() => new gy(), "ValueConverter") + } +}; +function gu(n = At) { + const e = pe( + vt(n), + rn + ), t = pe( + Rt({ shared: e }), + iy, + mu + ); + return e.ServiceRegistry.register(t), { shared: e, Pie: t }; +} +k(gu, "createPieServices"); +var Gt, yy = (Gt = class extends Et { + constructor() { + super(["architecture"]); + } +}, k(Gt, "ArchitectureTokenBuilder"), Gt), Ut, Ty = (Ut = class extends ca { + runCustomConverter(e, t, r) { + if (e.name === "ARCH_ICON") + return t.replace(/[()]/g, "").trim(); + if (e.name === "ARCH_TEXT_ICON") + return t.replace(/["()]/g, ""); + if (e.name === "ARCH_TITLE") + return t.replace(/[[\]]/g, "").trim(); + } +}, k(Ut, "ArchitectureValueConverter"), Ut), yu = { + parser: { + TokenBuilder: /* @__PURE__ */ k(() => new yy(), "TokenBuilder"), + ValueConverter: /* @__PURE__ */ k(() => new Ty(), "ValueConverter") + } +}; +function Tu(n = At) { + const e = pe( + vt(n), + rn + ), t = pe( + Rt({ shared: e }), + sy, + yu + ); + return e.ServiceRegistry.register(t), { shared: e, Architecture: t }; +} +k(Tu, "createArchitectureServices"); +var Bt, Ry = (Bt = class extends Et { + constructor() { + super(["radar-beta"]); + } +}, k(Bt, "RadarTokenBuilder"), Bt), Ru = { + parser: { + TokenBuilder: /* @__PURE__ */ k(() => new Ry(), "TokenBuilder"), + ValueConverter: /* @__PURE__ */ k(() => new Ei(), "ValueConverter") + } +}; +function vu(n = At) { + const e = pe( + vt(n), + rn + ), t = pe( + Rt({ shared: e }), + oy, + Ru + ); + return e.ServiceRegistry.register(t), { shared: e, Radar: t }; +} +k(vu, "createRadarServices"); +var Ze = {}, vy = { + info: /* @__PURE__ */ k(async () => { + const { createInfoServices: n } = await Promise.resolve().then(() => ky), e = n().Info.parser.LangiumParser; + Ze.info = e; + }, "info"), + packet: /* @__PURE__ */ k(async () => { + const { createPacketServices: n } = await Promise.resolve().then(() => xy), e = n().Packet.parser.LangiumParser; + Ze.packet = e; + }, "packet"), + pie: /* @__PURE__ */ k(async () => { + const { createPieServices: n } = await Promise.resolve().then(() => $y), e = n().Pie.parser.LangiumParser; + Ze.pie = e; + }, "pie"), + architecture: /* @__PURE__ */ k(async () => { + const { createArchitectureServices: n } = await Promise.resolve().then(() => Sy), e = n().Architecture.parser.LangiumParser; + Ze.architecture = e; + }, "architecture"), + gitGraph: /* @__PURE__ */ k(async () => { + const { createGitGraphServices: n } = await Promise.resolve().then(() => Iy), e = n().GitGraph.parser.LangiumParser; + Ze.gitGraph = e; + }, "gitGraph"), + radar: /* @__PURE__ */ k(async () => { + const { createRadarServices: n } = await Promise.resolve().then(() => Ny), e = n().Radar.parser.LangiumParser; + Ze.radar = e; + }, "radar") +}; +async function Ay(n, e) { + const t = vy[n]; + if (!t) + throw new Error(`Unknown diagram type: ${n}`); + Ze[n] || await t(); + const i = Ze[n].parse(e); + if (i.lexerErrors.length > 0 || i.parserErrors.length > 0) + throw new Ey(i); + return i.value; +} +k(Ay, "parse"); +var Vt, Ey = (Vt = class extends Error { + constructor(e) { + const t = e.lexerErrors.map((i) => i.message).join(` +`), r = e.parserErrors.map((i) => i.message).join(` +`); + super(`Parsing failed: ${t} ${r}`), this.result = e; + } +}, k(Vt, "MermaidParseError"), Vt); +const ky = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + InfoModule: du, + createInfoServices: fu +}, Symbol.toStringTag, { value: "Module" })), xy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + PacketModule: hu, + createPacketServices: pu +}, Symbol.toStringTag, { value: "Module" })), $y = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + PieModule: mu, + createPieServices: gu +}, Symbol.toStringTag, { value: "Module" })), Sy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + ArchitectureModule: yu, + createArchitectureServices: Tu +}, Symbol.toStringTag, { value: "Module" })), Iy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + GitGraphModule: cu, + createGitGraphServices: uu +}, Symbol.toStringTag, { value: "Module" })), Ny = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + RadarModule: Ru, + createRadarServices: vu +}, Symbol.toStringTag, { value: "Module" })); +export { + Ay as p +};