@pareto-engineering/design-system 5.3.0 → 5.4.0

package/dist/ui/a/XMLEditor/XMLEditor.js

@@ -0,0 +1,2447 @@
+import { jsx as Dt } from "react/jsx-runtime";
+import { useRef as Rt, useEffect as Nt } from "react";
+import { P as $ } from "../../../index-CxkFVI6N.js";
+import { S as Et, F as Ue, E as v, I as Fe, g as je, c as ke, i as F, a as O, T as Ye, A as Ze, b as ne, d as Wt, s as M, N as E, f as L, e as Je, C as It, h as Lt, D as Mt, m as R, j as ce, k as zt, P as Vt, l as Gt, n as Qt, o as Xt, p as X, q as _t, r as Ut, t as S, L as Ft, u as jt, v as Yt, w as Zt, x as Jt, y as Te, z as Ht, B as ve, G as Kt, H as es, J as ts, K as ss, M as ns, O as rs, Q as os, R as is, U as ls, V as as, W as hs, X as cs } from "../../../index-BUor0nOw.js";
+import { s as us } from "../../../exports.module-DmUnHWIJ.js";
+import '../../../assets/XMLEditor.css';const fs = (t) => {
+  let { state: e } = t, s = e.doc.lineAt(e.selection.main.from), n = ye(t.state, s.from);
+  return n.line ? ds(t) : n.block ? ms(t) : !1;
+};
+function Se(t, e) {
+  return ({ state: s, dispatch: n }) => {
+    if (s.readOnly)
+      return !1;
+    let r = t(e, s);
+    return r ? (n(s.update(r)), !0) : !1;
+  };
+}
+const ds = /* @__PURE__ */ Se(
+  xs,
+  0
+  /* CommentOption.Toggle */
+), ps = /* @__PURE__ */ Se(
+  He,
+  0
+  /* CommentOption.Toggle */
+), ms = /* @__PURE__ */ Se(
+  (t, e) => He(t, e, gs(e)),
+  0
+  /* CommentOption.Toggle */
+);
+function ye(t, e) {
+  let s = t.languageDataAt("commentTokens", e, 1);
+  return s.length ? s[0] : {};
+}
+const I = 50;
+function Os(t, { open: e, close: s }, n, r) {
+  let o = t.sliceDoc(n - I, n), i = t.sliceDoc(r, r + I), l = /\s*$/.exec(o)[0].length, a = /^\s*/.exec(i)[0].length, h = o.length - l;
+  if (o.slice(h - e.length, h) == e && i.slice(a, a + s.length) == s)
+    return {
+      open: { pos: n - l, margin: l && 1 },
+      close: { pos: r + a, margin: a && 1 }
+    };
+  let c, u;
+  r - n <= 2 * I ? c = u = t.sliceDoc(n, r) : (c = t.sliceDoc(n, n + I), u = t.sliceDoc(r - I, r));
+  let f = /^\s*/.exec(c)[0].length, d = /\s*$/.exec(u)[0].length, p = u.length - d - s.length;
+  return c.slice(f, f + e.length) == e && u.slice(p, p + s.length) == s ? {
+    open: {
+      pos: n + f + e.length,
+      margin: /\s/.test(c.charAt(f + e.length)) ? 1 : 0
+    },
+    close: {
+      pos: r - d - s.length,
+      margin: /\s/.test(u.charAt(p - 1)) ? 1 : 0
+    }
+  } : null;
+}
+function gs(t) {
+  let e = [];
+  for (let s of t.selection.ranges) {
+    let n = t.doc.lineAt(s.from), r = s.to <= n.to ? n : t.doc.lineAt(s.to);
+    r.from > n.from && r.from == s.to && (r = s.to == n.to + 1 ? n : t.doc.lineAt(s.to - 1));
+    let o = e.length - 1;
+    o >= 0 && e[o].to > n.from ? e[o].to = r.to : e.push({ from: n.from + /^\s*/.exec(n.text)[0].length, to: r.to });
+  }
+  return e;
+}
+function He(t, e, s = e.selection.ranges) {
+  let n = s.map((o) => ye(e, o.from).block);
+  if (!n.every((o) => o))
+    return null;
+  let r = s.map((o, i) => Os(e, n[i], o.from, o.to));
+  if (t != 2 && !r.every((o) => o))
+    return { changes: e.changes(s.map((o, i) => r[i] ? [] : [{ from: o.from, insert: n[i].open + " " }, { from: o.to, insert: " " + n[i].close }])) };
+  if (t != 1 && r.some((o) => o)) {
+    let o = [];
+    for (let i = 0, l; i < r.length; i++)
+      if (l = r[i]) {
+        let a = n[i], { open: h, close: c } = l;
+        o.push({ from: h.pos - a.open.length, to: h.pos + h.margin }, { from: c.pos - c.margin, to: c.pos + a.close.length });
+      }
+    return { changes: o };
+  }
+  return null;
+}
+function xs(t, e, s = e.selection.ranges) {
+  let n = [], r = -1;
+  for (let { from: o, to: i } of s) {
+    let l = n.length, a = 1e9, h = ye(e, o).line;
+    if (h) {
+      for (let c = o; c <= i; ) {
+        let u = e.doc.lineAt(c);
+        if (u.from > r && (o == i || i > u.from)) {
+          r = u.from;
+          let f = /^\s*/.exec(u.text)[0].length, d = f == u.length, p = u.text.slice(f, f + h.length) == h ? f : -1;
+          f < u.text.length && f < a && (a = f), n.push({ line: u, comment: p, token: h, indent: f, empty: d, single: !1 });
+        }
+        c = u.to + 1;
+      }
+      if (a < 1e9)
+        for (let c = l; c < n.length; c++)
+          n[c].indent < n[c].line.text.length && (n[c].indent = a);
+      n.length == l + 1 && (n[l].single = !0);
+    }
+  }
+  if (t != 2 && n.some((o) => o.comment < 0 && (!o.empty || o.single))) {
+    let o = [];
+    for (let { line: l, token: a, indent: h, empty: c, single: u } of n)
+      (u || !c) && o.push({ from: l.from + h, insert: a + " " });
+    let i = e.changes(o);
+    return { changes: i, selection: e.selection.map(i, 1) };
+  } else if (t != 1 && n.some((o) => o.comment >= 0)) {
+    let o = [];
+    for (let { line: i, comment: l, token: a } of n)
+      if (l >= 0) {
+        let h = i.from + l, c = h + a.length;
+        i.text[c - i.from] == " " && c++, o.push({ from: h, to: c });
+      }
+    return { changes: o };
+  }
+  return null;
+}
+const ue = /* @__PURE__ */ Ze.define(), ks = /* @__PURE__ */ Ze.define(), Ss = /* @__PURE__ */ Ue.define(), Ke = /* @__PURE__ */ Ue.define({
+  combine(t) {
+    return Wt(t, {
+      minDepth: 100,
+      newGroupDelay: 500,
+      joinToEvent: (e, s) => s
+    }, {
+      minDepth: Math.max,
+      newGroupDelay: Math.min,
+      joinToEvent: (e, s) => (n, r) => e(n, r) || s(n, r)
+    });
+  }
+}), et = /* @__PURE__ */ Et.define({
+  create() {
+    return A.empty;
+  },
+  update(t, e) {
+    let s = e.state.facet(Ke), n = e.annotation(ue);
+    if (n) {
+      let a = y.fromTransaction(e, n.selection), h = n.side, c = h == 0 ? t.undone : t.done;
+      return a ? c = j(c, c.length, s.minDepth, a) : c = nt(c, e.startState.selection), new A(h == 0 ? n.rest : c, h == 0 ? c : n.rest);
+    }
+    let r = e.annotation(ks);
+    if ((r == "full" || r == "before") && (t = t.isolate()), e.annotation(ne.addToHistory) === !1)
+      return e.changes.empty ? t : t.addMapping(e.changes.desc);
+    let o = y.fromTransaction(e), i = e.annotation(ne.time), l = e.annotation(ne.userEvent);
+    return o ? t = t.addChanges(o, i, l, s, e) : e.selection && (t = t.addSelection(e.startState.selection, i, l, s.newGroupDelay)), (r == "full" || r == "after") && (t = t.isolate()), t;
+  },
+  toJSON(t) {
+    return { done: t.done.map((e) => e.toJSON()), undone: t.undone.map((e) => e.toJSON()) };
+  },
+  fromJSON(t) {
+    return new A(t.done.map(y.fromJSON), t.undone.map(y.fromJSON));
+  }
+});
+function ys(t = {}) {
+  return [
+    et,
+    Ke.of(t),
+    v.domEventHandlers({
+      beforeinput(e, s) {
+        let n = e.inputType == "historyUndo" ? tt : e.inputType == "historyRedo" ? fe : null;
+        return n ? (e.preventDefault(), n(s)) : !1;
+      }
+    })
+  ];
+}
+function H(t, e) {
+  return function({ state: s, dispatch: n }) {
+    if (!e && s.readOnly)
+      return !1;
+    let r = s.field(et, !1);
+    if (!r)
+      return !1;
+    let o = r.pop(t, s, e);
+    return o ? (n(o), !0) : !1;
+  };
+}
+const tt = /* @__PURE__ */ H(0, !1), fe = /* @__PURE__ */ H(1, !1), bs = /* @__PURE__ */ H(0, !0), Cs = /* @__PURE__ */ H(1, !0);
+class y {
+  constructor(e, s, n, r, o) {
+    this.changes = e, this.effects = s, this.mapped = n, this.startSelection = r, this.selectionsAfter = o;
+  }
+  setSelAfter(e) {
+    return new y(this.changes, this.effects, this.mapped, this.startSelection, e);
+  }
+  toJSON() {
+    var e, s, n;
+    return {
+      changes: (e = this.changes) === null || e === void 0 ? void 0 : e.toJSON(),
+      mapped: (s = this.mapped) === null || s === void 0 ? void 0 : s.toJSON(),
+      startSelection: (n = this.startSelection) === null || n === void 0 ? void 0 : n.toJSON(),
+      selectionsAfter: this.selectionsAfter.map((r) => r.toJSON())
+    };
+  }
+  static fromJSON(e) {
+    return new y(e.changes && It.fromJSON(e.changes), [], e.mapped && Lt.fromJSON(e.mapped), e.startSelection && O.fromJSON(e.startSelection), e.selectionsAfter.map(O.fromJSON));
+  }
+  // This does not check `addToHistory` and such, it assumes the
+  // transaction needs to be converted to an item. Returns null when
+  // there are no changes or effects in the transaction.
+  static fromTransaction(e, s) {
+    let n = C;
+    for (let r of e.startState.facet(Ss)) {
+      let o = r(e);
+      o.length && (n = n.concat(o));
+    }
+    return !n.length && e.changes.empty ? null : new y(e.changes.invert(e.startState.doc), n, void 0, s || e.startState.selection, C);
+  }
+  static selection(e) {
+    return new y(void 0, C, void 0, void 0, e);
+  }
+}
+function j(t, e, s, n) {
+  let r = e + 1 > s + 20 ? e - s - 1 : 0, o = t.slice(r, e);
+  return o.push(n), o;
+}
+function Ts(t, e) {
+  let s = [], n = !1;
+  return t.iterChangedRanges((r, o) => s.push(r, o)), e.iterChangedRanges((r, o, i, l) => {
+    for (let a = 0; a < s.length; ) {
+      let h = s[a++], c = s[a++];
+      l >= h && i <= c && (n = !0);
+    }
+  }), n;
+}
+function vs(t, e) {
+  return t.ranges.length == e.ranges.length && t.ranges.filter((s, n) => s.empty != e.ranges[n].empty).length === 0;
+}
+function st(t, e) {
+  return t.length ? e.length ? t.concat(e) : t : e;
+}
+const C = [], Ps = 200;
+function nt(t, e) {
+  if (t.length) {
+    let s = t[t.length - 1], n = s.selectionsAfter.slice(Math.max(0, s.selectionsAfter.length - Ps));
+    return n.length && n[n.length - 1].eq(e) ? t : (n.push(e), j(t, t.length - 1, 1e9, s.setSelAfter(n)));
+  } else
+    return [y.selection([e])];
+}
+function $s(t) {
+  let e = t[t.length - 1], s = t.slice();
+  return s[t.length - 1] = e.setSelAfter(e.selectionsAfter.slice(0, e.selectionsAfter.length - 1)), s;
+}
+function re(t, e) {
+  if (!t.length)
+    return t;
+  let s = t.length, n = C;
+  for (; s; ) {
+    let r = As(t[s - 1], e, n);
+    if (r.changes && !r.changes.empty || r.effects.length) {
+      let o = t.slice(0, s);
+      return o[s - 1] = r, o;
+    } else
+      e = r.mapped, s--, n = r.selectionsAfter;
+  }
+  return n.length ? [y.selection(n)] : C;
+}
+function As(t, e, s) {
+  let n = st(t.selectionsAfter.length ? t.selectionsAfter.map((l) => l.map(e)) : C, s);
+  if (!t.changes)
+    return y.selection(n);
+  let r = t.changes.map(e), o = e.mapDesc(t.changes, !0), i = t.mapped ? t.mapped.composeDesc(o) : o;
+  return new y(r, Je.mapEffects(t.effects, e), i, t.startSelection.map(o), n);
+}
+const qs = /^(input\.type|delete)($|\.)/;
+class A {
+  constructor(e, s, n = 0, r = void 0) {
+    this.done = e, this.undone = s, this.prevTime = n, this.prevUserEvent = r;
+  }
+  isolate() {
+    return this.prevTime ? new A(this.done, this.undone) : this;
+  }
+  addChanges(e, s, n, r, o) {
+    let i = this.done, l = i[i.length - 1];
+    return l && l.changes && !l.changes.empty && e.changes && (!n || qs.test(n)) && (!l.selectionsAfter.length && s - this.prevTime < r.newGroupDelay && r.joinToEvent(o, Ts(l.changes, e.changes)) || // For compose (but not compose.start) events, always join with previous event
+    n == "input.type.compose") ? i = j(i, i.length - 1, r.minDepth, new y(e.changes.compose(l.changes), st(Je.mapEffects(e.effects, l.changes), l.effects), l.mapped, l.startSelection, C)) : i = j(i, i.length, r.minDepth, e), new A(i, C, s, n);
+  }
+  addSelection(e, s, n, r) {
+    let o = this.done.length ? this.done[this.done.length - 1].selectionsAfter : C;
+    return o.length > 0 && s - this.prevTime < r && n == this.prevUserEvent && n && /^select($|\.)/.test(n) && vs(o[o.length - 1], e) ? this : new A(nt(this.done, e), this.undone, s, n);
+  }
+  addMapping(e) {
+    return new A(re(this.done, e), re(this.undone, e), this.prevTime, this.prevUserEvent);
+  }
+  pop(e, s, n) {
+    let r = e == 0 ? this.done : this.undone;
+    if (r.length == 0)
+      return null;
+    let o = r[r.length - 1], i = o.selectionsAfter[0] || s.selection;
+    if (n && o.selectionsAfter.length)
+      return s.update({
+        selection: o.selectionsAfter[o.selectionsAfter.length - 1],
+        annotations: ue.of({ side: e, rest: $s(r), selection: i }),
+        userEvent: e == 0 ? "select.undo" : "select.redo",
+        scrollIntoView: !0
+      });
+    if (o.changes) {
+      let l = r.length == 1 ? C : r.slice(0, r.length - 1);
+      return o.mapped && (l = re(l, o.mapped)), s.update({
+        changes: o.changes,
+        selection: o.startSelection,
+        effects: o.effects,
+        annotations: ue.of({ side: e, rest: l, selection: i }),
+        filter: !1,
+        userEvent: e == 0 ? "undo" : "redo",
+        scrollIntoView: !0
+      });
+    } else
+      return null;
+  }
+}
+A.empty = /* @__PURE__ */ new A(C, C);
+const ws = [
+  { key: "Mod-z", run: tt, preventDefault: !0 },
+  { key: "Mod-y", mac: "Mod-Shift-z", run: fe, preventDefault: !0 },
+  { linux: "Ctrl-Shift-z", run: fe, preventDefault: !0 },
+  { key: "Mod-u", run: bs, preventDefault: !0 },
+  { key: "Alt-u", mac: "Mod-Shift-u", run: Cs, preventDefault: !0 }
+];
+function W(t, e) {
+  return O.create(t.ranges.map(e), t.mainIndex);
+}
+function q(t, e) {
+  return t.update({ selection: e, scrollIntoView: !0, userEvent: "select" });
+}
+function P({ state: t, dispatch: e }, s) {
+  let n = W(t.selection, s);
+  return n.eq(t.selection, !0) ? !1 : (e(q(t, n)), !0);
+}
+function K(t, e) {
+  return O.cursor(e ? t.to : t.from);
+}
+function rt(t, e) {
+  return P(t, (s) => s.empty ? t.moveByChar(s, e) : K(s, e));
+}
+function k(t) {
+  return t.textDirectionAt(t.state.selection.main.head) == Mt.LTR;
+}
+const ot = (t) => rt(t, !k(t)), it = (t) => rt(t, k(t));
+function lt(t, e) {
+  return P(t, (s) => s.empty ? t.moveByGroup(s, e) : K(s, e));
+}
+const Bs = (t) => lt(t, !k(t)), Ds = (t) => lt(t, k(t));
+function Rs(t, e, s) {
+  if (e.type.prop(s))
+    return !0;
+  let n = e.to - e.from;
+  return n && (n > 2 || /[^\s,.;:]/.test(t.sliceDoc(e.from, e.to))) || e.firstChild;
+}
+function ee(t, e, s) {
+  let n = M(t).resolveInner(e.head), r = s ? E.closedBy : E.openedBy;
+  for (let a = e.head; ; ) {
+    let h = s ? n.childAfter(a) : n.childBefore(a);
+    if (!h)
+      break;
+    Rs(t, h, r) ? n = h : a = s ? h.to : h.from;
+  }
+  let o = n.type.prop(r), i, l;
+  return o && (i = s ? R(t, n.from, 1) : R(t, n.to, -1)) && i.matched ? l = s ? i.end.to : i.end.from : l = s ? n.to : n.from, O.cursor(l, s ? -1 : 1);
+}
+const Ns = (t) => P(t, (e) => ee(t.state, e, !k(t))), Es = (t) => P(t, (e) => ee(t.state, e, k(t)));
+function at(t, e) {
+  return P(t, (s) => {
+    if (!s.empty)
+      return K(s, e);
+    let n = t.moveVertically(s, e);
+    return n.head != s.head ? n : t.moveToLineBoundary(s, e);
+  });
+}
+const ht = (t) => at(t, !1), ct = (t) => at(t, !0);
+function ut(t) {
+  let e = t.scrollDOM.clientHeight < t.scrollDOM.scrollHeight - 2, s = 0, n = 0, r;
+  if (e) {
+    for (let o of t.state.facet(v.scrollMargins)) {
+      let i = o(t);
+      i != null && i.top && (s = Math.max(i == null ? void 0 : i.top, s)), i != null && i.bottom && (n = Math.max(i == null ? void 0 : i.bottom, n));
+    }
+    r = t.scrollDOM.clientHeight - s - n;
+  } else
+    r = (t.dom.ownerDocument.defaultView || window).innerHeight;
+  return {
+    marginTop: s,
+    marginBottom: n,
+    selfScroll: e,
+    height: Math.max(t.defaultLineHeight, r - 5)
+  };
+}
+function ft(t, e) {
+  let s = ut(t), { state: n } = t, r = W(n.selection, (i) => i.empty ? t.moveVertically(i, e, s.height) : K(i, e));
+  if (r.eq(n.selection))
+    return !1;
+  let o;
+  if (s.selfScroll) {
+    let i = t.coordsAtPos(n.selection.main.head), l = t.scrollDOM.getBoundingClientRect(), a = l.top + s.marginTop, h = l.bottom - s.marginBottom;
+    i && i.top > a && i.bottom < h && (o = v.scrollIntoView(r.main.head, { y: "start", yMargin: i.top - a }));
+  }
+  return t.dispatch(q(n, r), { effects: o }), !0;
+}
+const Pe = (t) => ft(t, !1), de = (t) => ft(t, !0);
+function D(t, e, s) {
+  let n = t.lineBlockAt(e.head), r = t.moveToLineBoundary(e, s);
+  if (r.head == e.head && r.head != (s ? n.to : n.from) && (r = t.moveToLineBoundary(e, s, !1)), !s && r.head == n.from && n.length) {
+    let o = /^\s*/.exec(t.state.sliceDoc(n.from, Math.min(n.from + 100, n.to)))[0].length;
+    o && e.head != n.from + o && (r = O.cursor(n.from + o));
+  }
+  return r;
+}
+const Ws = (t) => P(t, (e) => D(t, e, !0)), Is = (t) => P(t, (e) => D(t, e, !1)), Ls = (t) => P(t, (e) => D(t, e, !k(t))), Ms = (t) => P(t, (e) => D(t, e, k(t))), zs = (t) => P(t, (e) => O.cursor(t.lineBlockAt(e.head).from, 1)), Vs = (t) => P(t, (e) => O.cursor(t.lineBlockAt(e.head).to, -1));
+function Gs(t, e, s) {
+  let n = !1, r = W(t.selection, (o) => {
+    let i = R(t, o.head, -1) || R(t, o.head, 1) || o.head > 0 && R(t, o.head - 1, 1) || o.head < t.doc.length && R(t, o.head + 1, -1);
+    if (!i || !i.end)
+      return o;
+    n = !0;
+    let l = i.start.from == o.head ? i.end.to : i.end.from;
+    return O.cursor(l);
+  });
+  return n ? (e(q(t, r)), !0) : !1;
+}
+const Qs = ({ state: t, dispatch: e }) => Gs(t, e);
+function T(t, e) {
+  let s = W(t.state.selection, (n) => {
+    let r = e(n);
+    return O.range(n.anchor, r.head, r.goalColumn, r.bidiLevel || void 0);
+  });
+  return s.eq(t.state.selection) ? !1 : (t.dispatch(q(t.state, s)), !0);
+}
+function dt(t, e) {
+  return T(t, (s) => t.moveByChar(s, e));
+}
+const pt = (t) => dt(t, !k(t)), mt = (t) => dt(t, k(t));
+function Ot(t, e) {
+  return T(t, (s) => t.moveByGroup(s, e));
+}
+const Xs = (t) => Ot(t, !k(t)), _s = (t) => Ot(t, k(t)), Us = (t) => T(t, (e) => ee(t.state, e, !k(t))), Fs = (t) => T(t, (e) => ee(t.state, e, k(t)));
+function gt(t, e) {
+  return T(t, (s) => t.moveVertically(s, e));
+}
+const xt = (t) => gt(t, !1), kt = (t) => gt(t, !0);
+function St(t, e) {
+  return T(t, (s) => t.moveVertically(s, e, ut(t).height));
+}
+const $e = (t) => St(t, !1), Ae = (t) => St(t, !0), js = (t) => T(t, (e) => D(t, e, !0)), Ys = (t) => T(t, (e) => D(t, e, !1)), Zs = (t) => T(t, (e) => D(t, e, !k(t))), Js = (t) => T(t, (e) => D(t, e, k(t))), Hs = (t) => T(t, (e) => O.cursor(t.lineBlockAt(e.head).from)), Ks = (t) => T(t, (e) => O.cursor(t.lineBlockAt(e.head).to)), qe = ({ state: t, dispatch: e }) => (e(q(t, { anchor: 0 })), !0), we = ({ state: t, dispatch: e }) => (e(q(t, { anchor: t.doc.length })), !0), Be = ({ state: t, dispatch: e }) => (e(q(t, { anchor: t.selection.main.anchor, head: 0 })), !0), De = ({ state: t, dispatch: e }) => (e(q(t, { anchor: t.selection.main.anchor, head: t.doc.length })), !0), en = ({ state: t, dispatch: e }) => (e(t.update({ selection: { anchor: 0, head: t.doc.length }, userEvent: "select" })), !0), tn = ({ state: t, dispatch: e }) => {
+  let s = te(t).map(({ from: n, to: r }) => O.range(n, Math.min(r + 1, t.doc.length)));
+  return e(t.update({ selection: O.create(s), userEvent: "select" })), !0;
+}, sn = ({ state: t, dispatch: e }) => {
+  let s = W(t.selection, (n) => {
+    let r = M(t), o = r.resolveStack(n.from, 1);
+    if (n.empty) {
+      let i = r.resolveStack(n.from, -1);
+      i.node.from >= o.node.from && i.node.to <= o.node.to && (o = i);
+    }
+    for (let i = o; i; i = i.next) {
+      let { node: l } = i;
+      if ((l.from < n.from && l.to >= n.to || l.to > n.to && l.from <= n.from) && i.next)
+        return O.range(l.to, l.from);
+    }
+    return n;
+  });
+  return s.eq(t.selection) ? !1 : (e(q(t, s)), !0);
+}, nn = ({ state: t, dispatch: e }) => {
+  let s = t.selection, n = null;
+  return s.ranges.length > 1 ? n = O.create([s.main]) : s.main.empty || (n = O.create([O.cursor(s.main.head)])), n ? (e(q(t, n)), !0) : !1;
+};
+function z(t, e) {
+  if (t.state.readOnly)
+    return !1;
+  let s = "delete.selection", { state: n } = t, r = n.changeByRange((o) => {
+    let { from: i, to: l } = o;
+    if (i == l) {
+      let a = e(o);
+      a < i ? (s = "delete.backward", a = G(t, a, !1)) : a > i && (s = "delete.forward", a = G(t, a, !0)), i = Math.min(i, a), l = Math.max(l, a);
+    } else
+      i = G(t, i, !1), l = G(t, l, !0);
+    return i == l ? { range: o } : { changes: { from: i, to: l }, range: O.cursor(i, i < o.head ? -1 : 1) };
+  });
+  return r.changes.empty ? !1 : (t.dispatch(n.update(r, {
+    scrollIntoView: !0,
+    userEvent: s,
+    effects: s == "delete.selection" ? v.announce.of(n.phrase("Selection deleted")) : void 0
+  })), !0);
+}
+function G(t, e, s) {
+  if (t instanceof v)
+    for (let n of t.state.facet(v.atomicRanges).map((r) => r(t)))
+      n.between(e, e, (r, o) => {
+        r < e && o > e && (e = s ? o : r);
+      });
+  return e;
+}
+const yt = (t, e, s) => z(t, (n) => {
+  let r = n.from, { state: o } = t, i = o.doc.lineAt(r), l, a;
+  if (s && !e && r > i.from && r < i.from + 200 && !/[^ \t]/.test(l = i.text.slice(0, r - i.from))) {
+    if (l[l.length - 1] == "	")
+      return r - 1;
+    let h = ke(l, o.tabSize), c = h % ce(o) || ce(o);
+    for (let u = 0; u < c && l[l.length - 1 - u] == " "; u++)
+      r--;
+    a = r;
+  } else
+    a = L(i.text, r - i.from, e, e) + i.from, a == r && i.number != (e ? o.doc.lines : 1) ? a += e ? 1 : -1 : !e && /[\ufe00-\ufe0f]/.test(i.text.slice(a - i.from, r - i.from)) && (a = L(i.text, a - i.from, !1, !1) + i.from);
+  return a;
+}), pe = (t) => yt(t, !1, !0), bt = (t) => yt(t, !0, !1), Ct = (t, e) => z(t, (s) => {
+  let n = s.head, { state: r } = t, o = r.doc.lineAt(n), i = r.charCategorizer(n);
+  for (let l = null; ; ) {
+    if (n == (e ? o.to : o.from)) {
+      n == s.head && o.number != (e ? r.doc.lines : 1) && (n += e ? 1 : -1);
+      break;
+    }
+    let a = L(o.text, n - o.from, e) + o.from, h = o.text.slice(Math.min(n, a) - o.from, Math.max(n, a) - o.from), c = i(h);
+    if (l != null && c != l)
+      break;
+    (h != " " || n != s.head) && (l = c), n = a;
+  }
+  return n;
+}), Tt = (t) => Ct(t, !1), rn = (t) => Ct(t, !0), on = (t) => z(t, (e) => {
+  let s = t.lineBlockAt(e.head).to;
+  return e.head < s ? s : Math.min(t.state.doc.length, e.head + 1);
+}), ln = (t) => z(t, (e) => {
+  let s = t.moveToLineBoundary(e, !1).head;
+  return e.head > s ? s : Math.max(0, e.head - 1);
+}), an = (t) => z(t, (e) => {
+  let s = t.moveToLineBoundary(e, !0).head;
+  return e.head < s ? s : Math.min(t.state.doc.length, e.head + 1);
+}), hn = ({ state: t, dispatch: e }) => {
+  if (t.readOnly)
+    return !1;
+  let s = t.changeByRange((n) => ({
+    changes: { from: n.from, to: n.to, insert: Ye.of(["", ""]) },
+    range: O.cursor(n.from)
+  }));
+  return e(t.update(s, { scrollIntoView: !0, userEvent: "input" })), !0;
+}, cn = ({ state: t, dispatch: e }) => {
+  if (t.readOnly)
+    return !1;
+  let s = t.changeByRange((n) => {
+    if (!n.empty || n.from == 0 || n.from == t.doc.length)
+      return { range: n };
+    let r = n.from, o = t.doc.lineAt(r), i = r == o.from ? r - 1 : L(o.text, r - o.from, !1) + o.from, l = r == o.to ? r + 1 : L(o.text, r - o.from, !0) + o.from;
+    return {
+      changes: { from: i, to: l, insert: t.doc.slice(r, l).append(t.doc.slice(i, r)) },
+      range: O.cursor(l)
+    };
+  });
+  return s.changes.empty ? !1 : (e(t.update(s, { scrollIntoView: !0, userEvent: "move.character" })), !0);
+};
+function te(t) {
+  let e = [], s = -1;
+  for (let n of t.selection.ranges) {
+    let r = t.doc.lineAt(n.from), o = t.doc.lineAt(n.to);
+    if (!n.empty && n.to == o.from && (o = t.doc.lineAt(n.to - 1)), s >= r.number) {
+      let i = e[e.length - 1];
+      i.to = o.to, i.ranges.push(n);
+    } else
+      e.push({ from: r.from, to: o.to, ranges: [n] });
+    s = o.number + 1;
+  }
+  return e;
+}
+function vt(t, e, s) {
+  if (t.readOnly)
+    return !1;
+  let n = [], r = [];
+  for (let o of te(t)) {
+    if (s ? o.to == t.doc.length : o.from == 0)
+      continue;
+    let i = t.doc.lineAt(s ? o.to + 1 : o.from - 1), l = i.length + 1;
+    if (s) {
+      n.push({ from: o.to, to: i.to }, { from: o.from, insert: i.text + t.lineBreak });
+      for (let a of o.ranges)
+        r.push(O.range(Math.min(t.doc.length, a.anchor + l), Math.min(t.doc.length, a.head + l)));
+    } else {
+      n.push({ from: i.from, to: o.from }, { from: o.to, insert: t.lineBreak + i.text });
+      for (let a of o.ranges)
+        r.push(O.range(a.anchor - l, a.head - l));
+    }
+  }
+  return n.length ? (e(t.update({
+    changes: n,
+    scrollIntoView: !0,
+    selection: O.create(r, t.selection.mainIndex),
+    userEvent: "move.line"
+  })), !0) : !1;
+}
+const un = ({ state: t, dispatch: e }) => vt(t, e, !1), fn = ({ state: t, dispatch: e }) => vt(t, e, !0);
+function Pt(t, e, s) {
+  if (t.readOnly)
+    return !1;
+  let n = [];
+  for (let r of te(t))
+    s ? n.push({ from: r.from, insert: t.doc.slice(r.from, r.to) + t.lineBreak }) : n.push({ from: r.to, insert: t.lineBreak + t.doc.slice(r.from, r.to) });
+  return e(t.update({ changes: n, scrollIntoView: !0, userEvent: "input.copyline" })), !0;
+}
+const dn = ({ state: t, dispatch: e }) => Pt(t, e, !1), pn = ({ state: t, dispatch: e }) => Pt(t, e, !0), mn = (t) => {
+  if (t.state.readOnly)
+    return !1;
+  let { state: e } = t, s = e.changes(te(e).map(({ from: r, to: o }) => (r > 0 ? r-- : o < e.doc.length && o++, { from: r, to: o }))), n = W(e.selection, (r) => {
+    let o;
+    if (t.lineWrapping) {
+      let i = t.lineBlockAt(r.head), l = t.coordsAtPos(r.head, r.assoc || 1);
+      l && (o = i.bottom + t.documentTop - l.bottom + t.defaultLineHeight / 2);
+    }
+    return t.moveVertically(r, !0, o);
+  }).map(s);
+  return t.dispatch({ changes: s, selection: n, scrollIntoView: !0, userEvent: "delete.line" }), !0;
+};
+function On(t, e) {
+  if (/\(\)|\[\]|\{\}/.test(t.sliceDoc(e - 1, e + 1)))
+    return { from: e, to: e };
+  let s = M(t).resolveInner(e), n = s.childBefore(e), r = s.childAfter(e), o;
+  return n && r && n.to <= e && r.from >= e && (o = n.type.prop(E.closedBy)) && o.indexOf(r.name) > -1 && t.doc.lineAt(n.to).from == t.doc.lineAt(r.from).from && !/\S/.test(t.sliceDoc(n.to, r.from)) ? { from: n.to, to: r.from } : null;
+}
+const me = /* @__PURE__ */ $t(!1), gn = /* @__PURE__ */ $t(!0);
+function $t(t) {
+  return ({ state: e, dispatch: s }) => {
+    if (e.readOnly)
+      return !1;
+    let n = e.changeByRange((r) => {
+      let { from: o, to: i } = r, l = e.doc.lineAt(o), a = !t && o == i && On(e, o);
+      t && (o = i = (i <= l.to ? l : e.doc.lineAt(i)).to);
+      let h = new Fe(e, { simulateBreak: o, simulateDoubleBreak: !!a }), c = je(h, o);
+      for (c == null && (c = ke(/^\s*/.exec(e.doc.lineAt(o).text)[0], e.tabSize)); i < l.to && /\s/.test(l.text[i - l.from]); )
+        i++;
+      a ? { from: o, to: i } = a : o > l.from && o < l.from + 100 && !/\S/.test(l.text.slice(0, o)) && (o = l.from);
+      let u = ["", F(e, c)];
+      return a && u.push(F(e, h.lineIndent(l.from, -1))), {
+        changes: { from: o, to: i, insert: Ye.of(u) },
+        range: O.cursor(o + 1 + u[1].length)
+      };
+    });
+    return s(e.update(n, { scrollIntoView: !0, userEvent: "input" })), !0;
+  };
+}
+function be(t, e) {
+  let s = -1;
+  return t.changeByRange((n) => {
+    let r = [];
+    for (let i = n.from; i <= n.to; ) {
+      let l = t.doc.lineAt(i);
+      l.number > s && (n.empty || n.to > l.from) && (e(l, r, n), s = l.number), i = l.to + 1;
+    }
+    let o = t.changes(r);
+    return {
+      changes: r,
+      range: O.range(o.mapPos(n.anchor, 1), o.mapPos(n.head, 1))
+    };
+  });
+}
+const xn = ({ state: t, dispatch: e }) => {
+  if (t.readOnly)
+    return !1;
+  let s = /* @__PURE__ */ Object.create(null), n = new Fe(t, { overrideIndentation: (o) => {
+    let i = s[o];
+    return i ?? -1;
+  } }), r = be(t, (o, i, l) => {
+    let a = je(n, o.from);
+    if (a == null)
+      return;
+    /\S/.test(o.text) || (a = 0);
+    let h = /^\s*/.exec(o.text)[0], c = F(t, a);
+    (h != c || l.from < o.from + h.length) && (s[o.from] = a, i.push({ from: o.from, to: o.from + h.length, insert: c }));
+  });
+  return r.changes.empty || e(t.update(r, { userEvent: "indent" })), !0;
+}, At = ({ state: t, dispatch: e }) => t.readOnly ? !1 : (e(t.update(be(t, (s, n) => {
+  n.push({ from: s.from, insert: t.facet(zt) });
+}), { userEvent: "input.indent" })), !0), qt = ({ state: t, dispatch: e }) => t.readOnly ? !1 : (e(t.update(be(t, (s, n) => {
+  let r = /^\s*/.exec(s.text)[0];
+  if (!r)
+    return;
+  let o = ke(r, t.tabSize), i = 0, l = F(t, Math.max(0, o - ce(t)));
+  for (; i < r.length && i < l.length && r.charCodeAt(i) == l.charCodeAt(i); )
+    i++;
+  n.push({ from: s.from + i, to: s.from + r.length, insert: l.slice(i) });
+}), { userEvent: "delete.dedent" })), !0), kn = (t) => (t.setTabFocusMode(), !0), Sn = [
+  { key: "Ctrl-b", run: ot, shift: pt, preventDefault: !0 },
+  { key: "Ctrl-f", run: it, shift: mt },
+  { key: "Ctrl-p", run: ht, shift: xt },
+  { key: "Ctrl-n", run: ct, shift: kt },
+  { key: "Ctrl-a", run: zs, shift: Hs },
+  { key: "Ctrl-e", run: Vs, shift: Ks },
+  { key: "Ctrl-d", run: bt },
+  { key: "Ctrl-h", run: pe },
+  { key: "Ctrl-k", run: on },
+  { key: "Ctrl-Alt-h", run: Tt },
+  { key: "Ctrl-o", run: hn },
+  { key: "Ctrl-t", run: cn },
+  { key: "Ctrl-v", run: de }
+], yn = /* @__PURE__ */ [
+  { key: "ArrowLeft", run: ot, shift: pt, preventDefault: !0 },
+  { key: "Mod-ArrowLeft", mac: "Alt-ArrowLeft", run: Bs, shift: Xs, preventDefault: !0 },
+  { mac: "Cmd-ArrowLeft", run: Ls, shift: Zs, preventDefault: !0 },
+  { key: "ArrowRight", run: it, shift: mt, preventDefault: !0 },
+  { key: "Mod-ArrowRight", mac: "Alt-ArrowRight", run: Ds, shift: _s, preventDefault: !0 },
+  { mac: "Cmd-ArrowRight", run: Ms, shift: Js, preventDefault: !0 },
+  { key: "ArrowUp", run: ht, shift: xt, preventDefault: !0 },
+  { mac: "Cmd-ArrowUp", run: qe, shift: Be },
+  { mac: "Ctrl-ArrowUp", run: Pe, shift: $e },
+  { key: "ArrowDown", run: ct, shift: kt, preventDefault: !0 },
+  { mac: "Cmd-ArrowDown", run: we, shift: De },
+  { mac: "Ctrl-ArrowDown", run: de, shift: Ae },
+  { key: "PageUp", run: Pe, shift: $e },
+  { key: "PageDown", run: de, shift: Ae },
+  { key: "Home", run: Is, shift: Ys, preventDefault: !0 },
+  { key: "Mod-Home", run: qe, shift: Be },
+  { key: "End", run: Ws, shift: js, preventDefault: !0 },
+  { key: "Mod-End", run: we, shift: De },
+  { key: "Enter", run: me, shift: me },
+  { key: "Mod-a", run: en },
+  { key: "Backspace", run: pe, shift: pe },
+  { key: "Delete", run: bt },
+  { key: "Mod-Backspace", mac: "Alt-Backspace", run: Tt },
+  { key: "Mod-Delete", mac: "Alt-Delete", run: rn },
+  { mac: "Mod-Backspace", run: ln },
+  { mac: "Mod-Delete", run: an }
+].concat(/* @__PURE__ */ Sn.map((t) => ({ mac: t.key, run: t.run, shift: t.shift }))), bn = /* @__PURE__ */ [
+  { key: "Alt-ArrowLeft", mac: "Ctrl-ArrowLeft", run: Ns, shift: Us },
+  { key: "Alt-ArrowRight", mac: "Ctrl-ArrowRight", run: Es, shift: Fs },
+  { key: "Alt-ArrowUp", run: un },
+  { key: "Shift-Alt-ArrowUp", run: dn },
+  { key: "Alt-ArrowDown", run: fn },
+  { key: "Shift-Alt-ArrowDown", run: pn },
+  { key: "Escape", run: nn },
+  { key: "Mod-Enter", run: gn },
+  { key: "Alt-l", mac: "Ctrl-l", run: tn },
+  { key: "Mod-i", run: sn, preventDefault: !0 },
+  { key: "Mod-[", run: qt },
+  { key: "Mod-]", run: At },
+  { key: "Mod-Alt-\\", run: xn },
+  { key: "Shift-Mod-k", run: mn },
+  { key: "Shift-Mod-\\", run: Qs },
+  { key: "Mod-/", run: fs },
+  { key: "Alt-A", run: ps },
+  { key: "Ctrl-m", mac: "Shift-Alt-m", run: kn }
+].concat(yn), Cn = { key: "Tab", run: At, shift: qt };
+class Y {
+  /**
+  @internal
+  */
+  constructor(e, s, n, r, o, i, l, a, h, c = 0, u) {
+    this.p = e, this.stack = s, this.state = n, this.reducePos = r, this.pos = o, this.score = i, this.buffer = l, this.bufferBase = a, this.curContext = h, this.lookAhead = c, this.parent = u;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return `[${this.stack.filter((e, s) => s % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? "!" + this.score : ""}`;
+  }
+  // Start an empty stack
+  /**
+  @internal
+  */
+  static start(e, s, n = 0) {
+    let r = e.parser.context;
+    return new Y(e, [], s, n, n, 0, [], 0, r ? new Re(r, r.start) : null, 0, null);
+  }
+  /**
+  The stack's current [context](#lr.ContextTracker) value, if
+  any. Its type will depend on the context tracker's type
+  parameter, or it will be `null` if there is no context
+  tracker.
+  */
+  get context() {
+    return this.curContext ? this.curContext.context : null;
+  }
+  // Push a state onto the stack, tracking its start position as well
+  // as the buffer base at that point.
+  /**
+  @internal
+  */
+  pushState(e, s) {
+    this.stack.push(this.state, s, this.bufferBase + this.buffer.length), this.state = e;
+  }
+  // Apply a reduce action
+  /**
+  @internal
+  */
+  reduce(e) {
+    var s;
+    let n = e >> 19, r = e & 65535, { parser: o } = this.p, i = this.reducePos < this.pos - 25;
+    i && this.setLookAhead(this.pos);
+    let l = o.dynamicPrecedence(r);
+    if (l && (this.score += l), n == 0) {
+      this.pushState(o.getGoto(this.state, r, !0), this.reducePos), r < o.minRepeatTerm && this.storeNode(r, this.reducePos, this.reducePos, i ? 8 : 4, !0), this.reduceContext(r, this.reducePos);
+      return;
+    }
+    let a = this.stack.length - (n - 1) * 3 - (e & 262144 ? 6 : 0), h = a ? this.stack[a - 2] : this.p.ranges[0].from, c = this.reducePos - h;
+    c >= 2e3 && !(!((s = this.p.parser.nodeSet.types[r]) === null || s === void 0) && s.isAnonymous) && (h == this.p.lastBigReductionStart ? (this.p.bigReductionCount++, this.p.lastBigReductionSize = c) : this.p.lastBigReductionSize < c && (this.p.bigReductionCount = 1, this.p.lastBigReductionStart = h, this.p.lastBigReductionSize = c));
+    let u = a ? this.stack[a - 1] : 0, f = this.bufferBase + this.buffer.length - u;
+    if (r < o.minRepeatTerm || e & 131072) {
+      let d = o.stateFlag(
+        this.state,
+        1
+        /* StateFlag.Skipped */
+      ) ? this.pos : this.reducePos;
+      this.storeNode(r, h, d, f + 4, !0);
+    }
+    if (e & 262144)
+      this.state = this.stack[a];
+    else {
+      let d = this.stack[a - 3];
+      this.state = o.getGoto(d, r, !0);
+    }
+    for (; this.stack.length > a; )
+      this.stack.pop();
+    this.reduceContext(r, h);
+  }
+  // Shift a value into the buffer
+  /**
+  @internal
+  */
+  storeNode(e, s, n, r = 4, o = !1) {
+    if (e == 0 && (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
+      let i = this, l = this.buffer.length;
+      if (l == 0 && i.parent && (l = i.bufferBase - i.parent.bufferBase, i = i.parent), l > 0 && i.buffer[l - 4] == 0 && i.buffer[l - 1] > -1) {
+        if (s == n)
+          return;
+        if (i.buffer[l - 2] >= s) {
+          i.buffer[l - 2] = n;
+          return;
+        }
+      }
+    }
+    if (!o || this.pos == n)
+      this.buffer.push(e, s, n, r);
+    else {
+      let i = this.buffer.length;
+      if (i > 0 && this.buffer[i - 4] != 0) {
+        let l = !1;
+        for (let a = i; a > 0 && this.buffer[a - 2] > n; a -= 4)
+          if (this.buffer[a - 1] >= 0) {
+            l = !0;
+            break;
+          }
+        if (l)
+          for (; i > 0 && this.buffer[i - 2] > n; )
+            this.buffer[i] = this.buffer[i - 4], this.buffer[i + 1] = this.buffer[i - 3], this.buffer[i + 2] = this.buffer[i - 2], this.buffer[i + 3] = this.buffer[i - 1], i -= 4, r > 4 && (r -= 4);
+      }
+      this.buffer[i] = e, this.buffer[i + 1] = s, this.buffer[i + 2] = n, this.buffer[i + 3] = r;
+    }
+  }
+  // Apply a shift action
+  /**
+  @internal
+  */
+  shift(e, s, n, r) {
+    if (e & 131072)
+      this.pushState(e & 65535, this.pos);
+    else if ((e & 262144) == 0) {
+      let o = e, { parser: i } = this.p;
+      (r > this.pos || s <= i.maxNode) && (this.pos = r, i.stateFlag(
+        o,
+        1
+        /* StateFlag.Skipped */
+      ) || (this.reducePos = r)), this.pushState(o, n), this.shiftContext(s, n), s <= i.maxNode && this.buffer.push(s, n, r, 4);
+    } else
+      this.pos = r, this.shiftContext(s, n), s <= this.p.parser.maxNode && this.buffer.push(s, n, r, 4);
+  }
+  // Apply an action
+  /**
+  @internal
+  */
+  apply(e, s, n, r) {
+    e & 65536 ? this.reduce(e) : this.shift(e, s, n, r);
+  }
+  // Add a prebuilt (reused) node into the buffer.
+  /**
+  @internal
+  */
+  useNode(e, s) {
+    let n = this.p.reused.length - 1;
+    (n < 0 || this.p.reused[n] != e) && (this.p.reused.push(e), n++);
+    let r = this.pos;
+    this.reducePos = this.pos = r + e.length, this.pushState(s, r), this.buffer.push(
+      n,
+      r,
+      this.reducePos,
+      -1
+      /* size == -1 means this is a reused value */
+    ), this.curContext && this.updateContext(this.curContext.tracker.reuse(this.curContext.context, e, this, this.p.stream.reset(this.pos - e.length)));
+  }
+  // Split the stack. Due to the buffer sharing and the fact
+  // that `this.stack` tends to stay quite shallow, this isn't very
+  // expensive.
+  /**
+  @internal
+  */
+  split() {
+    let e = this, s = e.buffer.length;
+    for (; s > 0 && e.buffer[s - 2] > e.reducePos; )
+      s -= 4;
+    let n = e.buffer.slice(s), r = e.bufferBase + s;
+    for (; e && r == e.bufferBase; )
+      e = e.parent;
+    return new Y(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, n, r, this.curContext, this.lookAhead, e);
+  }
+  // Try to recover from an error by 'deleting' (ignoring) one token.
+  /**
+  @internal
+  */
+  recoverByDelete(e, s) {
+    let n = e <= this.p.parser.maxNode;
+    n && this.storeNode(e, this.pos, s, 4), this.storeNode(0, this.pos, s, n ? 8 : 4), this.pos = this.reducePos = s, this.score -= 190;
+  }
+  /**
+  Check if the given term would be able to be shifted (optionally
+  after some reductions) on this stack. This can be useful for
+  external tokenizers that want to make sure they only provide a
+  given token when it applies.
+  */
+  canShift(e) {
+    for (let s = new Tn(this); ; ) {
+      let n = this.p.parser.stateSlot(
+        s.state,
+        4
+        /* ParseState.DefaultReduce */
+      ) || this.p.parser.hasAction(s.state, e);
+      if (n == 0)
+        return !1;
+      if ((n & 65536) == 0)
+        return !0;
+      s.reduce(n);
+    }
+  }
+  // Apply up to Recover.MaxNext recovery actions that conceptually
+  // inserts some missing token or rule.
+  /**
+  @internal
+  */
+  recoverByInsert(e) {
+    if (this.stack.length >= 300)
+      return [];
+    let s = this.p.parser.nextStates(this.state);
+    if (s.length > 8 || this.stack.length >= 120) {
+      let r = [];
+      for (let o = 0, i; o < s.length; o += 2)
+        (i = s[o + 1]) != this.state && this.p.parser.hasAction(i, e) && r.push(s[o], i);
+      if (this.stack.length < 120)
+        for (let o = 0; r.length < 8 && o < s.length; o += 2) {
+          let i = s[o + 1];
+          r.some((l, a) => a & 1 && l == i) || r.push(s[o], i);
+        }
+      s = r;
+    }
+    let n = [];
+    for (let r = 0; r < s.length && n.length < 4; r += 2) {
+      let o = s[r + 1];
+      if (o == this.state)
+        continue;
+      let i = this.split();
+      i.pushState(o, this.pos), i.storeNode(0, i.pos, i.pos, 4, !0), i.shiftContext(s[r], this.pos), i.reducePos = this.pos, i.score -= 200, n.push(i);
+    }
+    return n;
+  }
+  // Force a reduce, if possible. Return false if that can't
+  // be done.
+  /**
+  @internal
+  */
+  forceReduce() {
+    let { parser: e } = this.p, s = e.stateSlot(
+      this.state,
+      5
+      /* ParseState.ForcedReduce */
+    );
+    if ((s & 65536) == 0)
+      return !1;
+    if (!e.validAction(this.state, s)) {
+      let n = s >> 19, r = s & 65535, o = this.stack.length - n * 3;
+      if (o < 0 || e.getGoto(this.stack[o], r, !1) < 0) {
+        let i = this.findForcedReduction();
+        if (i == null)
+          return !1;
+        s = i;
+      }
+      this.storeNode(0, this.pos, this.pos, 4, !0), this.score -= 100;
+    }
+    return this.reducePos = this.pos, this.reduce(s), !0;
+  }
+  /**
+  Try to scan through the automaton to find some kind of reduction
+  that can be applied. Used when the regular ForcedReduce field
+  isn't a valid action. @internal
+  */
+  findForcedReduction() {
+    let { parser: e } = this.p, s = [], n = (r, o) => {
+      if (!s.includes(r))
+        return s.push(r), e.allActions(r, (i) => {
+          if (!(i & 393216)) if (i & 65536) {
+            let l = (i >> 19) - o;
+            if (l > 1) {
+              let a = i & 65535, h = this.stack.length - l * 3;
+              if (h >= 0 && e.getGoto(this.stack[h], a, !1) >= 0)
+                return l << 19 | 65536 | a;
+            }
+          } else {
+            let l = n(i, o + 1);
+            if (l != null)
+              return l;
+          }
+        });
+    };
+    return n(this.state, 0);
+  }
+  /**
+  @internal
+  */
+  forceAll() {
+    for (; !this.p.parser.stateFlag(
+      this.state,
+      2
+      /* StateFlag.Accepting */
+    ); )
+      if (!this.forceReduce()) {
+        this.storeNode(0, this.pos, this.pos, 4, !0);
+        break;
+      }
+    return this;
+  }
+  /**
+  Check whether this state has no further actions (assumed to be a direct descendant of the
+  top state, since any other states must be able to continue
+  somehow). @internal
+  */
+  get deadEnd() {
+    if (this.stack.length != 3)
+      return !1;
+    let { parser: e } = this.p;
+    return e.data[e.stateSlot(
+      this.state,
+      1
+      /* ParseState.Actions */
+    )] == 65535 && !e.stateSlot(
+      this.state,
+      4
+      /* ParseState.DefaultReduce */
+    );
+  }
+  /**
+  Restart the stack (put it back in its start state). Only safe
+  when this.stack.length == 3 (state is directly below the top
+  state). @internal
+  */
+  restart() {
+    this.storeNode(0, this.pos, this.pos, 4, !0), this.state = this.stack[0], this.stack.length = 0;
+  }
+  /**
+  @internal
+  */
+  sameState(e) {
+    if (this.state != e.state || this.stack.length != e.stack.length)
+      return !1;
+    for (let s = 0; s < this.stack.length; s += 3)
+      if (this.stack[s] != e.stack[s])
+        return !1;
+    return !0;
+  }
+  /**
+  Get the parser used by this stack.
+  */
+  get parser() {
+    return this.p.parser;
+  }
+  /**
+  Test whether a given dialect (by numeric ID, as exported from
+  the terms file) is enabled.
+  */
+  dialectEnabled(e) {
+    return this.p.parser.dialect.flags[e];
+  }
+  shiftContext(e, s) {
+    this.curContext && this.updateContext(this.curContext.tracker.shift(this.curContext.context, e, this, this.p.stream.reset(s)));
+  }
+  reduceContext(e, s) {
+    this.curContext && this.updateContext(this.curContext.tracker.reduce(this.curContext.context, e, this, this.p.stream.reset(s)));
+  }
+  /**
+  @internal
+  */
+  emitContext() {
+    let e = this.buffer.length - 1;
+    (e < 0 || this.buffer[e] != -3) && this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);
+  }
+  /**
+  @internal
+  */
+  emitLookAhead() {
+    let e = this.buffer.length - 1;
+    (e < 0 || this.buffer[e] != -4) && this.buffer.push(this.lookAhead, this.pos, this.pos, -4);
+  }
+  updateContext(e) {
+    if (e != this.curContext.context) {
+      let s = new Re(this.curContext.tracker, e);
+      s.hash != this.curContext.hash && this.emitContext(), this.curContext = s;
+    }
+  }
+  /**
+  @internal
+  */
+  setLookAhead(e) {
+    e > this.lookAhead && (this.emitLookAhead(), this.lookAhead = e);
+  }
+  /**
+  @internal
+  */
+  close() {
+    this.curContext && this.curContext.tracker.strict && this.emitContext(), this.lookAhead > 0 && this.emitLookAhead();
+  }
+}
+class Re {
+  constructor(e, s) {
+    this.tracker = e, this.context = s, this.hash = e.strict ? e.hash(s) : 0;
+  }
+}
+class Tn {
+  constructor(e) {
+    this.start = e, this.state = e.state, this.stack = e.stack, this.base = this.stack.length;
+  }
+  reduce(e) {
+    let s = e & 65535, n = e >> 19;
+    n == 0 ? (this.stack == this.start.stack && (this.stack = this.stack.slice()), this.stack.push(this.state, 0, 0), this.base += 3) : this.base -= (n - 1) * 3;
+    let r = this.start.p.parser.getGoto(this.stack[this.base - 3], s, !0);
+    this.state = r;
+  }
+}
+class Z {
+  constructor(e, s, n) {
+    this.stack = e, this.pos = s, this.index = n, this.buffer = e.buffer, this.index == 0 && this.maybeNext();
+  }
+  static create(e, s = e.bufferBase + e.buffer.length) {
+    return new Z(e, s, s - e.bufferBase);
+  }
+  maybeNext() {
+    let e = this.stack.parent;
+    e != null && (this.index = this.stack.bufferBase - e.bufferBase, this.stack = e, this.buffer = e.buffer);
+  }
+  get id() {
+    return this.buffer[this.index - 4];
+  }
+  get start() {
+    return this.buffer[this.index - 3];
+  }
+  get end() {
+    return this.buffer[this.index - 2];
+  }
+  get size() {
+    return this.buffer[this.index - 1];
+  }
+  next() {
+    this.index -= 4, this.pos -= 4, this.index == 0 && this.maybeNext();
+  }
+  fork() {
+    return new Z(this.stack, this.pos, this.index);
+  }
+}
+function Q(t, e = Uint16Array) {
+  if (typeof t != "string")
+    return t;
+  let s = null;
+  for (let n = 0, r = 0; n < t.length; ) {
+    let o = 0;
+    for (; ; ) {
+      let i = t.charCodeAt(n++), l = !1;
+      if (i == 126) {
+        o = 65535;
+        break;
+      }
+      i >= 92 && i--, i >= 34 && i--;
+      let a = i - 32;
+      if (a >= 46 && (a -= 46, l = !0), o += a, l)
+        break;
+      o *= 46;
+    }
+    s ? s[r++] = o : s = new e(o);
+  }
+  return s;
+}
+class _ {
+  constructor() {
+    this.start = -1, this.value = -1, this.end = -1, this.extended = -1, this.lookAhead = 0, this.mask = 0, this.context = 0;
+  }
+}
+const Ne = new _();
+class vn {
+  /**
+  @internal
+  */
+  constructor(e, s) {
+    this.input = e, this.ranges = s, this.chunk = "", this.chunkOff = 0, this.chunk2 = "", this.chunk2Pos = 0, this.next = -1, this.token = Ne, this.rangeIndex = 0, this.pos = this.chunkPos = s[0].from, this.range = s[0], this.end = s[s.length - 1].to, this.readNext();
+  }
+  /**
+  @internal
+  */
+  resolveOffset(e, s) {
+    let n = this.range, r = this.rangeIndex, o = this.pos + e;
+    for (; o < n.from; ) {
+      if (!r)
+        return null;
+      let i = this.ranges[--r];
+      o -= n.from - i.to, n = i;
+    }
+    for (; s < 0 ? o > n.to : o >= n.to; ) {
+      if (r == this.ranges.length - 1)
+        return null;
+      let i = this.ranges[++r];
+      o += i.from - n.to, n = i;
+    }
+    return o;
+  }
+  /**
+  @internal
+  */
+  clipPos(e) {
+    if (e >= this.range.from && e < this.range.to)
+      return e;
+    for (let s of this.ranges)
+      if (s.to > e)
+        return Math.max(e, s.from);
+    return this.end;
+  }
+  /**
+  Look at a code unit near the stream position. `.peek(0)` equals
+  `.next`, `.peek(-1)` gives you the previous character, and so
+  on.
+  
+  Note that looking around during tokenizing creates dependencies
+  on potentially far-away content, which may reduce the
+  effectiveness incremental parsing—when looking forward—or even
+  cause invalid reparses when looking backward more than 25 code
+  units, since the library does not track lookbehind.
+  */
+  peek(e) {
+    let s = this.chunkOff + e, n, r;
+    if (s >= 0 && s < this.chunk.length)
+      n = this.pos + e, r = this.chunk.charCodeAt(s);
+    else {
+      let o = this.resolveOffset(e, 1);
+      if (o == null)
+        return -1;
+      if (n = o, n >= this.chunk2Pos && n < this.chunk2Pos + this.chunk2.length)
+        r = this.chunk2.charCodeAt(n - this.chunk2Pos);
+      else {
+        let i = this.rangeIndex, l = this.range;
+        for (; l.to <= n; )
+          l = this.ranges[++i];
+        this.chunk2 = this.input.chunk(this.chunk2Pos = n), n + this.chunk2.length > l.to && (this.chunk2 = this.chunk2.slice(0, l.to - n)), r = this.chunk2.charCodeAt(0);
+      }
+    }
+    return n >= this.token.lookAhead && (this.token.lookAhead = n + 1), r;
+  }
+  /**
+  Accept a token. By default, the end of the token is set to the
+  current stream position, but you can pass an offset (relative to
+  the stream position) to change that.
+  */
+  acceptToken(e, s = 0) {
+    let n = s ? this.resolveOffset(s, -1) : this.pos;
+    if (n == null || n < this.token.start)
+      throw new RangeError("Token end out of bounds");
+    this.token.value = e, this.token.end = n;
+  }
+  /**
+  Accept a token ending at a specific given position.
+  */
+  acceptTokenTo(e, s) {
+    this.token.value = e, this.token.end = s;
+  }
+  getChunk() {
+    if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {
+      let { chunk: e, chunkPos: s } = this;
+      this.chunk = this.chunk2, this.chunkPos = this.chunk2Pos, this.chunk2 = e, this.chunk2Pos = s, this.chunkOff = this.pos - this.chunkPos;
+    } else {
+      this.chunk2 = this.chunk, this.chunk2Pos = this.chunkPos;
+      let e = this.input.chunk(this.pos), s = this.pos + e.length;
+      this.chunk = s > this.range.to ? e.slice(0, this.range.to - this.pos) : e, this.chunkPos = this.pos, this.chunkOff = 0;
+    }
+  }
+  readNext() {
+    return this.chunkOff >= this.chunk.length && (this.getChunk(), this.chunkOff == this.chunk.length) ? this.next = -1 : this.next = this.chunk.charCodeAt(this.chunkOff);
+  }
+  /**
+  Move the stream forward N (defaults to 1) code units. Returns
+  the new value of [`next`](#lr.InputStream.next).
+  */
+  advance(e = 1) {
+    for (this.chunkOff += e; this.pos + e >= this.range.to; ) {
+      if (this.rangeIndex == this.ranges.length - 1)
+        return this.setDone();
+      e -= this.range.to - this.pos, this.range = this.ranges[++this.rangeIndex], this.pos = this.range.from;
+    }
+    return this.pos += e, this.pos >= this.token.lookAhead && (this.token.lookAhead = this.pos + 1), this.readNext();
+  }
+  setDone() {
+    return this.pos = this.chunkPos = this.end, this.range = this.ranges[this.rangeIndex = this.ranges.length - 1], this.chunk = "", this.next = -1;
+  }
+  /**
+  @internal
+  */
+  reset(e, s) {
+    if (s ? (this.token = s, s.start = e, s.lookAhead = e + 1, s.value = s.extended = -1) : this.token = Ne, this.pos != e) {
+      if (this.pos = e, e == this.end)
+        return this.setDone(), this;
+      for (; e < this.range.from; )
+        this.range = this.ranges[--this.rangeIndex];
+      for (; e >= this.range.to; )
+        this.range = this.ranges[++this.rangeIndex];
+      e >= this.chunkPos && e < this.chunkPos + this.chunk.length ? this.chunkOff = e - this.chunkPos : (this.chunk = "", this.chunkOff = 0), this.readNext();
+    }
+    return this;
+  }
+  /**
+  @internal
+  */
+  read(e, s) {
+    if (e >= this.chunkPos && s <= this.chunkPos + this.chunk.length)
+      return this.chunk.slice(e - this.chunkPos, s - this.chunkPos);
+    if (e >= this.chunk2Pos && s <= this.chunk2Pos + this.chunk2.length)
+      return this.chunk2.slice(e - this.chunk2Pos, s - this.chunk2Pos);
+    if (e >= this.range.from && s <= this.range.to)
+      return this.input.read(e, s);
+    let n = "";
+    for (let r of this.ranges) {
+      if (r.from >= s)
+        break;
+      r.to > e && (n += this.input.read(Math.max(r.from, e), Math.min(r.to, s)));
+    }
+    return n;
+  }
+}
+class N {
+  constructor(e, s) {
+    this.data = e, this.id = s;
+  }
+  token(e, s) {
+    let { parser: n } = s.p;
+    Pn(this.data, e, s, this.id, n.data, n.tokenPrecTable);
+  }
+}
+N.prototype.contextual = N.prototype.fallback = N.prototype.extend = !1;
+N.prototype.fallback = N.prototype.extend = !1;
+class wt {
+  /**
+  Create a tokenizer. The first argument is the function that,
+  given an input stream, scans for the types of tokens it
+  recognizes at the stream's position, and calls
+  [`acceptToken`](#lr.InputStream.acceptToken) when it finds
+  one.
+  */
+  constructor(e, s = {}) {
+    this.token = e, this.contextual = !!s.contextual, this.fallback = !!s.fallback, this.extend = !!s.extend;
+  }
+}
+function Pn(t, e, s, n, r, o) {
+  let i = 0, l = 1 << n, { dialect: a } = s.p.parser;
+  e: for (; (l & t[i]) != 0; ) {
+    let h = t[i + 1];
+    for (let d = i + 3; d < h; d += 2)
+      if ((t[d + 1] & l) > 0) {
+        let p = t[d];
+        if (a.allows(p) && (e.token.value == -1 || e.token.value == p || $n(p, e.token.value, r, o))) {
+          e.acceptToken(p);
+          break;
+        }
+      }
+    let c = e.next, u = 0, f = t[i + 2];
+    if (e.next < 0 && f > u && t[h + f * 3 - 3] == 65535) {
+      i = t[h + f * 3 - 1];
+      continue e;
+    }
+    for (; u < f; ) {
+      let d = u + f >> 1, p = h + d + (d << 1), m = t[p], g = t[p + 1] || 65536;
+      if (c < m)
+        f = d;
+      else if (c >= g)
+        u = d + 1;
+      else {
+        i = t[p + 2], e.advance();
+        continue e;
+      }
+    }
+    break;
+  }
+}
+function Ee(t, e, s) {
+  for (let n = e, r; (r = t[n]) != 65535; n++)
+    if (r == s)
+      return n - e;
+  return -1;
+}
+function $n(t, e, s, n) {
+  let r = Ee(s, n, e);
+  return r < 0 || Ee(s, n, t) < r;
+}
+const b = typeof process < "u" && process.env && /\bparse\b/.test(process.env.LOG);
+let oe = null;
+function We(t, e, s) {
+  let n = t.cursor(_t.IncludeAnonymous);
+  for (n.moveTo(e); ; )
+    if (!(s < 0 ? n.childBefore(e) : n.childAfter(e)))
+      for (; ; ) {
+        if ((s < 0 ? n.to < e : n.from > e) && !n.type.isError)
+          return s < 0 ? Math.max(0, Math.min(
+            n.to - 1,
+            e - 25
+            /* Lookahead.Margin */
+          )) : Math.min(t.length, Math.max(
+            n.from + 1,
+            e + 25
+            /* Lookahead.Margin */
+          ));
+        if (s < 0 ? n.prevSibling() : n.nextSibling())
+          break;
+        if (!n.parent())
+          return s < 0 ? 0 : t.length;
+      }
+}
+class An {
+  constructor(e, s) {
+    this.fragments = e, this.nodeSet = s, this.i = 0, this.fragment = null, this.safeFrom = -1, this.safeTo = -1, this.trees = [], this.start = [], this.index = [], this.nextFragment();
+  }
+  nextFragment() {
+    let e = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];
+    if (e) {
+      for (this.safeFrom = e.openStart ? We(e.tree, e.from + e.offset, 1) - e.offset : e.from, this.safeTo = e.openEnd ? We(e.tree, e.to + e.offset, -1) - e.offset : e.to; this.trees.length; )
+        this.trees.pop(), this.start.pop(), this.index.pop();
+      this.trees.push(e.tree), this.start.push(-e.offset), this.index.push(0), this.nextStart = this.safeFrom;
+    } else
+      this.nextStart = 1e9;
+  }
+  // `pos` must be >= any previously given `pos` for this cursor
+  nodeAt(e) {
+    if (e < this.nextStart)
+      return null;
+    for (; this.fragment && this.safeTo <= e; )
+      this.nextFragment();
+    if (!this.fragment)
+      return null;
+    for (; ; ) {
+      let s = this.trees.length - 1;
+      if (s < 0)
+        return this.nextFragment(), null;
+      let n = this.trees[s], r = this.index[s];
+      if (r == n.children.length) {
+        this.trees.pop(), this.start.pop(), this.index.pop();
+        continue;
+      }
+      let o = n.children[r], i = this.start[s] + n.positions[r];
+      if (i > e)
+        return this.nextStart = i, null;
+      if (o instanceof X) {
+        if (i == e) {
+          if (i < this.safeFrom)
+            return null;
+          let l = i + o.length;
+          if (l <= this.safeTo) {
+            let a = o.prop(E.lookAhead);
+            if (!a || l + a < this.fragment.to)
+              return o;
+          }
+        }
+        this.index[s]++, i + o.length >= Math.max(this.safeFrom, e) && (this.trees.push(o), this.start.push(i), this.index.push(0));
+      } else
+        this.index[s]++, this.nextStart = i + o.length;
+    }
+  }
+}
+class qn {
+  constructor(e, s) {
+    this.stream = s, this.tokens = [], this.mainToken = null, this.actions = [], this.tokens = e.tokenizers.map((n) => new _());
+  }
+  getActions(e) {
+    let s = 0, n = null, { parser: r } = e.p, { tokenizers: o } = r, i = r.stateSlot(
+      e.state,
+      3
+      /* ParseState.TokenizerMask */
+    ), l = e.curContext ? e.curContext.hash : 0, a = 0;
+    for (let h = 0; h < o.length; h++) {
+      if ((1 << h & i) == 0)
+        continue;
+      let c = o[h], u = this.tokens[h];
+      if (!(n && !c.fallback) && ((c.contextual || u.start != e.pos || u.mask != i || u.context != l) && (this.updateCachedToken(u, c, e), u.mask = i, u.context = l), u.lookAhead > u.end + 25 && (a = Math.max(u.lookAhead, a)), u.value != 0)) {
+        let f = s;
+        if (u.extended > -1 && (s = this.addActions(e, u.extended, u.end, s)), s = this.addActions(e, u.value, u.end, s), !c.extend && (n = u, s > f))
+          break;
+      }
+    }
+    for (; this.actions.length > s; )
+      this.actions.pop();
+    return a && e.setLookAhead(a), !n && e.pos == this.stream.end && (n = new _(), n.value = e.p.parser.eofTerm, n.start = n.end = e.pos, s = this.addActions(e, n.value, n.end, s)), this.mainToken = n, this.actions;
+  }
+  getMainToken(e) {
+    if (this.mainToken)
+      return this.mainToken;
+    let s = new _(), { pos: n, p: r } = e;
+    return s.start = n, s.end = Math.min(n + 1, r.stream.end), s.value = n == r.stream.end ? r.parser.eofTerm : 0, s;
+  }
+  updateCachedToken(e, s, n) {
+    let r = this.stream.clipPos(n.pos);
+    if (s.token(this.stream.reset(r, e), n), e.value > -1) {
+      let { parser: o } = n.p;
+      for (let i = 0; i < o.specialized.length; i++)
+        if (o.specialized[i] == e.value) {
+          let l = o.specializers[i](this.stream.read(e.start, e.end), n);
+          if (l >= 0 && n.p.parser.dialect.allows(l >> 1)) {
+            (l & 1) == 0 ? e.value = l >> 1 : e.extended = l >> 1;
+            break;
+          }
+        }
+    } else
+      e.value = 0, e.end = this.stream.clipPos(r + 1);
+  }
+  putAction(e, s, n, r) {
+    for (let o = 0; o < r; o += 3)
+      if (this.actions[o] == e)
+        return r;
+    return this.actions[r++] = e, this.actions[r++] = s, this.actions[r++] = n, r;
+  }
+  addActions(e, s, n, r) {
+    let { state: o } = e, { parser: i } = e.p, { data: l } = i;
+    for (let a = 0; a < 2; a++)
+      for (let h = i.stateSlot(
+        o,
+        a ? 2 : 1
+        /* ParseState.Actions */
+      ); ; h += 3) {
+        if (l[h] == 65535)
+          if (l[h + 1] == 1)
+            h = w(l, h + 2);
+          else {
+            r == 0 && l[h + 1] == 2 && (r = this.putAction(w(l, h + 2), s, n, r));
+            break;
+          }
+        l[h] == s && (r = this.putAction(w(l, h + 1), s, n, r));
+      }
+    return r;
+  }
+}
+class wn {
+  constructor(e, s, n, r) {
+    this.parser = e, this.input = s, this.ranges = r, this.recovering = 0, this.nextStackID = 9812, this.minStackPos = 0, this.reused = [], this.stoppedAt = null, this.lastBigReductionStart = -1, this.lastBigReductionSize = 0, this.bigReductionCount = 0, this.stream = new vn(s, r), this.tokens = new qn(e, this.stream), this.topTerm = e.top[1];
+    let { from: o } = r[0];
+    this.stacks = [Y.start(this, e.top[0], o)], this.fragments = n.length && this.stream.end - o > e.bufferLength * 4 ? new An(n, e.nodeSet) : null;
+  }
+  get parsedPos() {
+    return this.minStackPos;
+  }
+  // Move the parser forward. This will process all parse stacks at
+  // `this.pos` and try to advance them to a further position. If no
+  // stack for such a position is found, it'll start error-recovery.
+  //
+  // When the parse is finished, this will return a syntax tree. When
+  // not, it returns `null`.
+  advance() {
+    let e = this.stacks, s = this.minStackPos, n = this.stacks = [], r, o;
+    if (this.bigReductionCount > 300 && e.length == 1) {
+      let [i] = e;
+      for (; i.forceReduce() && i.stack.length && i.stack[i.stack.length - 2] >= this.lastBigReductionStart; )
+        ;
+      this.bigReductionCount = this.lastBigReductionSize = 0;
+    }
+    for (let i = 0; i < e.length; i++) {
+      let l = e[i];
+      for (; ; ) {
+        if (this.tokens.mainToken = null, l.pos > s)
+          n.push(l);
+        else {
+          if (this.advanceStack(l, n, e))
+            continue;
+          {
+            r || (r = [], o = []), r.push(l);
+            let a = this.tokens.getMainToken(l);
+            o.push(a.value, a.end);
+          }
+        }
+        break;
+      }
+    }
+    if (!n.length) {
+      let i = r && Rn(r);
+      if (i)
+        return b && console.log("Finish with " + this.stackID(i)), this.stackToTree(i);
+      if (this.parser.strict)
+        throw b && r && console.log("Stuck with token " + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : "none")), new SyntaxError("No parse at " + s);
+      this.recovering || (this.recovering = 5);
+    }
+    if (this.recovering && r) {
+      let i = this.stoppedAt != null && r[0].pos > this.stoppedAt ? r[0] : this.runRecovery(r, o, n);
+      if (i)
+        return b && console.log("Force-finish " + this.stackID(i)), this.stackToTree(i.forceAll());
+    }
+    if (this.recovering) {
+      let i = this.recovering == 1 ? 1 : this.recovering * 3;
+      if (n.length > i)
+        for (n.sort((l, a) => a.score - l.score); n.length > i; )
+          n.pop();
+      n.some((l) => l.reducePos > s) && this.recovering--;
+    } else if (n.length > 1) {
+      e: for (let i = 0; i < n.length - 1; i++) {
+        let l = n[i];
+        for (let a = i + 1; a < n.length; a++) {
+          let h = n[a];
+          if (l.sameState(h) || l.buffer.length > 500 && h.buffer.length > 500)
+            if ((l.score - h.score || l.buffer.length - h.buffer.length) > 0)
+              n.splice(a--, 1);
+            else {
+              n.splice(i--, 1);
+              continue e;
+            }
+        }
+      }
+      n.length > 12 && n.splice(
+        12,
+        n.length - 12
+        /* Rec.MaxStackCount */
+      );
+    }
+    this.minStackPos = n[0].pos;
+    for (let i = 1; i < n.length; i++)
+      n[i].pos < this.minStackPos && (this.minStackPos = n[i].pos);
+    return null;
+  }
+  stopAt(e) {
+    if (this.stoppedAt != null && this.stoppedAt < e)
+      throw new RangeError("Can't move stoppedAt forward");
+    this.stoppedAt = e;
+  }
+  // Returns an updated version of the given stack, or null if the
+  // stack can't advance normally. When `split` and `stacks` are
+  // given, stacks split off by ambiguous operations will be pushed to
+  // `split`, or added to `stacks` if they move `pos` forward.
+  advanceStack(e, s, n) {
+    let r = e.pos, { parser: o } = this, i = b ? this.stackID(e) + " -> " : "";
+    if (this.stoppedAt != null && r > this.stoppedAt)
+      return e.forceReduce() ? e : null;
+    if (this.fragments) {
+      let h = e.curContext && e.curContext.tracker.strict, c = h ? e.curContext.hash : 0;
+      for (let u = this.fragments.nodeAt(r); u; ) {
+        let f = this.parser.nodeSet.types[u.type.id] == u.type ? o.getGoto(e.state, u.type.id) : -1;
+        if (f > -1 && u.length && (!h || (u.prop(E.contextHash) || 0) == c))
+          return e.useNode(u, f), b && console.log(i + this.stackID(e) + ` (via reuse of ${o.getName(u.type.id)})`), !0;
+        if (!(u instanceof X) || u.children.length == 0 || u.positions[0] > 0)
+          break;
+        let d = u.children[0];
+        if (d instanceof X && u.positions[0] == 0)
+          u = d;
+        else
+          break;
+      }
+    }
+    let l = o.stateSlot(
+      e.state,
+      4
+      /* ParseState.DefaultReduce */
+    );
+    if (l > 0)
+      return e.reduce(l), b && console.log(i + this.stackID(e) + ` (via always-reduce ${o.getName(
+        l & 65535
+        /* Action.ValueMask */
+      )})`), !0;
+    if (e.stack.length >= 8400)
+      for (; e.stack.length > 6e3 && e.forceReduce(); )
+        ;
+    let a = this.tokens.getActions(e);
+    for (let h = 0; h < a.length; ) {
+      let c = a[h++], u = a[h++], f = a[h++], d = h == a.length || !n, p = d ? e : e.split(), m = this.tokens.mainToken;
+      if (p.apply(c, u, m ? m.start : p.pos, f), b && console.log(i + this.stackID(p) + ` (via ${(c & 65536) == 0 ? "shift" : `reduce of ${o.getName(
+        c & 65535
+        /* Action.ValueMask */
+      )}`} for ${o.getName(u)} @ ${r}${p == e ? "" : ", split"})`), d)
+        return !0;
+      p.pos > r ? s.push(p) : n.push(p);
+    }
+    return !1;
+  }
+  // Advance a given stack forward as far as it will go. Returns the
+  // (possibly updated) stack if it got stuck, or null if it moved
+  // forward and was given to `pushStackDedup`.
+  advanceFully(e, s) {
+    let n = e.pos;
+    for (; ; ) {
+      if (!this.advanceStack(e, null, null))
+        return !1;
+      if (e.pos > n)
+        return Ie(e, s), !0;
+    }
+  }
+  runRecovery(e, s, n) {
+    let r = null, o = !1;
+    for (let i = 0; i < e.length; i++) {
+      let l = e[i], a = s[i << 1], h = s[(i << 1) + 1], c = b ? this.stackID(l) + " -> " : "";
+      if (l.deadEnd && (o || (o = !0, l.restart(), b && console.log(c + this.stackID(l) + " (restarted)"), this.advanceFully(l, n))))
+        continue;
+      let u = l.split(), f = c;
+      for (let d = 0; u.forceReduce() && d < 10 && (b && console.log(f + this.stackID(u) + " (via force-reduce)"), !this.advanceFully(u, n)); d++)
+        b && (f = this.stackID(u) + " -> ");
+      for (let d of l.recoverByInsert(a))
+        b && console.log(c + this.stackID(d) + " (via recover-insert)"), this.advanceFully(d, n);
+      this.stream.end > l.pos ? (h == l.pos && (h++, a = 0), l.recoverByDelete(a, h), b && console.log(c + this.stackID(l) + ` (via recover-delete ${this.parser.getName(a)})`), Ie(l, n)) : (!r || r.score < l.score) && (r = l);
+    }
+    return r;
+  }
+  // Convert the stack's buffer to a syntax tree.
+  stackToTree(e) {
+    return e.close(), X.build({
+      buffer: Z.create(e),
+      nodeSet: this.parser.nodeSet,
+      topID: this.topTerm,
+      maxBufferLength: this.parser.bufferLength,
+      reused: this.reused,
+      start: this.ranges[0].from,
+      length: e.pos - this.ranges[0].from,
+      minRepeatType: this.parser.minRepeatTerm
+    });
+  }
+  stackID(e) {
+    let s = (oe || (oe = /* @__PURE__ */ new WeakMap())).get(e);
+    return s || oe.set(e, s = String.fromCodePoint(this.nextStackID++)), s + e;
+  }
+}
+function Ie(t, e) {
+  for (let s = 0; s < e.length; s++) {
+    let n = e[s];
+    if (n.pos == t.pos && n.sameState(t)) {
+      e[s].score < t.score && (e[s] = t);
+      return;
+    }
+  }
+  e.push(t);
+}
+class Bn {
+  constructor(e, s, n) {
+    this.source = e, this.flags = s, this.disabled = n;
+  }
+  allows(e) {
+    return !this.disabled || this.disabled[e] == 0;
+  }
+}
+const ie = (t) => t;
+class Dn {
+  /**
+  Define a context tracker.
+  */
+  constructor(e) {
+    this.start = e.start, this.shift = e.shift || ie, this.reduce = e.reduce || ie, this.reuse = e.reuse || ie, this.hash = e.hash || (() => 0), this.strict = e.strict !== !1;
+  }
+}
+class J extends Vt {
+  /**
+  @internal
+  */
+  constructor(e) {
+    if (super(), this.wrappers = [], e.version != 14)
+      throw new RangeError(`Parser version (${e.version}) doesn't match runtime version (14)`);
+    let s = e.nodeNames.split(" ");
+    this.minRepeatTerm = s.length;
+    for (let l = 0; l < e.repeatNodeCount; l++)
+      s.push("");
+    let n = Object.keys(e.topRules).map((l) => e.topRules[l][1]), r = [];
+    for (let l = 0; l < s.length; l++)
+      r.push([]);
+    function o(l, a, h) {
+      r[l].push([a, a.deserialize(String(h))]);
+    }
+    if (e.nodeProps)
+      for (let l of e.nodeProps) {
+        let a = l[0];
+        typeof a == "string" && (a = E[a]);
+        for (let h = 1; h < l.length; ) {
+          let c = l[h++];
+          if (c >= 0)
+            o(c, a, l[h++]);
+          else {
+            let u = l[h + -c];
+            for (let f = -c; f > 0; f--)
+              o(l[h++], a, u);
+            h++;
+          }
+        }
+      }
+    this.nodeSet = new Gt(s.map((l, a) => Qt.define({
+      name: a >= this.minRepeatTerm ? void 0 : l,
+      id: a,
+      props: r[a],
+      top: n.indexOf(a) > -1,
+      error: a == 0,
+      skipped: e.skippedNodes && e.skippedNodes.indexOf(a) > -1
+    }))), e.propSources && (this.nodeSet = this.nodeSet.extend(...e.propSources)), this.strict = !1, this.bufferLength = Xt;
+    let i = Q(e.tokenData);
+    this.context = e.context, this.specializerSpecs = e.specialized || [], this.specialized = new Uint16Array(this.specializerSpecs.length);
+    for (let l = 0; l < this.specializerSpecs.length; l++)
+      this.specialized[l] = this.specializerSpecs[l].term;
+    this.specializers = this.specializerSpecs.map(Le), this.states = Q(e.states, Uint32Array), this.data = Q(e.stateData), this.goto = Q(e.goto), this.maxTerm = e.maxTerm, this.tokenizers = e.tokenizers.map((l) => typeof l == "number" ? new N(i, l) : l), this.topRules = e.topRules, this.dialects = e.dialects || {}, this.dynamicPrecedences = e.dynamicPrecedences || null, this.tokenPrecTable = e.tokenPrec, this.termNames = e.termNames || null, this.maxNode = this.nodeSet.types.length - 1, this.dialect = this.parseDialect(), this.top = this.topRules[Object.keys(this.topRules)[0]];
+  }
+  createParse(e, s, n) {
+    let r = new wn(this, e, s, n);
+    for (let o of this.wrappers)
+      r = o(r, e, s, n);
+    return r;
+  }
+  /**
+  Get a goto table entry @internal
+  */
+  getGoto(e, s, n = !1) {
+    let r = this.goto;
+    if (s >= r[0])
+      return -1;
+    for (let o = r[s + 1]; ; ) {
+      let i = r[o++], l = i & 1, a = r[o++];
+      if (l && n)
+        return a;
+      for (let h = o + (i >> 1); o < h; o++)
+        if (r[o] == e)
+          return a;
+      if (l)
+        return -1;
+    }
+  }
+  /**
+  Check if this state has an action for a given terminal @internal
+  */
+  hasAction(e, s) {
+    let n = this.data;
+    for (let r = 0; r < 2; r++)
+      for (let o = this.stateSlot(
+        e,
+        r ? 2 : 1
+        /* ParseState.Actions */
+      ), i; ; o += 3) {
+        if ((i = n[o]) == 65535)
+          if (n[o + 1] == 1)
+            i = n[o = w(n, o + 2)];
+          else {
+            if (n[o + 1] == 2)
+              return w(n, o + 2);
+            break;
+          }
+        if (i == s || i == 0)
+          return w(n, o + 1);
+      }
+    return 0;
+  }
+  /**
+  @internal
+  */
+  stateSlot(e, s) {
+    return this.states[e * 6 + s];
+  }
+  /**
+  @internal
+  */
+  stateFlag(e, s) {
+    return (this.stateSlot(
+      e,
+      0
+      /* ParseState.Flags */
+    ) & s) > 0;
+  }
+  /**
+  @internal
+  */
+  validAction(e, s) {
+    return !!this.allActions(e, (n) => n == s ? !0 : null);
+  }
+  /**
+  @internal
+  */
+  allActions(e, s) {
+    let n = this.stateSlot(
+      e,
+      4
+      /* ParseState.DefaultReduce */
+    ), r = n ? s(n) : void 0;
+    for (let o = this.stateSlot(
+      e,
+      1
+      /* ParseState.Actions */
+    ); r == null; o += 3) {
+      if (this.data[o] == 65535)
+        if (this.data[o + 1] == 1)
+          o = w(this.data, o + 2);
+        else
+          break;
+      r = s(w(this.data, o + 1));
+    }
+    return r;
+  }
+  /**
+  Get the states that can follow this one through shift actions or
+  goto jumps. @internal
+  */
+  nextStates(e) {
+    let s = [];
+    for (let n = this.stateSlot(
+      e,
+      1
+      /* ParseState.Actions */
+    ); ; n += 3) {
+      if (this.data[n] == 65535)
+        if (this.data[n + 1] == 1)
+          n = w(this.data, n + 2);
+        else
+          break;
+      if ((this.data[n + 2] & 1) == 0) {
+        let r = this.data[n + 1];
+        s.some((o, i) => i & 1 && o == r) || s.push(this.data[n], r);
+      }
+    }
+    return s;
+  }
+  /**
+  Configure the parser. Returns a new parser instance that has the
+  given settings modified. Settings not provided in `config` are
+  kept from the original parser.
+  */
+  configure(e) {
+    let s = Object.assign(Object.create(J.prototype), this);
+    if (e.props && (s.nodeSet = this.nodeSet.extend(...e.props)), e.top) {
+      let n = this.topRules[e.top];
+      if (!n)
+        throw new RangeError(`Invalid top rule name ${e.top}`);
+      s.top = n;
+    }
+    return e.tokenizers && (s.tokenizers = this.tokenizers.map((n) => {
+      let r = e.tokenizers.find((o) => o.from == n);
+      return r ? r.to : n;
+    })), e.specializers && (s.specializers = this.specializers.slice(), s.specializerSpecs = this.specializerSpecs.map((n, r) => {
+      let o = e.specializers.find((l) => l.from == n.external);
+      if (!o)
+        return n;
+      let i = Object.assign(Object.assign({}, n), { external: o.to });
+      return s.specializers[r] = Le(i), i;
+    })), e.contextTracker && (s.context = e.contextTracker), e.dialect && (s.dialect = this.parseDialect(e.dialect)), e.strict != null && (s.strict = e.strict), e.wrap && (s.wrappers = s.wrappers.concat(e.wrap)), e.bufferLength != null && (s.bufferLength = e.bufferLength), s;
+  }
+  /**
+  Tells you whether any [parse wrappers](#lr.ParserConfig.wrap)
+  are registered for this parser.
+  */
+  hasWrappers() {
+    return this.wrappers.length > 0;
+  }
+  /**
+  Returns the name associated with a given term. This will only
+  work for all terms when the parser was generated with the
+  `--names` option. By default, only the names of tagged terms are
+  stored.
+  */
+  getName(e) {
+    return this.termNames ? this.termNames[e] : String(e <= this.maxNode && this.nodeSet.types[e].name || e);
+  }
+  /**
+  The eof term id is always allocated directly after the node
+  types. @internal
+  */
+  get eofTerm() {
+    return this.maxNode + 1;
+  }
+  /**
+  The type of top node produced by the parser.
+  */
+  get topNode() {
+    return this.nodeSet.types[this.top[1]];
+  }
+  /**
+  @internal
+  */
+  dynamicPrecedence(e) {
+    let s = this.dynamicPrecedences;
+    return s == null ? 0 : s[e] || 0;
+  }
+  /**
+  @internal
+  */
+  parseDialect(e) {
+    let s = Object.keys(this.dialects), n = s.map(() => !1);
+    if (e)
+      for (let o of e.split(" ")) {
+        let i = s.indexOf(o);
+        i >= 0 && (n[i] = !0);
+      }
+    let r = null;
+    for (let o = 0; o < s.length; o++)
+      if (!n[o])
+        for (let i = this.dialects[s[o]], l; (l = this.data[i++]) != 65535; )
+          (r || (r = new Uint8Array(this.maxTerm + 1)))[l] = 1;
+    return new Bn(e, n, r);
+  }
+  /**
+  Used by the output of the parser generator. Not available to
+  user code. @hide
+  */
+  static deserialize(e) {
+    return new J(e);
+  }
+}
+function w(t, e) {
+  return t[e] | t[e + 1] << 16;
+}
+function Rn(t) {
+  let e = null;
+  for (let s of t) {
+    let n = s.p.stoppedAt;
+    (s.pos == s.p.stream.end || n != null && s.pos > n) && s.p.parser.stateFlag(
+      s.state,
+      2
+      /* StateFlag.Accepting */
+    ) && (!e || e.score < s.score) && (e = s);
+  }
+  return e;
+}
+function Le(t) {
+  if (t.external) {
+    let e = t.extend ? 1 : 0;
+    return (s, n) => t.external(s, n) << 1 | e;
+  }
+  return t.get;
+}
+const Oe = 1, Nn = 2, En = 3, Wn = 4, In = 5, Ln = 36, Mn = 37, zn = 38, Vn = 11, Gn = 13;
+function Qn(t) {
+  return t == 45 || t == 46 || t == 58 || t >= 65 && t <= 90 || t == 95 || t >= 97 && t <= 122 || t >= 161;
+}
+function Xn(t) {
+  return t == 9 || t == 10 || t == 13 || t == 32;
+}
+let Me = null, ze = null, Ve = 0;
+function ge(t, e) {
+  let s = t.pos + e;
+  if (ze == t && Ve == s) return Me;
+  for (; Xn(t.peek(e)); ) e++;
+  let n = "";
+  for (; ; ) {
+    let r = t.peek(e);
+    if (!Qn(r)) break;
+    n += String.fromCharCode(r), e++;
+  }
+  return ze = t, Ve = s, Me = n || null;
+}
+function Ge(t, e) {
+  this.name = t, this.parent = e;
+}
+const _n = new Dn({
+  start: null,
+  shift(t, e, s, n) {
+    return e == Oe ? new Ge(ge(n, 1) || "", t) : t;
+  },
+  reduce(t, e) {
+    return e == Vn && t ? t.parent : t;
+  },
+  reuse(t, e, s, n) {
+    let r = e.type.id;
+    return r == Oe || r == Gn ? new Ge(ge(n, 1) || "", t) : t;
+  },
+  strict: !1
+}), Un = new wt((t, e) => {
+  if (t.next == 60) {
+    if (t.advance(), t.next == 47) {
+      t.advance();
+      let s = ge(t, 0);
+      if (!s) return t.acceptToken(In);
+      if (e.context && s == e.context.name) return t.acceptToken(Nn);
+      for (let n = e.context; n; n = n.parent) if (n.name == s) return t.acceptToken(En, -2);
+      t.acceptToken(Wn);
+    } else if (t.next != 33 && t.next != 63)
+      return t.acceptToken(Oe);
+  }
+}, { contextual: !0 });
+function Ce(t, e) {
+  return new wt((s) => {
+    let n = 0, r = e.charCodeAt(0);
+    e: for (; !(s.next < 0); s.advance(), n++)
+      if (s.next == r) {
+        for (let o = 1; o < e.length; o++)
+          if (s.peek(o) != e.charCodeAt(o)) continue e;
+        break;
+      }
+    n && s.acceptToken(t);
+  });
+}
+const Fn = Ce(Ln, "-->"), jn = Ce(Mn, "?>"), Yn = Ce(zn, "]]>"), Zn = Ut({
+  Text: S.content,
+  "StartTag StartCloseTag EndTag SelfCloseEndTag": S.angleBracket,
+  TagName: S.tagName,
+  "MismatchedCloseTag/TagName": [S.tagName, S.invalid],
+  AttributeName: S.attributeName,
+  AttributeValue: S.attributeValue,
+  Is: S.definitionOperator,
+  "EntityReference CharacterReference": S.character,
+  Comment: S.blockComment,
+  ProcessingInst: S.processingInstruction,
+  DoctypeDecl: S.documentMeta,
+  Cdata: S.special(S.string)
+}), Jn = J.deserialize({
+  version: 14,
+  states: ",lOQOaOOOrOxO'#CfOzOpO'#CiO!tOaO'#CgOOOP'#Cg'#CgO!{OrO'#CrO#TOtO'#CsO#]OpO'#CtOOOP'#DT'#DTOOOP'#Cv'#CvQQOaOOOOOW'#Cw'#CwO#eOxO,59QOOOP,59Q,59QOOOO'#Cx'#CxO#mOpO,59TO#uO!bO,59TOOOP'#C|'#C|O$TOaO,59RO$[OpO'#CoOOOP,59R,59ROOOQ'#C}'#C}O$dOrO,59^OOOP,59^,59^OOOS'#DO'#DOO$lOtO,59_OOOP,59_,59_O$tOpO,59`O$|OpO,59`OOOP-E6t-E6tOOOW-E6u-E6uOOOP1G.l1G.lOOOO-E6v-E6vO%UO!bO1G.oO%UO!bO1G.oO%dOpO'#CkO%lO!bO'#CyO%zO!bO1G.oOOOP1G.o1G.oOOOP1G.w1G.wOOOP-E6z-E6zOOOP1G.m1G.mO&VOpO,59ZO&_OpO,59ZOOOQ-E6{-E6{OOOP1G.x1G.xOOOS-E6|-E6|OOOP1G.y1G.yO&gOpO1G.zO&gOpO1G.zOOOP1G.z1G.zO&oO!bO7+$ZO&}O!bO7+$ZOOOP7+$Z7+$ZOOOP7+$c7+$cO'YOpO,59VO'bOpO,59VO'mO!bO,59eOOOO-E6w-E6wO'{OpO1G.uO'{OpO1G.uOOOP1G.u1G.uO(TOpO7+$fOOOP7+$f7+$fO(]O!bO<<GuOOOP<<Gu<<GuOOOP<<G}<<G}O'bOpO1G.qO'bOpO1G.qO(hO#tO'#CnO(vO&jO'#CnOOOO1G.q1G.qO)UOpO7+$aOOOP7+$a7+$aOOOP<<HQ<<HQOOOPAN=aAN=aOOOPAN=iAN=iO'bOpO7+$]OOOO7+$]7+$]OOOO'#Cz'#CzO)^O#tO,59YOOOO,59Y,59YOOOO'#C{'#C{O)lO&jO,59YOOOP<<G{<<G{OOOO<<Gw<<GwOOOO-E6x-E6xOOOO1G.t1G.tOOOO-E6y-E6y",
+  stateData: ")z~OPQOSVOTWOVWOWWOXWOiXOyPO!QTO!SUO~OvZOx]O~O^`Oz^O~OPQOQcOSVOTWOVWOWWOXWOyPO!QTO!SUO~ORdO~P!SOteO!PgO~OuhO!RjO~O^lOz^O~OvZOxoO~O^qOz^O~O[vO`sOdwOz^O~ORyO~P!SO^{Oz^O~OteO!P}O~OuhO!R!PO~O^!QOz^O~O[!SOz^O~O[!VO`sOd!WOz^O~Oa!YOz^O~Oz^O[mX`mXdmX~O[!VO`sOd!WO~O^!]Oz^O~O[!_Oz^O~O[!aOz^O~O[!cO`sOd!dOz^O~O[!cO`sOd!dO~Oa!eOz^O~Oz^O{!gO}!hO~Oz^O[ma`madma~O[!kOz^O~O[!lOz^O~O[!mO`sOd!nO~OW!qOX!qO{!sO|!qO~OW!tOX!tO}!sO!O!tO~O[!vOz^O~OW!qOX!qO{!yO|!qO~OW!tOX!tO}!yO!O!tO~O",
+  goto: "%cxPPPPPPPPPPyyP!PP!VPP!`!jP!pyyyP!v!|#S$[$k$q$w$}%TPPPP%ZXWORYbXRORYb_t`qru!T!U!bQ!i!YS!p!e!fR!w!oQdRRybXSORYbQYORmYQ[PRn[Q_QQkVjp_krz!R!T!X!Z!^!`!f!j!oQr`QzcQ!RlQ!TqQ!XsQ!ZtQ!^{Q!`!QQ!f!YQ!j!]R!o!eQu`S!UqrU![u!U!bR!b!TQ!r!gR!x!rQ!u!hR!z!uQbRRxbQfTR|fQiUR!OiSXOYTaRb",
+  nodeNames: "⚠ StartTag StartCloseTag MissingCloseTag StartCloseTag StartCloseTag Document Text EntityReference CharacterReference Cdata Element EndTag OpenTag TagName Attribute AttributeName Is AttributeValue CloseTag SelfCloseEndTag SelfClosingTag Comment ProcessingInst MismatchedCloseTag DoctypeDecl",
+  maxTerm: 50,
+  context: _n,
+  nodeProps: [
+    ["closedBy", 1, "SelfCloseEndTag EndTag", 13, "CloseTag MissingCloseTag"],
+    ["openedBy", 12, "StartTag StartCloseTag", 19, "OpenTag", 20, "StartTag"],
+    ["isolate", -6, 13, 18, 19, 21, 22, 24, ""]
+  ],
+  propSources: [Zn],
+  skippedNodes: [0],
+  repeatNodeCount: 9,
+  tokenData: "!)v~R!YOX$qXY)iYZ)iZ]$q]^)i^p$qpq)iqr$qrs*vsv$qvw+fwx/ix}$q}!O0[!O!P$q!P!Q2z!Q![$q![!]4n!]!^$q!^!_8U!_!`!#t!`!a!$l!a!b!%d!b!c$q!c!}4n!}#P$q#P#Q!'W#Q#R$q#R#S4n#S#T$q#T#o4n#o%W$q%W%o4n%o%p$q%p&a4n&a&b$q&b1p4n1p4U$q4U4d4n4d4e$q4e$IS4n$IS$I`$q$I`$Ib4n$Ib$Kh$q$Kh%#t4n%#t&/x$q&/x&Et4n&Et&FV$q&FV;'S4n;'S;:j8O;:j;=`)c<%l?&r$q?&r?Ah4n?Ah?BY$q?BY?Mn4n?MnO$qi$zXVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qa%nVVP!O`Ov%gwx&Tx!^%g!^!_&o!_;'S%g;'S;=`'W<%lO%gP&YTVPOv&Tw!^&T!_;'S&T;'S;=`&i<%lO&TP&lP;=`<%l&T`&tS!O`Ov&ox;'S&o;'S;=`'Q<%lO&o`'TP;=`<%l&oa'ZP;=`<%l%gX'eWVP|WOr'^rs&Tsv'^w!^'^!^!_'}!_;'S'^;'S;=`(i<%lO'^W(ST|WOr'}sv'}w;'S'};'S;=`(c<%lO'}W(fP;=`<%l'}X(lP;=`<%l'^h(vV|W!O`Or(ors&osv(owx'}x;'S(o;'S;=`)]<%lO(oh)`P;=`<%l(oi)fP;=`<%l$qo)t`VP|W!O`zUOX$qXY)iYZ)iZ]$q]^)i^p$qpq)iqr$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qk+PV{YVP!O`Ov%gwx&Tx!^%g!^!_&o!_;'S%g;'S;=`'W<%lO%g~+iast,n![!]-r!c!}-r#R#S-r#T#o-r%W%o-r%p&a-r&b1p-r4U4d-r4e$IS-r$I`$Ib-r$Kh%#t-r&/x&Et-r&FV;'S-r;'S;:j/c?&r?Ah-r?BY?Mn-r~,qQ!Q![,w#l#m-V~,zQ!Q![,w!]!^-Q~-VOX~~-YR!Q![-c!c!i-c#T#Z-c~-fS!Q![-c!]!^-Q!c!i-c#T#Z-c~-ug}!O-r!O!P-r!Q![-r![!]-r!]!^/^!c!}-r#R#S-r#T#o-r$}%O-r%W%o-r%p&a-r&b1p-r1p4U-r4U4d-r4e$IS-r$I`$Ib-r$Je$Jg-r$Kh%#t-r&/x&Et-r&FV;'S-r;'S;:j/c?&r?Ah-r?BY?Mn-r~/cOW~~/fP;=`<%l-rk/rW}bVP|WOr'^rs&Tsv'^w!^'^!^!_'}!_;'S'^;'S;=`(i<%lO'^k0eZVP|W!O`Or$qrs%gsv$qwx'^x}$q}!O1W!O!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qk1aZVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_!`$q!`!a2S!a;'S$q;'S;=`)c<%lO$qk2_X!PQVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qm3TZVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_!`$q!`!a3v!a;'S$q;'S;=`)c<%lO$qm4RXdSVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qo4{!P`S^QVP|W!O`Or$qrs%gsv$qwx'^x}$q}!O4n!O!P4n!P!Q$q!Q![4n![!]4n!]!^$q!^!_(o!_!c$q!c!}4n!}#R$q#R#S4n#S#T$q#T#o4n#o$}$q$}%O4n%O%W$q%W%o4n%o%p$q%p&a4n&a&b$q&b1p4n1p4U4n4U4d4n4d4e$q4e$IS4n$IS$I`$q$I`$Ib4n$Ib$Je$q$Je$Jg4n$Jg$Kh$q$Kh%#t4n%#t&/x$q&/x&Et4n&Et&FV$q&FV;'S4n;'S;:j8O;:j;=`)c<%l?&r$q?&r?Ah4n?Ah?BY$q?BY?Mn4n?MnO$qo8RP;=`<%l4ni8]Y|W!O`Oq(oqr8{rs&osv(owx'}x!a(o!a!b!#U!b;'S(o;'S;=`)]<%lO(oi9S_|W!O`Or(ors&osv(owx'}x}(o}!O:R!O!f(o!f!g;e!g!}(o!}#ODh#O#W(o#W#XLp#X;'S(o;'S;=`)]<%lO(oi:YX|W!O`Or(ors&osv(owx'}x}(o}!O:u!O;'S(o;'S;=`)]<%lO(oi;OV!QP|W!O`Or(ors&osv(owx'}x;'S(o;'S;=`)]<%lO(oi;lX|W!O`Or(ors&osv(owx'}x!q(o!q!r<X!r;'S(o;'S;=`)]<%lO(oi<`X|W!O`Or(ors&osv(owx'}x!e(o!e!f<{!f;'S(o;'S;=`)]<%lO(oi=SX|W!O`Or(ors&osv(owx'}x!v(o!v!w=o!w;'S(o;'S;=`)]<%lO(oi=vX|W!O`Or(ors&osv(owx'}x!{(o!{!|>c!|;'S(o;'S;=`)]<%lO(oi>jX|W!O`Or(ors&osv(owx'}x!r(o!r!s?V!s;'S(o;'S;=`)]<%lO(oi?^X|W!O`Or(ors&osv(owx'}x!g(o!g!h?y!h;'S(o;'S;=`)]<%lO(oi@QY|W!O`Or?yrs@psv?yvwA[wxBdx!`?y!`!aCr!a;'S?y;'S;=`Db<%lO?ya@uV!O`Ov@pvxA[x!`@p!`!aAy!a;'S@p;'S;=`B^<%lO@pPA_TO!`A[!`!aAn!a;'SA[;'S;=`As<%lOA[PAsOiPPAvP;=`<%lA[aBQSiP!O`Ov&ox;'S&o;'S;=`'Q<%lO&oaBaP;=`<%l@pXBiX|WOrBdrsA[svBdvwA[w!`Bd!`!aCU!a;'SBd;'S;=`Cl<%lOBdXC]TiP|WOr'}sv'}w;'S'};'S;=`(c<%lO'}XCoP;=`<%lBdiC{ViP|W!O`Or(ors&osv(owx'}x;'S(o;'S;=`)]<%lO(oiDeP;=`<%l?yiDoZ|W!O`Or(ors&osv(owx'}x!e(o!e!fEb!f#V(o#V#WIr#W;'S(o;'S;=`)]<%lO(oiEiX|W!O`Or(ors&osv(owx'}x!f(o!f!gFU!g;'S(o;'S;=`)]<%lO(oiF]X|W!O`Or(ors&osv(owx'}x!c(o!c!dFx!d;'S(o;'S;=`)]<%lO(oiGPX|W!O`Or(ors&osv(owx'}x!v(o!v!wGl!w;'S(o;'S;=`)]<%lO(oiGsX|W!O`Or(ors&osv(owx'}x!c(o!c!dH`!d;'S(o;'S;=`)]<%lO(oiHgX|W!O`Or(ors&osv(owx'}x!}(o!}#OIS#O;'S(o;'S;=`)]<%lO(oiI]V|W!O`yPOr(ors&osv(owx'}x;'S(o;'S;=`)]<%lO(oiIyX|W!O`Or(ors&osv(owx'}x#W(o#W#XJf#X;'S(o;'S;=`)]<%lO(oiJmX|W!O`Or(ors&osv(owx'}x#T(o#T#UKY#U;'S(o;'S;=`)]<%lO(oiKaX|W!O`Or(ors&osv(owx'}x#h(o#h#iK|#i;'S(o;'S;=`)]<%lO(oiLTX|W!O`Or(ors&osv(owx'}x#T(o#T#UH`#U;'S(o;'S;=`)]<%lO(oiLwX|W!O`Or(ors&osv(owx'}x#c(o#c#dMd#d;'S(o;'S;=`)]<%lO(oiMkX|W!O`Or(ors&osv(owx'}x#V(o#V#WNW#W;'S(o;'S;=`)]<%lO(oiN_X|W!O`Or(ors&osv(owx'}x#h(o#h#iNz#i;'S(o;'S;=`)]<%lO(oi! RX|W!O`Or(ors&osv(owx'}x#m(o#m#n! n#n;'S(o;'S;=`)]<%lO(oi! uX|W!O`Or(ors&osv(owx'}x#d(o#d#e!!b#e;'S(o;'S;=`)]<%lO(oi!!iX|W!O`Or(ors&osv(owx'}x#X(o#X#Y?y#Y;'S(o;'S;=`)]<%lO(oi!#_V!SP|W!O`Or(ors&osv(owx'}x;'S(o;'S;=`)]<%lO(ok!$PXaQVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qo!$wX[UVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qk!%mZVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_!`$q!`!a!&`!a;'S$q;'S;=`)c<%lO$qk!&kX!RQVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$qk!'aZVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_#P$q#P#Q!(S#Q;'S$q;'S;=`)c<%lO$qk!(]ZVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_!`$q!`!a!)O!a;'S$q;'S;=`)c<%lO$qk!)ZXxQVP|W!O`Or$qrs%gsv$qwx'^x!^$q!^!_(o!_;'S$q;'S;=`)c<%lO$q",
+  tokenizers: [Un, Fn, jn, Yn, 0, 1, 2, 3, 4],
+  topRules: { Document: [0, 6] },
+  tokenPrec: 0
+});
+function U(t, e) {
+  let s = e && e.getChild("TagName");
+  return s ? t.sliceString(s.from, s.to) : "";
+}
+function le(t, e) {
+  let s = e && e.firstChild;
+  return !s || s.name != "OpenTag" ? "" : U(t, s);
+}
+function Hn(t, e, s) {
+  let n = e && e.getChildren("Attribute").find((o) => o.from <= s && o.to >= s), r = n && n.getChild("AttributeName");
+  return r ? t.sliceString(r.from, r.to) : "";
+}
+function ae(t) {
+  for (let e = t && t.parent; e; e = e.parent)
+    if (e.name == "Element")
+      return e;
+  return null;
+}
+function Kn(t, e) {
+  var s;
+  let n = M(t).resolveInner(e, -1), r = null;
+  for (let o = n; !r && o.parent; o = o.parent)
+    (o.name == "OpenTag" || o.name == "CloseTag" || o.name == "SelfClosingTag" || o.name == "MismatchedCloseTag") && (r = o);
+  if (r && (r.to > e || r.lastChild.type.isError)) {
+    let o = r.parent;
+    if (n.name == "TagName")
+      return r.name == "CloseTag" || r.name == "MismatchedCloseTag" ? { type: "closeTag", from: n.from, context: o } : { type: "openTag", from: n.from, context: ae(o) };
+    if (n.name == "AttributeName")
+      return { type: "attrName", from: n.from, context: r };
+    if (n.name == "AttributeValue")
+      return { type: "attrValue", from: n.from, context: r };
+    let i = n == r || n.name == "Attribute" ? n.childBefore(e) : n;
+    return (i == null ? void 0 : i.name) == "StartTag" ? { type: "openTag", from: e, context: ae(o) } : (i == null ? void 0 : i.name) == "StartCloseTag" && i.to <= e ? { type: "closeTag", from: e, context: o } : (i == null ? void 0 : i.name) == "Is" ? { type: "attrValue", from: e, context: r } : i ? { type: "attrName", from: e, context: r } : null;
+  } else if (n.name == "StartCloseTag")
+    return { type: "closeTag", from: e, context: n.parent };
+  for (; n.parent && n.to == e && !(!((s = n.lastChild) === null || s === void 0) && s.type.isError); )
+    n = n.parent;
+  return n.name == "Element" || n.name == "Text" || n.name == "Document" ? { type: "tag", from: e, context: n.name == "Element" ? n : ae(n) } : null;
+}
+class er {
+  constructor(e, s, n) {
+    this.attrs = s, this.attrValues = n, this.children = [], this.name = e.name, this.completion = Object.assign(Object.assign({ type: "type" }, e.completion || {}), { label: this.name }), this.openCompletion = Object.assign(Object.assign({}, this.completion), { label: "<" + this.name }), this.closeCompletion = Object.assign(Object.assign({}, this.completion), { label: "</" + this.name + ">", boost: 2 }), this.closeNameCompletion = Object.assign(Object.assign({}, this.completion), { label: this.name + ">" }), this.text = e.textContent ? e.textContent.map((r) => ({ label: r, type: "text" })) : [];
+  }
+}
+const he = /^[:\-\.\w\u00b7-\uffff]*$/;
+function Qe(t) {
+  return Object.assign(Object.assign({ type: "property" }, t.completion || {}), { label: t.name });
+}
+function Xe(t) {
+  return typeof t == "string" ? { label: `"${t}"`, type: "constant" } : /^"/.test(t.label) ? t : Object.assign(Object.assign({}, t), { label: `"${t.label}"` });
+}
+function tr(t, e) {
+  let s = [], n = [], r = /* @__PURE__ */ Object.create(null);
+  for (let a of e) {
+    let h = Qe(a);
+    s.push(h), a.global && n.push(h), a.values && (r[a.name] = a.values.map(Xe));
+  }
+  let o = [], i = [], l = /* @__PURE__ */ Object.create(null);
+  for (let a of t) {
+    let h = n, c = r;
+    a.attributes && (h = h.concat(a.attributes.map((f) => typeof f == "string" ? s.find((d) => d.label == f) || { label: f, type: "property" } : (f.values && (c == r && (c = Object.create(c)), c[f.name] = f.values.map(Xe)), Qe(f)))));
+    let u = new er(a, h, c);
+    l[u.name] = u, o.push(u), a.top && i.push(u);
+  }
+  i.length || (i = o);
+  for (let a = 0; a < o.length; a++) {
+    let h = t[a], c = o[a];
+    if (h.children)
+      for (let u of h.children)
+        l[u] && c.children.push(l[u]);
+    else
+      c.children = o;
+  }
+  return (a) => {
+    var h;
+    let { doc: c } = a.state, u = Kn(a.state, a.pos);
+    if (!u || u.type == "tag" && !a.explicit)
+      return null;
+    let { type: f, from: d, context: p } = u;
+    if (f == "openTag") {
+      let m = i, g = le(c, p);
+      if (g) {
+        let x = l[g];
+        m = (x == null ? void 0 : x.children) || o;
+      }
+      return {
+        from: d,
+        options: m.map((x) => x.completion),
+        validFor: he
+      };
+    } else if (f == "closeTag") {
+      let m = le(c, p);
+      return m ? {
+        from: d,
+        to: a.pos + (c.sliceString(a.pos, a.pos + 1) == ">" ? 1 : 0),
+        options: [((h = l[m]) === null || h === void 0 ? void 0 : h.closeNameCompletion) || { label: m + ">", type: "type" }],
+        validFor: he
+      } : null;
+    } else if (f == "attrName") {
+      let m = l[U(c, p)];
+      return {
+        from: d,
+        options: (m == null ? void 0 : m.attrs) || n,
+        validFor: he
+      };
+    } else if (f == "attrValue") {
+      let m = Hn(c, p, d);
+      if (!m)
+        return null;
+      let g = l[U(c, p)], x = ((g == null ? void 0 : g.attrValues) || r)[m];
+      return !x || !x.length ? null : {
+        from: d,
+        to: a.pos + (c.sliceString(a.pos, a.pos + 1) == '"' ? 1 : 0),
+        options: x,
+        validFor: /^"[^"]*"?$/
+      };
+    } else if (f == "tag") {
+      let m = le(c, p), g = l[m], x = [], B = p && p.lastChild;
+      m && (!B || B.name != "CloseTag" || U(c, B) != m) && x.push(g ? g.closeCompletion : { label: "</" + m + ">", type: "type", boost: 2 });
+      let se = x.concat(((g == null ? void 0 : g.children) || (p ? o : i)).map((V) => V.openCompletion));
+      if (p && (g != null && g.text.length)) {
+        let V = p.firstChild;
+        V.to > a.pos - 20 && !/\S/.test(a.state.sliceDoc(V.to, a.pos)) && (se = se.concat(g.text));
+      }
+      return {
+        from: d,
+        options: se,
+        validFor: /^<\/?[:\-\.\w\u00b7-\uffff]*$/
+      };
+    } else
+      return null;
+  };
+}
+const xe = /* @__PURE__ */ Ft.define({
+  name: "xml",
+  parser: /* @__PURE__ */ Jn.configure({
+    props: [
+      /* @__PURE__ */ Yt.add({
+        Element(t) {
+          let e = /^\s*<\//.test(t.textAfter);
+          return t.lineIndent(t.node.from) + (e ? 0 : t.unit);
+        },
+        "OpenTag CloseTag SelfClosingTag"(t) {
+          return t.column(t.node.from) + t.unit;
+        }
+      }),
+      /* @__PURE__ */ Zt.add({
+        Element(t) {
+          let e = t.firstChild, s = t.lastChild;
+          return !e || e.name != "OpenTag" ? null : { from: e.to, to: s.name == "CloseTag" ? s.from : t.to };
+        }
+      }),
+      /* @__PURE__ */ Jt.add({
+        "OpenTag CloseTag": (t) => t.getChild("TagName")
+      })
+    ]
+  }),
+  languageData: {
+    commentTokens: { block: { open: "<!--", close: "-->" } },
+    indentOnInput: /^\s*<\/$/
+  }
+});
+function sr(t = {}) {
+  let e = [xe.data.of({
+    autocomplete: tr(t.elements || [], t.attributes || [])
+  })];
+  return t.autoCloseTags !== !1 && e.push(nr), new jt(xe, e);
+}
+function _e(t, e, s = t.length) {
+  if (!e)
+    return "";
+  let n = e.firstChild, r = n && n.getChild("TagName");
+  return r ? t.sliceString(r.from, Math.min(r.to, s)) : "";
+}
+const nr = /* @__PURE__ */ v.inputHandler.of((t, e, s, n, r) => {
+  if (t.composing || t.state.readOnly || e != s || n != ">" && n != "/" || !xe.isActiveAt(t.state, e, -1))
+    return !1;
+  let o = r(), { state: i } = o, l = i.changeByRange((a) => {
+    var h, c, u;
+    let { head: f } = a, d = i.doc.sliceString(f - 1, f) == n, p = M(i).resolveInner(f, -1), m;
+    if (d && n == ">" && p.name == "EndTag") {
+      let g = p.parent;
+      if (((c = (h = g.parent) === null || h === void 0 ? void 0 : h.lastChild) === null || c === void 0 ? void 0 : c.name) != "CloseTag" && (m = _e(i.doc, g.parent, f))) {
+        let x = f + (i.doc.sliceString(f, f + 1) === ">" ? 1 : 0), B = `</${m}>`;
+        return { range: a, changes: { from: f, to: x, insert: B } };
+      }
+    } else if (d && n == "/" && p.name == "StartCloseTag") {
+      let g = p.parent;
+      if (p.from == f - 2 && ((u = g.lastChild) === null || u === void 0 ? void 0 : u.name) != "CloseTag" && (m = _e(i.doc, g, f))) {
+        let x = f + (i.doc.sliceString(f, f + 1) === ">" ? 1 : 0), B = `${m}>`;
+        return {
+          range: O.cursor(f + B.length, -1),
+          changes: { from: f, to: x, insert: B }
+        };
+      }
+    }
+    return { range: a };
+  });
+  return l.changes.empty ? !1 : (t.dispatch([
+    o,
+    i.update(l, {
+      userEvent: "input.complete",
+      scrollIntoView: !0
+    })
+  ]), !0);
+}), rr = us.base, or = "code-editor", Bt = ({
+  id: t,
+  className: e,
+  style: s,
+  readOnly: n,
+  height: r,
+  gutterWidth: o,
+  config: i,
+  onChange: l,
+  onBlur: a
+}) => {
+  const h = Rt();
+  return Nt(() => {
+    const c = Te.create({
+      doc: i,
+      extensions: [
+        Ht.highest(
+          ve.of([
+            {
+              key: "Enter",
+              run: (f) => me(f)
+            }
+          ])
+        ),
+        ve.of([
+          bn,
+          Cn,
+          ...ws
+        ]),
+        Kt(),
+        es(),
+        ts(),
+        ss(),
+        ns(),
+        rs(),
+        os(),
+        is(),
+        ls(),
+        as(),
+        hs(),
+        sr(),
+        ys(),
+        cs,
+        Te.readOnly.of(n),
+        v.updateListener.of((f) => {
+          l(f);
+        }),
+        v.focusChangeEffect.of((f, d) => {
+          d || a == null || a(f);
+        }),
+        v.domEventHandlers({
+          keydown(f) {
+            f.stopPropagation();
+          }
+        })
+      ]
+    }), u = new v({
+      state: c,
+      parent: h.current
+    });
+    return () => {
+      u.destroy();
+    };
+  }, [h]), /* @__PURE__ */ Dt(
+    "div",
+    {
+      id: t,
+      ref: h,
+      className: [
+        rr,
+        or,
+        e
+      ].filter((c) => c).join(" "),
+      style: {
+        "--height": r,
+        "--gutter-width": o,
+        ...s
+      }
+    }
+  );
+};
+Bt.propTypes = {
+  /**
+     * The HTML id for this element
+     */
+  id: $.string,
+  /**
+     * The HTML class names for this element
+     */
+  className: $.string,
+  /**
+     * The React-written, css properties for this element.
+     */
+  style: $.objectOf($.string),
+  /**
+     *  Whether or not the content is read only.
+     */
+  readOnly: $.bool,
+  /**
+   * The initial labeling configuration.
+   */
+  config: $.string,
+  /**
+   * The height of the editor.
+   */
+  height: $.string,
+  /**
+   * The callback for when the labeling configuration changes.
+   */
+  onChange: $.func,
+  /**
+   * The width of the gutter.
+   */
+  gutterWidth: $.string,
+  /**
+   * The callback for when the editor loses focus.
+   */
+  onBlur: $.func
+};
+Bt.defaultProps = {
+  config: `<View>
+  <!--Edit this config to customize the labeling interface.-->
+</View>
+  `,
+  height: "20em",
+  gutterWidth: "3em"
+};
+export {
+  Bt as default
+};