@marimo-team/islands 0.21.2-dev62 → 0.21.2-dev63

package/dist/esm-CxoKu9RN.js

@@ -0,0 +1,2805 @@
+import { s as __toESM } from "./chunk-BNovOVIE.js";
+import { t as require_react } from "./react-Bs6Z0kvn.js";
+import { t as require_compiler_runtime } from "./compiler-runtime-B_OLMU9S.js";
+import { n as Copy, r as toast, t as copyToClipboard } from "./copy-B7XqFjF_.js";
+import { t as Check } from "./check-B2OoWw2h.js";
+import { h as Events, y as cn } from "./button-B1ZgJ7Cc.js";
+import { t as require_jsx_runtime } from "./jsx-runtime-9hcJiI23.js";
+import { t as Tooltip } from "./tooltip-DnI4CwIS.js";
+import { $ as ViewPlugin, A as indentString, At as Prec, B as tags, Bt as combineConfig, C as foldKeymap, Ct as ChangeSet, D as getIndentation, Dt as EditorState, E as getIndentUnit, Et as EditorSelection, F as syntaxHighlighting, Ft as StateField, H as NodeProp, Ht as findClusterBreak, I as syntaxTree, It as Text, Lt as Transaction, Mt as RangeSetBuilder, N as matchBrackets, Ot as Facet, Pt as StateEffect, Rt as codePointAt, St as ChangeDesc, Ut as fromCodePoint, Vt as countColumn, X as Direction, Y as Decoration, Z as EditorView, _t as showDialog, a as HighlightStyle, bt as crelt, ct as highlightActiveLineGutter, dt as keymap, et as WidgetType, ft as lineNumbers, g as defaultHighlightStyle, gt as runScopeHandlers, ht as rectangularSelection, it as getPanel, j as indentUnit, jt as RangeSet, k as indentOnInput, lt as highlightSpecialChars, mt as placeholder, nt as drawSelection, o as IndentContext, p as bracketMatching, pt as logException, rt as dropCursor, st as highlightActiveLine, tt as crosshairCursor, ut as hoverTooltip, vt as showPanel, wt as CharCategory, x as foldGutter, xt as Annotation, zt as codePointSize } from "./dist-C4EV3aDt.js";
+import { a as closeBracketsKeymap, c as completionKeymap, i as closeBrackets, r as autocompletion } from "./dist-BYr4a-wE.js";
+var import_compiler_runtime = require_compiler_runtime(), import_react = /* @__PURE__ */ __toESM(require_react(), 1), import_jsx_runtime = /* @__PURE__ */ __toESM(require_jsx_runtime(), 1);
+const CopyClipboardIcon = (e6) => {
+  let x = (0, import_compiler_runtime.c)(14), { value: S, className: k, buttonClassName: j, tooltip: M, toastTitle: N, ariaLabel: P } = e6, [F, I] = (0, import_react.useState)(false), L;
+  x[0] !== N || x[1] !== S ? (L = Events.stopPropagation(async (e7) => {
+    await copyToClipboard(typeof S == "function" ? S(e7) : S).then(() => {
+      I(true), setTimeout(() => I(false), 2e3), N && toast({ title: N });
+    });
+  }), x[0] = N, x[1] = S, x[2] = L) : L = x[2];
+  let R = L, z = P ?? "Copy to clipboard", B;
+  x[3] !== k || x[4] !== F ? (B = F ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Check, { className: cn(k, "text-(--grass-11)") }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Copy, { className: k }), x[3] = k, x[4] = F, x[5] = B) : B = x[5];
+  let V;
+  x[6] !== j || x[7] !== R || x[8] !== z || x[9] !== B ? (V = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", {
+    type: "button",
+    onClick: R,
+    "aria-label": z,
+    className: j,
+    children: B
+  }), x[6] = j, x[7] = R, x[8] = z, x[9] = B, x[10] = V) : V = x[10];
+  let H = V;
+  if (M === false) return H;
+  let U = F ? "Copied!" : M ?? "Copy to clipboard", W;
+  return x[11] !== H || x[12] !== U ? (W = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Tooltip, {
+    content: U,
+    delayDuration: 400,
+    children: H
+  }), x[11] = H, x[12] = U, x[13] = W) : W = x[13], W;
+};
+var toggleComment = (e6) => {
+  let { state: x } = e6, S = x.doc.lineAt(x.selection.main.from), C = getConfig(e6.state, S.from);
+  return C.line ? toggleLineComment(e6) : C.block ? toggleBlockCommentByLine(e6) : false;
+};
+function command(e6, x) {
+  return ({ state: S, dispatch: C }) => {
+    if (S.readOnly) return false;
+    let w = e6(x, S);
+    return w ? (C(S.update(w)), true) : false;
+  };
+}
+var toggleLineComment = /* @__PURE__ */ command(changeLineComment, 0), toggleBlockComment = /* @__PURE__ */ command(changeBlockComment, 0), toggleBlockCommentByLine = /* @__PURE__ */ command((e6, x) => changeBlockComment(e6, x, selectedLineRanges(x)), 0);
+function getConfig(e6, x) {
+  let S = e6.languageDataAt("commentTokens", x, 1);
+  return S.length ? S[0] : {};
+}
+var SearchMargin = 50;
+function findBlockComment(e6, { open: x, close: S }, C, w) {
+  let T = e6.sliceDoc(C - SearchMargin, C), E = e6.sliceDoc(w, w + SearchMargin), D = /\s*$/.exec(T)[0].length, O = /^\s*/.exec(E)[0].length, k = T.length - D;
+  if (T.slice(k - x.length, k) == x && E.slice(O, O + S.length) == S) return {
+    open: {
+      pos: C - D,
+      margin: D && 1
+    },
+    close: {
+      pos: w + O,
+      margin: O && 1
+    }
+  };
+  let A, j;
+  w - C <= 2 * SearchMargin ? A = j = e6.sliceDoc(C, w) : (A = e6.sliceDoc(C, C + SearchMargin), j = e6.sliceDoc(w - SearchMargin, w));
+  let M = /^\s*/.exec(A)[0].length, N = /\s*$/.exec(j)[0].length, P = j.length - N - S.length;
+  return A.slice(M, M + x.length) == x && j.slice(P, P + S.length) == S ? {
+    open: {
+      pos: C + M + x.length,
+      margin: /\s/.test(A.charAt(M + x.length)) ? 1 : 0
+    },
+    close: {
+      pos: w - N - S.length,
+      margin: /\s/.test(j.charAt(P - 1)) ? 1 : 0
+    }
+  } : null;
+}
+function selectedLineRanges(e6) {
+  let x = [];
+  for (let S of e6.selection.ranges) {
+    let C = e6.doc.lineAt(S.from), w = S.to <= C.to ? C : e6.doc.lineAt(S.to);
+    w.from > C.from && w.from == S.to && (w = S.to == C.to + 1 ? C : e6.doc.lineAt(S.to - 1));
+    let T = x.length - 1;
+    T >= 0 && x[T].to > C.from ? x[T].to = w.to : x.push({
+      from: C.from + /^\s*/.exec(C.text)[0].length,
+      to: w.to
+    });
+  }
+  return x;
+}
+function changeBlockComment(e6, x, S = x.selection.ranges) {
+  let C = S.map((e7) => getConfig(x, e7.from).block);
+  if (!C.every((e7) => e7)) return null;
+  let w = S.map((e7, S2) => findBlockComment(x, C[S2], e7.from, e7.to));
+  if (e6 != 2 && !w.every((e7) => e7)) return { changes: x.changes(S.map((e7, x2) => w[x2] ? [] : [{
+    from: e7.from,
+    insert: C[x2].open + " "
+  }, {
+    from: e7.to,
+    insert: " " + C[x2].close
+  }])) };
+  if (e6 != 1 && w.some((e7) => e7)) {
+    let e7 = [];
+    for (let x2 = 0, S2; x2 < w.length; x2++) if (S2 = w[x2]) {
+      let w2 = C[x2], { open: T, close: E } = S2;
+      e7.push({
+        from: T.pos - w2.open.length,
+        to: T.pos + T.margin
+      }, {
+        from: E.pos - E.margin,
+        to: E.pos + w2.close.length
+      });
+    }
+    return { changes: e7 };
+  }
+  return null;
+}
+function changeLineComment(e6, x, S = x.selection.ranges) {
+  let C = [], w = -1;
+  ranges: for (let { from: e7, to: T } of S) {
+    let S2 = C.length, E = 1e9, D;
+    for (let S3 = e7; S3 <= T; ) {
+      let O = x.doc.lineAt(S3);
+      if (D == null && (D = getConfig(x, O.from).line, !D)) continue ranges;
+      if (O.from > w && (e7 == T || T > O.from)) {
+        w = O.from;
+        let e8 = /^\s*/.exec(O.text)[0].length, x2 = e8 == O.length, S4 = O.text.slice(e8, e8 + D.length) == D ? e8 : -1;
+        e8 < O.text.length && e8 < E && (E = e8), C.push({
+          line: O,
+          comment: S4,
+          token: D,
+          indent: e8,
+          empty: x2,
+          single: false
+        });
+      }
+      S3 = O.to + 1;
+    }
+    if (E < 1e9) for (let e8 = S2; e8 < C.length; e8++) C[e8].indent < C[e8].line.text.length && (C[e8].indent = E);
+    C.length == S2 + 1 && (C[S2].single = true);
+  }
+  if (e6 != 2 && C.some((e7) => e7.comment < 0 && (!e7.empty || e7.single))) {
+    let e7 = [];
+    for (let { line: x2, token: S3, indent: w2, empty: T, single: E } of C) (E || !T) && e7.push({
+      from: x2.from + w2,
+      insert: S3 + " "
+    });
+    let S2 = x.changes(e7);
+    return {
+      changes: S2,
+      selection: x.selection.map(S2, 1)
+    };
+  } else if (e6 != 1 && C.some((e7) => e7.comment >= 0)) {
+    let e7 = [];
+    for (let { line: x2, comment: S2, token: w2 } of C) if (S2 >= 0) {
+      let C2 = x2.from + S2, T = C2 + w2.length;
+      x2.text[T - x2.from] == " " && T++, e7.push({
+        from: C2,
+        to: T
+      });
+    }
+    return { changes: e7 };
+  }
+  return null;
+}
+var fromHistory = /* @__PURE__ */ Annotation.define(), isolateHistory = /* @__PURE__ */ Annotation.define(), invertedEffects = /* @__PURE__ */ Facet.define(), historyConfig = /* @__PURE__ */ Facet.define({ combine(e6) {
+  return combineConfig(e6, {
+    minDepth: 100,
+    newGroupDelay: 500,
+    joinToEvent: (e7, x) => x
+  }, {
+    minDepth: Math.max,
+    newGroupDelay: Math.min,
+    joinToEvent: (e7, x) => (S, C) => e7(S, C) || x(S, C)
+  });
+} }), historyField_ = /* @__PURE__ */ StateField.define({
+  create() {
+    return HistoryState.empty;
+  },
+  update(e6, x) {
+    let S = x.state.facet(historyConfig), C = x.annotation(fromHistory);
+    if (C) {
+      let w2 = HistEvent.fromTransaction(x, C.selection), T2 = C.side, E2 = T2 == 0 ? e6.undone : e6.done;
+      return E2 = w2 ? updateBranch(E2, E2.length, S.minDepth, w2) : addSelection(E2, x.startState.selection), new HistoryState(T2 == 0 ? C.rest : E2, T2 == 0 ? E2 : C.rest);
+    }
+    let w = x.annotation(isolateHistory);
+    if ((w == "full" || w == "before") && (e6 = e6.isolate()), x.annotation(Transaction.addToHistory) === false) return x.changes.empty ? e6 : e6.addMapping(x.changes.desc);
+    let T = HistEvent.fromTransaction(x), E = x.annotation(Transaction.time), D = x.annotation(Transaction.userEvent);
+    return T ? e6 = e6.addChanges(T, E, D, S, x) : x.selection && (e6 = e6.addSelection(x.startState.selection, E, D, S.newGroupDelay)), (w == "full" || w == "after") && (e6 = e6.isolate()), e6;
+  },
+  toJSON(e6) {
+    return {
+      done: e6.done.map((e7) => e7.toJSON()),
+      undone: e6.undone.map((e7) => e7.toJSON())
+    };
+  },
+  fromJSON(e6) {
+    return new HistoryState(e6.done.map(HistEvent.fromJSON), e6.undone.map(HistEvent.fromJSON));
+  }
+});
+function history(e6 = {}) {
+  return [
+    historyField_,
+    historyConfig.of(e6),
+    EditorView.domEventHandlers({ beforeinput(e7, x) {
+      let S = e7.inputType == "historyUndo" ? undo : e7.inputType == "historyRedo" ? redo : null;
+      return S ? (e7.preventDefault(), S(x)) : false;
+    } })
+  ];
+}
+var historyField = historyField_;
+function cmd(e6, x) {
+  return function({ state: S, dispatch: C }) {
+    if (!x && S.readOnly) return false;
+    let w = S.field(historyField_, false);
+    if (!w) return false;
+    let T = w.pop(e6, S, x);
+    return T ? (C(T), true) : false;
+  };
+}
+var undo = /* @__PURE__ */ cmd(0, false), redo = /* @__PURE__ */ cmd(1, false), undoSelection = /* @__PURE__ */ cmd(0, true), redoSelection = /* @__PURE__ */ cmd(1, true), HistEvent = class e {
+  constructor(e6, x, S, C, w) {
+    this.changes = e6, this.effects = x, this.mapped = S, this.startSelection = C, this.selectionsAfter = w;
+  }
+  setSelAfter(x) {
+    return new e(this.changes, this.effects, this.mapped, this.startSelection, x);
+  }
+  toJSON() {
+    var _a, _b, _c;
+    return {
+      changes: (_a = this.changes) == null ? void 0 : _a.toJSON(),
+      mapped: (_b = this.mapped) == null ? void 0 : _b.toJSON(),
+      startSelection: (_c = this.startSelection) == null ? void 0 : _c.toJSON(),
+      selectionsAfter: this.selectionsAfter.map((e6) => e6.toJSON())
+    };
+  }
+  static fromJSON(x) {
+    return new e(x.changes && ChangeSet.fromJSON(x.changes), [], x.mapped && ChangeDesc.fromJSON(x.mapped), x.startSelection && EditorSelection.fromJSON(x.startSelection), x.selectionsAfter.map(EditorSelection.fromJSON));
+  }
+  static fromTransaction(x, S) {
+    let C = none;
+    for (let e6 of x.startState.facet(invertedEffects)) {
+      let S2 = e6(x);
+      S2.length && (C = C.concat(S2));
+    }
+    return !C.length && x.changes.empty ? null : new e(x.changes.invert(x.startState.doc), C, void 0, S || x.startState.selection, none);
+  }
+  static selection(x) {
+    return new e(void 0, none, void 0, void 0, x);
+  }
+};
+function updateBranch(e6, x, S, C) {
+  let w = x + 1 > S + 20 ? x - S - 1 : 0, T = e6.slice(w, x);
+  return T.push(C), T;
+}
+function isAdjacent(e6, x) {
+  let S = [], C = false;
+  return e6.iterChangedRanges((e7, x2) => S.push(e7, x2)), x.iterChangedRanges((e7, x2, w, T) => {
+    for (let e8 = 0; e8 < S.length; ) {
+      let x3 = S[e8++], E = S[e8++];
+      T >= x3 && w <= E && (C = true);
+    }
+  }), C;
+}
+function eqSelectionShape(e6, x) {
+  return e6.ranges.length == x.ranges.length && e6.ranges.filter((e7, S) => e7.empty != x.ranges[S].empty).length === 0;
+}
+function conc(e6, x) {
+  return e6.length ? x.length ? e6.concat(x) : e6 : x;
+}
+var none = [], MaxSelectionsPerEvent = 200;
+function addSelection(e6, x) {
+  if (e6.length) {
+    let S = e6[e6.length - 1], C = S.selectionsAfter.slice(Math.max(0, S.selectionsAfter.length - MaxSelectionsPerEvent));
+    return C.length && C[C.length - 1].eq(x) ? e6 : (C.push(x), updateBranch(e6, e6.length - 1, 1e9, S.setSelAfter(C)));
+  } else return [HistEvent.selection([x])];
+}
+function popSelection(e6) {
+  let x = e6[e6.length - 1], S = e6.slice();
+  return S[e6.length - 1] = x.setSelAfter(x.selectionsAfter.slice(0, x.selectionsAfter.length - 1)), S;
+}
+function addMappingToBranch(e6, x) {
+  if (!e6.length) return e6;
+  let S = e6.length, C = none;
+  for (; S; ) {
+    let w = mapEvent(e6[S - 1], x, C);
+    if (w.changes && !w.changes.empty || w.effects.length) {
+      let x2 = e6.slice(0, S);
+      return x2[S - 1] = w, x2;
+    } else x = w.mapped, S--, C = w.selectionsAfter;
+  }
+  return C.length ? [HistEvent.selection(C)] : none;
+}
+function mapEvent(e6, x, S) {
+  let C = conc(e6.selectionsAfter.length ? e6.selectionsAfter.map((e7) => e7.map(x)) : none, S);
+  if (!e6.changes) return HistEvent.selection(C);
+  let w = e6.changes.map(x), T = x.mapDesc(e6.changes, true), E = e6.mapped ? e6.mapped.composeDesc(T) : T;
+  return new HistEvent(w, StateEffect.mapEffects(e6.effects, x), E, e6.startSelection.map(T), C);
+}
+var joinableUserEvent = /^(input\.type|delete)($|\.)/, HistoryState = class e2 {
+  constructor(e6, x, S = 0, C = void 0) {
+    this.done = e6, this.undone = x, this.prevTime = S, this.prevUserEvent = C;
+  }
+  isolate() {
+    return this.prevTime ? new e2(this.done, this.undone) : this;
+  }
+  addChanges(x, S, C, w, T) {
+    let E = this.done, D = E[E.length - 1];
+    return E = D && D.changes && !D.changes.empty && x.changes && (!C || joinableUserEvent.test(C)) && (!D.selectionsAfter.length && S - this.prevTime < w.newGroupDelay && w.joinToEvent(T, isAdjacent(D.changes, x.changes)) || C == "input.type.compose") ? updateBranch(E, E.length - 1, w.minDepth, new HistEvent(x.changes.compose(D.changes), conc(StateEffect.mapEffects(x.effects, D.changes), D.effects), D.mapped, D.startSelection, none)) : updateBranch(E, E.length, w.minDepth, x), new e2(E, none, S, C);
+  }
+  addSelection(x, S, C, w) {
+    let T = this.done.length ? this.done[this.done.length - 1].selectionsAfter : none;
+    return T.length > 0 && S - this.prevTime < w && C == this.prevUserEvent && C && /^select($|\.)/.test(C) && eqSelectionShape(T[T.length - 1], x) ? this : new e2(addSelection(this.done, x), this.undone, S, C);
+  }
+  addMapping(x) {
+    return new e2(addMappingToBranch(this.done, x), addMappingToBranch(this.undone, x), this.prevTime, this.prevUserEvent);
+  }
+  pop(e6, x, S) {
+    let C = e6 == 0 ? this.done : this.undone;
+    if (C.length == 0) return null;
+    let w = C[C.length - 1], T = w.selectionsAfter[0] || (w.startSelection ? w.startSelection.map(w.changes.invertedDesc, 1) : x.selection);
+    if (S && w.selectionsAfter.length) return x.update({
+      selection: w.selectionsAfter[w.selectionsAfter.length - 1],
+      annotations: fromHistory.of({
+        side: e6,
+        rest: popSelection(C),
+        selection: T
+      }),
+      userEvent: e6 == 0 ? "select.undo" : "select.redo",
+      scrollIntoView: true
+    });
+    if (w.changes) {
+      let S2 = C.length == 1 ? none : C.slice(0, C.length - 1);
+      return w.mapped && (S2 = addMappingToBranch(S2, w.mapped)), x.update({
+        changes: w.changes,
+        selection: w.startSelection,
+        effects: w.effects,
+        annotations: fromHistory.of({
+          side: e6,
+          rest: S2,
+          selection: T
+        }),
+        filter: false,
+        userEvent: e6 == 0 ? "undo" : "redo",
+        scrollIntoView: true
+      });
+    } else return null;
+  }
+};
+HistoryState.empty = /* @__PURE__ */ new HistoryState(none, none);
+var historyKeymap = [
+  {
+    key: "Mod-z",
+    run: undo,
+    preventDefault: true
+  },
+  {
+    key: "Mod-y",
+    mac: "Mod-Shift-z",
+    run: redo,
+    preventDefault: true
+  },
+  {
+    linux: "Ctrl-Shift-z",
+    run: redo,
+    preventDefault: true
+  },
+  {
+    key: "Mod-u",
+    run: undoSelection,
+    preventDefault: true
+  },
+  {
+    key: "Alt-u",
+    mac: "Mod-Shift-u",
+    run: redoSelection,
+    preventDefault: true
+  }
+];
+function updateSel(e6, x) {
+  return EditorSelection.create(e6.ranges.map(x), e6.mainIndex);
+}
+function setSel(e6, x) {
+  return e6.update({
+    selection: x,
+    scrollIntoView: true,
+    userEvent: "select"
+  });
+}
+function moveSel({ state: e6, dispatch: x }, S) {
+  let C = updateSel(e6.selection, S);
+  return C.eq(e6.selection, true) ? false : (x(setSel(e6, C)), true);
+}
+function rangeEnd(e6, x) {
+  return EditorSelection.cursor(x ? e6.to : e6.from);
+}
+function cursorByChar(e6, x) {
+  return moveSel(e6, (S) => S.empty ? e6.moveByChar(S, x) : rangeEnd(S, x));
+}
+function ltrAtCursor(e6) {
+  return e6.textDirectionAt(e6.state.selection.main.head) == Direction.LTR;
+}
+var cursorCharLeft = (e6) => cursorByChar(e6, !ltrAtCursor(e6)), cursorCharRight = (e6) => cursorByChar(e6, ltrAtCursor(e6));
+function cursorByGroup(e6, x) {
+  return moveSel(e6, (S) => S.empty ? e6.moveByGroup(S, x) : rangeEnd(S, x));
+}
+var cursorGroupLeft = (e6) => cursorByGroup(e6, !ltrAtCursor(e6)), cursorGroupRight = (e6) => cursorByGroup(e6, ltrAtCursor(e6));
+typeof Intl < "u" && Intl.Segmenter;
+function interestingNode(e6, x, S) {
+  if (x.type.prop(S)) return true;
+  let C = x.to - x.from;
+  return C && (C > 2 || /[^\s,.;:]/.test(e6.sliceDoc(x.from, x.to))) || x.firstChild;
+}
+function moveBySyntax(e6, x, S) {
+  let C = syntaxTree(e6).resolveInner(x.head), w = S ? NodeProp.closedBy : NodeProp.openedBy;
+  for (let T2 = x.head; ; ) {
+    let x2 = S ? C.childAfter(T2) : C.childBefore(T2);
+    if (!x2) break;
+    interestingNode(e6, x2, w) ? C = x2 : T2 = S ? x2.to : x2.from;
+  }
+  let T = C.type.prop(w), E, D;
+  return D = T && (E = S ? matchBrackets(e6, C.from, 1) : matchBrackets(e6, C.to, -1)) && E.matched ? S ? E.end.to : E.end.from : S ? C.to : C.from, EditorSelection.cursor(D, S ? -1 : 1);
+}
+var cursorSyntaxLeft = (e6) => moveSel(e6, (x) => moveBySyntax(e6.state, x, !ltrAtCursor(e6))), cursorSyntaxRight = (e6) => moveSel(e6, (x) => moveBySyntax(e6.state, x, ltrAtCursor(e6)));
+function cursorByLine(e6, x) {
+  return moveSel(e6, (S) => {
+    if (!S.empty) return rangeEnd(S, x);
+    let C = e6.moveVertically(S, x);
+    return C.head == S.head ? e6.moveToLineBoundary(S, x) : C;
+  });
+}
+var cursorLineUp = (e6) => cursorByLine(e6, false), cursorLineDown = (e6) => cursorByLine(e6, true);
+function pageInfo(e6) {
+  let x = e6.scrollDOM.clientHeight < e6.scrollDOM.scrollHeight - 2, S = 0, C = 0, w;
+  if (x) {
+    for (let x2 of e6.state.facet(EditorView.scrollMargins)) {
+      let w2 = x2(e6);
+      (w2 == null ? void 0 : w2.top) && (S = Math.max(w2 == null ? void 0 : w2.top, S)), (w2 == null ? void 0 : w2.bottom) && (C = Math.max(w2 == null ? void 0 : w2.bottom, C));
+    }
+    w = e6.scrollDOM.clientHeight - S - C;
+  } else w = (e6.dom.ownerDocument.defaultView || window).innerHeight;
+  return {
+    marginTop: S,
+    marginBottom: C,
+    selfScroll: x,
+    height: Math.max(e6.defaultLineHeight, w - 5)
+  };
+}
+function cursorByPage(e6, x) {
+  let S = pageInfo(e6), { state: C } = e6, w = updateSel(C.selection, (C2) => C2.empty ? e6.moveVertically(C2, x, S.height) : rangeEnd(C2, x));
+  if (w.eq(C.selection)) return false;
+  let T;
+  if (S.selfScroll) {
+    let x2 = e6.coordsAtPos(C.selection.main.head), E = e6.scrollDOM.getBoundingClientRect(), D = E.top + S.marginTop, O = E.bottom - S.marginBottom;
+    x2 && x2.top > D && x2.bottom < O && (T = EditorView.scrollIntoView(w.main.head, {
+      y: "start",
+      yMargin: x2.top - D
+    }));
+  }
+  return e6.dispatch(setSel(C, w), { effects: T }), true;
+}
+var cursorPageUp = (e6) => cursorByPage(e6, false), cursorPageDown = (e6) => cursorByPage(e6, true);
+function moveByLineBoundary(e6, x, S) {
+  let C = e6.lineBlockAt(x.head), w = e6.moveToLineBoundary(x, S);
+  if (w.head == x.head && w.head != (S ? C.to : C.from) && (w = e6.moveToLineBoundary(x, S, false)), !S && w.head == C.from && C.length) {
+    let S2 = /^\s*/.exec(e6.state.sliceDoc(C.from, Math.min(C.from + 100, C.to)))[0].length;
+    S2 && x.head != C.from + S2 && (w = EditorSelection.cursor(C.from + S2));
+  }
+  return w;
+}
+var cursorLineBoundaryForward = (e6) => moveSel(e6, (x) => moveByLineBoundary(e6, x, true)), cursorLineBoundaryBackward = (e6) => moveSel(e6, (x) => moveByLineBoundary(e6, x, false)), cursorLineBoundaryLeft = (e6) => moveSel(e6, (x) => moveByLineBoundary(e6, x, !ltrAtCursor(e6))), cursorLineBoundaryRight = (e6) => moveSel(e6, (x) => moveByLineBoundary(e6, x, ltrAtCursor(e6))), cursorLineStart = (e6) => moveSel(e6, (x) => EditorSelection.cursor(e6.lineBlockAt(x.head).from, 1)), cursorLineEnd = (e6) => moveSel(e6, (x) => EditorSelection.cursor(e6.lineBlockAt(x.head).to, -1));
+function toMatchingBracket(e6, x, S) {
+  let C = false, w = updateSel(e6.selection, (x2) => {
+    let w2 = matchBrackets(e6, x2.head, -1) || matchBrackets(e6, x2.head, 1) || x2.head > 0 && matchBrackets(e6, x2.head - 1, 1) || x2.head < e6.doc.length && matchBrackets(e6, x2.head + 1, -1);
+    if (!w2 || !w2.end) return x2;
+    C = true;
+    let T = w2.start.from == x2.head ? w2.end.to : w2.end.from;
+    return S ? EditorSelection.range(x2.anchor, T) : EditorSelection.cursor(T);
+  });
+  return C ? (x(setSel(e6, w)), true) : false;
+}
+var cursorMatchingBracket = ({ state: e6, dispatch: x }) => toMatchingBracket(e6, x, false);
+function extendSel(e6, x) {
+  let S = updateSel(e6.state.selection, (e7) => {
+    let S2 = x(e7);
+    return EditorSelection.range(e7.anchor, S2.head, S2.goalColumn, S2.bidiLevel || void 0);
+  });
+  return S.eq(e6.state.selection) ? false : (e6.dispatch(setSel(e6.state, S)), true);
+}
+function selectByChar(e6, x) {
+  return extendSel(e6, (S) => e6.moveByChar(S, x));
+}
+var selectCharLeft = (e6) => selectByChar(e6, !ltrAtCursor(e6)), selectCharRight = (e6) => selectByChar(e6, ltrAtCursor(e6));
+function selectByGroup(e6, x) {
+  return extendSel(e6, (S) => e6.moveByGroup(S, x));
+}
+var selectGroupLeft = (e6) => selectByGroup(e6, !ltrAtCursor(e6)), selectGroupRight = (e6) => selectByGroup(e6, ltrAtCursor(e6)), selectSyntaxLeft = (e6) => extendSel(e6, (x) => moveBySyntax(e6.state, x, !ltrAtCursor(e6))), selectSyntaxRight = (e6) => extendSel(e6, (x) => moveBySyntax(e6.state, x, ltrAtCursor(e6)));
+function selectByLine(e6, x) {
+  return extendSel(e6, (S) => e6.moveVertically(S, x));
+}
+var selectLineUp = (e6) => selectByLine(e6, false), selectLineDown = (e6) => selectByLine(e6, true);
+function selectByPage(e6, x) {
+  return extendSel(e6, (S) => e6.moveVertically(S, x, pageInfo(e6).height));
+}
+var selectPageUp = (e6) => selectByPage(e6, false), selectPageDown = (e6) => selectByPage(e6, true), selectLineBoundaryForward = (e6) => extendSel(e6, (x) => moveByLineBoundary(e6, x, true)), selectLineBoundaryBackward = (e6) => extendSel(e6, (x) => moveByLineBoundary(e6, x, false)), selectLineBoundaryLeft = (e6) => extendSel(e6, (x) => moveByLineBoundary(e6, x, !ltrAtCursor(e6))), selectLineBoundaryRight = (e6) => extendSel(e6, (x) => moveByLineBoundary(e6, x, ltrAtCursor(e6))), selectLineStart = (e6) => extendSel(e6, (x) => EditorSelection.cursor(e6.lineBlockAt(x.head).from)), selectLineEnd = (e6) => extendSel(e6, (x) => EditorSelection.cursor(e6.lineBlockAt(x.head).to)), cursorDocStart = ({ state: e6, dispatch: x }) => (x(setSel(e6, { anchor: 0 })), true), cursorDocEnd = ({ state: e6, dispatch: x }) => (x(setSel(e6, { anchor: e6.doc.length })), true), selectDocStart = ({ state: e6, dispatch: x }) => (x(setSel(e6, {
+  anchor: e6.selection.main.anchor,
+  head: 0
+})), true), selectDocEnd = ({ state: e6, dispatch: x }) => (x(setSel(e6, {
+  anchor: e6.selection.main.anchor,
+  head: e6.doc.length
+})), true), selectAll = ({ state: e6, dispatch: x }) => (x(e6.update({
+  selection: {
+    anchor: 0,
+    head: e6.doc.length
+  },
+  userEvent: "select"
+})), true), selectLine = ({ state: e6, dispatch: x }) => {
+  let S = selectedLineBlocks(e6).map(({ from: x2, to: S2 }) => EditorSelection.range(x2, Math.min(S2 + 1, e6.doc.length)));
+  return x(e6.update({
+    selection: EditorSelection.create(S),
+    userEvent: "select"
+  })), true;
+}, selectParentSyntax = ({ state: e6, dispatch: x }) => {
+  let S = updateSel(e6.selection, (x2) => {
+    let S2 = syntaxTree(e6), C = S2.resolveStack(x2.from, 1);
+    if (x2.empty) {
+      let e7 = S2.resolveStack(x2.from, -1);
+      e7.node.from >= C.node.from && e7.node.to <= C.node.to && (C = e7);
+    }
+    for (let e7 = C; e7; e7 = e7.next) {
+      let { node: S3 } = e7;
+      if ((S3.from < x2.from && S3.to >= x2.to || S3.to > x2.to && S3.from <= x2.from) && e7.next) return EditorSelection.range(S3.to, S3.from);
+    }
+    return x2;
+  });
+  return S.eq(e6.selection) ? false : (x(setSel(e6, S)), true);
+};
+function addCursorVertically(e6, x) {
+  let { state: S } = e6, C = S.selection, w = S.selection.ranges.slice();
+  for (let C2 of S.selection.ranges) {
+    let T = S.doc.lineAt(C2.head);
+    if (x ? T.to < e6.state.doc.length : T.from > 0) for (let S2 = C2; ; ) {
+      let C3 = e6.moveVertically(S2, x);
+      if (C3.head < T.from || C3.head > T.to) {
+        w.some((e7) => e7.head == C3.head) || w.push(C3);
+        break;
+      } else if (C3.head == S2.head) break;
+      else S2 = C3;
+    }
+  }
+  return w.length == C.ranges.length ? false : (e6.dispatch(setSel(S, EditorSelection.create(w, w.length - 1))), true);
+}
+var addCursorAbove = (e6) => addCursorVertically(e6, false), addCursorBelow = (e6) => addCursorVertically(e6, true), simplifySelection = ({ state: e6, dispatch: x }) => {
+  let S = e6.selection, C = null;
+  return S.ranges.length > 1 ? C = EditorSelection.create([S.main]) : S.main.empty || (C = EditorSelection.create([EditorSelection.cursor(S.main.head)])), C ? (x(setSel(e6, C)), true) : false;
+};
+function deleteBy(e6, x) {
+  if (e6.state.readOnly) return false;
+  let S = "delete.selection", { state: C } = e6, w = C.changeByRange((C2) => {
+    let { from: w2, to: T } = C2;
+    if (w2 == T) {
+      let E = x(C2);
+      E < w2 ? (S = "delete.backward", E = skipAtomic(e6, E, false)) : E > w2 && (S = "delete.forward", E = skipAtomic(e6, E, true)), w2 = Math.min(w2, E), T = Math.max(T, E);
+    } else w2 = skipAtomic(e6, w2, false), T = skipAtomic(e6, T, true);
+    return w2 == T ? { range: C2 } : {
+      changes: {
+        from: w2,
+        to: T
+      },
+      range: EditorSelection.cursor(w2, w2 < C2.head ? -1 : 1)
+    };
+  });
+  return w.changes.empty ? false : (e6.dispatch(C.update(w, {
+    scrollIntoView: true,
+    userEvent: S,
+    effects: S == "delete.selection" ? EditorView.announce.of(C.phrase("Selection deleted")) : void 0
+  })), true);
+}
+function skipAtomic(e6, x, S) {
+  if (e6 instanceof EditorView) for (let C of e6.state.facet(EditorView.atomicRanges).map((x2) => x2(e6))) C.between(x, x, (e7, C2) => {
+    e7 < x && C2 > x && (x = S ? C2 : e7);
+  });
+  return x;
+}
+var deleteByChar = (e6, x, S) => deleteBy(e6, (C) => {
+  let w = C.from, { state: T } = e6, E = T.doc.lineAt(w), D, O;
+  if (S && !x && w > E.from && w < E.from + 200 && !/[^ \t]/.test(D = E.text.slice(0, w - E.from))) {
+    if (D[D.length - 1] == "	") return w - 1;
+    let e7 = countColumn(D, T.tabSize) % getIndentUnit(T) || getIndentUnit(T);
+    for (let x2 = 0; x2 < e7 && D[D.length - 1 - x2] == " "; x2++) w--;
+    O = w;
+  } else O = findClusterBreak(E.text, w - E.from, x, x) + E.from, O == w && E.number != (x ? T.doc.lines : 1) ? O += x ? 1 : -1 : !x && /[\ufe00-\ufe0f]/.test(E.text.slice(O - E.from, w - E.from)) && (O = findClusterBreak(E.text, O - E.from, false, false) + E.from);
+  return O;
+}), deleteCharBackward = (e6) => deleteByChar(e6, false, true), deleteCharForward = (e6) => deleteByChar(e6, true, false), deleteByGroup = (e6, x) => deleteBy(e6, (S) => {
+  let C = S.head, { state: w } = e6, T = w.doc.lineAt(C), E = w.charCategorizer(C);
+  for (let e7 = null; ; ) {
+    if (C == (x ? T.to : T.from)) {
+      C == S.head && T.number != (x ? w.doc.lines : 1) && (C += x ? 1 : -1);
+      break;
+    }
+    let D = findClusterBreak(T.text, C - T.from, x) + T.from, O = T.text.slice(Math.min(C, D) - T.from, Math.max(C, D) - T.from), k = E(O);
+    if (e7 != null && k != e7) break;
+    (O != " " || C != S.head) && (e7 = k), C = D;
+  }
+  return C;
+}), deleteGroupBackward = (e6) => deleteByGroup(e6, false), deleteGroupForward = (e6) => deleteByGroup(e6, true), deleteToLineEnd = (e6) => deleteBy(e6, (x) => {
+  let S = e6.lineBlockAt(x.head).to;
+  return x.head < S ? S : Math.min(e6.state.doc.length, x.head + 1);
+}), deleteLineBoundaryBackward = (e6) => deleteBy(e6, (x) => {
+  let S = e6.moveToLineBoundary(x, false).head;
+  return x.head > S ? S : Math.max(0, x.head - 1);
+}), deleteLineBoundaryForward = (e6) => deleteBy(e6, (x) => {
+  let S = e6.moveToLineBoundary(x, true).head;
+  return x.head < S ? S : Math.min(e6.state.doc.length, x.head + 1);
+}), splitLine = ({ state: e6, dispatch: x }) => {
+  if (e6.readOnly) return false;
+  let S = e6.changeByRange((e7) => ({
+    changes: {
+      from: e7.from,
+      to: e7.to,
+      insert: Text.of(["", ""])
+    },
+    range: EditorSelection.cursor(e7.from)
+  }));
+  return x(e6.update(S, {
+    scrollIntoView: true,
+    userEvent: "input"
+  })), true;
+}, transposeChars = ({ state: e6, dispatch: x }) => {
+  if (e6.readOnly) return false;
+  let S = e6.changeByRange((x2) => {
+    if (!x2.empty || x2.from == 0 || x2.from == e6.doc.length) return { range: x2 };
+    let S2 = x2.from, C = e6.doc.lineAt(S2), w = S2 == C.from ? S2 - 1 : findClusterBreak(C.text, S2 - C.from, false) + C.from, T = S2 == C.to ? S2 + 1 : findClusterBreak(C.text, S2 - C.from, true) + C.from;
+    return {
+      changes: {
+        from: w,
+        to: T,
+        insert: e6.doc.slice(S2, T).append(e6.doc.slice(w, S2))
+      },
+      range: EditorSelection.cursor(T)
+    };
+  });
+  return S.changes.empty ? false : (x(e6.update(S, {
+    scrollIntoView: true,
+    userEvent: "move.character"
+  })), true);
+};
+function selectedLineBlocks(e6) {
+  let x = [], S = -1;
+  for (let C of e6.selection.ranges) {
+    let w = e6.doc.lineAt(C.from), T = e6.doc.lineAt(C.to);
+    if (!C.empty && C.to == T.from && (T = e6.doc.lineAt(C.to - 1)), S >= w.number) {
+      let e7 = x[x.length - 1];
+      e7.to = T.to, e7.ranges.push(C);
+    } else x.push({
+      from: w.from,
+      to: T.to,
+      ranges: [C]
+    });
+    S = T.number + 1;
+  }
+  return x;
+}
+function moveLine(e6, x, S) {
+  if (e6.readOnly) return false;
+  let C = [], w = [];
+  for (let x2 of selectedLineBlocks(e6)) {
+    if (S ? x2.to == e6.doc.length : x2.from == 0) continue;
+    let T = e6.doc.lineAt(S ? x2.to + 1 : x2.from - 1), E = T.length + 1;
+    if (S) {
+      C.push({
+        from: x2.to,
+        to: T.to
+      }, {
+        from: x2.from,
+        insert: T.text + e6.lineBreak
+      });
+      for (let S2 of x2.ranges) w.push(EditorSelection.range(Math.min(e6.doc.length, S2.anchor + E), Math.min(e6.doc.length, S2.head + E)));
+    } else {
+      C.push({
+        from: T.from,
+        to: x2.from
+      }, {
+        from: x2.to,
+        insert: e6.lineBreak + T.text
+      });
+      for (let e7 of x2.ranges) w.push(EditorSelection.range(e7.anchor - E, e7.head - E));
+    }
+  }
+  return C.length ? (x(e6.update({
+    changes: C,
+    scrollIntoView: true,
+    selection: EditorSelection.create(w, e6.selection.mainIndex),
+    userEvent: "move.line"
+  })), true) : false;
+}
+var moveLineUp = ({ state: e6, dispatch: x }) => moveLine(e6, x, false), moveLineDown = ({ state: e6, dispatch: x }) => moveLine(e6, x, true);
+function copyLine(e6, x, S) {
+  if (e6.readOnly) return false;
+  let C = [];
+  for (let x2 of selectedLineBlocks(e6)) S ? C.push({
+    from: x2.from,
+    insert: e6.doc.slice(x2.from, x2.to) + e6.lineBreak
+  }) : C.push({
+    from: x2.to,
+    insert: e6.lineBreak + e6.doc.slice(x2.from, x2.to)
+  });
+  let w = e6.changes(C);
+  return x(e6.update({
+    changes: w,
+    selection: e6.selection.map(w, S ? 1 : -1),
+    scrollIntoView: true,
+    userEvent: "input.copyline"
+  })), true;
+}
+var copyLineUp = ({ state: e6, dispatch: x }) => copyLine(e6, x, false), copyLineDown = ({ state: e6, dispatch: x }) => copyLine(e6, x, true), deleteLine = (e6) => {
+  if (e6.state.readOnly) return false;
+  let { state: x } = e6, S = x.changes(selectedLineBlocks(x).map(({ from: e7, to: S2 }) => (e7 > 0 ? e7-- : S2 < x.doc.length && S2++, {
+    from: e7,
+    to: S2
+  }))), C = updateSel(x.selection, (x2) => {
+    let S2;
+    if (e6.lineWrapping) {
+      let C2 = e6.lineBlockAt(x2.head), w = e6.coordsAtPos(x2.head, x2.assoc || 1);
+      w && (S2 = C2.bottom + e6.documentTop - w.bottom + e6.defaultLineHeight / 2);
+    }
+    return e6.moveVertically(x2, true, S2);
+  }).map(S);
+  return e6.dispatch({
+    changes: S,
+    selection: C,
+    scrollIntoView: true,
+    userEvent: "delete.line"
+  }), true;
+};
+function isBetweenBrackets(e6, x) {
+  if (/\(\)|\[\]|\{\}/.test(e6.sliceDoc(x - 1, x + 1))) return {
+    from: x,
+    to: x
+  };
+  let S = syntaxTree(e6).resolveInner(x), C = S.childBefore(x), w = S.childAfter(x), T;
+  return C && w && C.to <= x && w.from >= x && (T = C.type.prop(NodeProp.closedBy)) && T.indexOf(w.name) > -1 && e6.doc.lineAt(C.to).from == e6.doc.lineAt(w.from).from && !/\S/.test(e6.sliceDoc(C.to, w.from)) ? {
+    from: C.to,
+    to: w.from
+  } : null;
+}
+var insertNewlineAndIndent = /* @__PURE__ */ newlineAndIndent(false), insertBlankLine = /* @__PURE__ */ newlineAndIndent(true);
+function newlineAndIndent(e6) {
+  return ({ state: x, dispatch: S }) => {
+    if (x.readOnly) return false;
+    let C = x.changeByRange((S2) => {
+      let { from: C2, to: w } = S2, T = x.doc.lineAt(C2), E = !e6 && C2 == w && isBetweenBrackets(x, C2);
+      e6 && (C2 = w = (w <= T.to ? T : x.doc.lineAt(w)).to);
+      let D = new IndentContext(x, {
+        simulateBreak: C2,
+        simulateDoubleBreak: !!E
+      }), O = getIndentation(D, C2);
+      for (O ?? (O = countColumn(/^\s*/.exec(x.doc.lineAt(C2).text)[0], x.tabSize)); w < T.to && /\s/.test(T.text[w - T.from]); ) w++;
+      E ? { from: C2, to: w } = E : C2 > T.from && C2 < T.from + 100 && !/\S/.test(T.text.slice(0, C2)) && (C2 = T.from);
+      let k = ["", indentString(x, O)];
+      return E && k.push(indentString(x, D.lineIndent(T.from, -1))), {
+        changes: {
+          from: C2,
+          to: w,
+          insert: Text.of(k)
+        },
+        range: EditorSelection.cursor(C2 + 1 + k[1].length)
+      };
+    });
+    return S(x.update(C, {
+      scrollIntoView: true,
+      userEvent: "input"
+    })), true;
+  };
+}
+function changeBySelectedLine(e6, x) {
+  let S = -1;
+  return e6.changeByRange((C) => {
+    let w = [];
+    for (let T2 = C.from; T2 <= C.to; ) {
+      let E = e6.doc.lineAt(T2);
+      E.number > S && (C.empty || C.to > E.from) && (x(E, w, C), S = E.number), T2 = E.to + 1;
+    }
+    let T = e6.changes(w);
+    return {
+      changes: w,
+      range: EditorSelection.range(T.mapPos(C.anchor, 1), T.mapPos(C.head, 1))
+    };
+  });
+}
+var indentSelection = ({ state: e6, dispatch: x }) => {
+  if (e6.readOnly) return false;
+  let S = /* @__PURE__ */ Object.create(null), C = new IndentContext(e6, { overrideIndentation: (e7) => S[e7] ?? -1 }), w = changeBySelectedLine(e6, (x2, w2, T) => {
+    let E = getIndentation(C, x2.from);
+    if (E == null) return;
+    /\S/.test(x2.text) || (E = 0);
+    let D = /^\s*/.exec(x2.text)[0], O = indentString(e6, E);
+    (D != O || T.from < x2.from + D.length) && (S[x2.from] = E, w2.push({
+      from: x2.from,
+      to: x2.from + D.length,
+      insert: O
+    }));
+  });
+  return w.changes.empty || x(e6.update(w, { userEvent: "indent" })), true;
+}, indentMore = ({ state: e6, dispatch: x }) => e6.readOnly ? false : (x(e6.update(changeBySelectedLine(e6, (x2, S) => {
+  S.push({
+    from: x2.from,
+    insert: e6.facet(indentUnit)
+  });
+}), { userEvent: "input.indent" })), true), indentLess = ({ state: e6, dispatch: x }) => e6.readOnly ? false : (x(e6.update(changeBySelectedLine(e6, (x2, S) => {
+  let C = /^\s*/.exec(x2.text)[0];
+  if (!C) return;
+  let w = countColumn(C, e6.tabSize), T = 0, E = indentString(e6, Math.max(0, w - getIndentUnit(e6)));
+  for (; T < C.length && T < E.length && C.charCodeAt(T) == E.charCodeAt(T); ) T++;
+  S.push({
+    from: x2.from + T,
+    to: x2.from + C.length,
+    insert: E.slice(T)
+  });
+}), { userEvent: "delete.dedent" })), true), toggleTabFocusMode = (e6) => (e6.setTabFocusMode(), true), insertTab = ({ state: e6, dispatch: x }) => e6.selection.ranges.some((e7) => !e7.empty) ? indentMore({
+  state: e6,
+  dispatch: x
+}) : (x(e6.update(e6.replaceSelection("	"), {
+  scrollIntoView: true,
+  userEvent: "input"
+})), true), emacsStyleKeymap = [
+  {
+    key: "Ctrl-b",
+    run: cursorCharLeft,
+    shift: selectCharLeft,
+    preventDefault: true
+  },
+  {
+    key: "Ctrl-f",
+    run: cursorCharRight,
+    shift: selectCharRight
+  },
+  {
+    key: "Ctrl-p",
+    run: cursorLineUp,
+    shift: selectLineUp
+  },
+  {
+    key: "Ctrl-n",
+    run: cursorLineDown,
+    shift: selectLineDown
+  },
+  {
+    key: "Ctrl-a",
+    run: cursorLineStart,
+    shift: selectLineStart
+  },
+  {
+    key: "Ctrl-e",
+    run: cursorLineEnd,
+    shift: selectLineEnd
+  },
+  {
+    key: "Ctrl-d",
+    run: deleteCharForward
+  },
+  {
+    key: "Ctrl-h",
+    run: deleteCharBackward
+  },
+  {
+    key: "Ctrl-k",
+    run: deleteToLineEnd
+  },
+  {
+    key: "Ctrl-Alt-h",
+    run: deleteGroupBackward
+  },
+  {
+    key: "Ctrl-o",
+    run: splitLine
+  },
+  {
+    key: "Ctrl-t",
+    run: transposeChars
+  },
+  {
+    key: "Ctrl-v",
+    run: cursorPageDown
+  }
+], standardKeymap = /* @__PURE__ */ [
+  {
+    key: "ArrowLeft",
+    run: cursorCharLeft,
+    shift: selectCharLeft,
+    preventDefault: true
+  },
+  {
+    key: "Mod-ArrowLeft",
+    mac: "Alt-ArrowLeft",
+    run: cursorGroupLeft,
+    shift: selectGroupLeft,
+    preventDefault: true
+  },
+  {
+    mac: "Cmd-ArrowLeft",
+    run: cursorLineBoundaryLeft,
+    shift: selectLineBoundaryLeft,
+    preventDefault: true
+  },
+  {
+    key: "ArrowRight",
+    run: cursorCharRight,
+    shift: selectCharRight,
+    preventDefault: true
+  },
+  {
+    key: "Mod-ArrowRight",
+    mac: "Alt-ArrowRight",
+    run: cursorGroupRight,
+    shift: selectGroupRight,
+    preventDefault: true
+  },
+  {
+    mac: "Cmd-ArrowRight",
+    run: cursorLineBoundaryRight,
+    shift: selectLineBoundaryRight,
+    preventDefault: true
+  },
+  {
+    key: "ArrowUp",
+    run: cursorLineUp,
+    shift: selectLineUp,
+    preventDefault: true
+  },
+  {
+    mac: "Cmd-ArrowUp",
+    run: cursorDocStart,
+    shift: selectDocStart
+  },
+  {
+    mac: "Ctrl-ArrowUp",
+    run: cursorPageUp,
+    shift: selectPageUp
+  },
+  {
+    key: "ArrowDown",
+    run: cursorLineDown,
+    shift: selectLineDown,
+    preventDefault: true
+  },
+  {
+    mac: "Cmd-ArrowDown",
+    run: cursorDocEnd,
+    shift: selectDocEnd
+  },
+  {
+    mac: "Ctrl-ArrowDown",
+    run: cursorPageDown,
+    shift: selectPageDown
+  },
+  {
+    key: "PageUp",
+    run: cursorPageUp,
+    shift: selectPageUp
+  },
+  {
+    key: "PageDown",
+    run: cursorPageDown,
+    shift: selectPageDown
+  },
+  {
+    key: "Home",
+    run: cursorLineBoundaryBackward,
+    shift: selectLineBoundaryBackward,
+    preventDefault: true
+  },
+  {
+    key: "Mod-Home",
+    run: cursorDocStart,
+    shift: selectDocStart
+  },
+  {
+    key: "End",
+    run: cursorLineBoundaryForward,
+    shift: selectLineBoundaryForward,
+    preventDefault: true
+  },
+  {
+    key: "Mod-End",
+    run: cursorDocEnd,
+    shift: selectDocEnd
+  },
+  {
+    key: "Enter",
+    run: insertNewlineAndIndent,
+    shift: insertNewlineAndIndent
+  },
+  {
+    key: "Mod-a",
+    run: selectAll
+  },
+  {
+    key: "Backspace",
+    run: deleteCharBackward,
+    shift: deleteCharBackward,
+    preventDefault: true
+  },
+  {
+    key: "Delete",
+    run: deleteCharForward,
+    preventDefault: true
+  },
+  {
+    key: "Mod-Backspace",
+    mac: "Alt-Backspace",
+    run: deleteGroupBackward,
+    preventDefault: true
+  },
+  {
+    key: "Mod-Delete",
+    mac: "Alt-Delete",
+    run: deleteGroupForward,
+    preventDefault: true
+  },
+  {
+    mac: "Mod-Backspace",
+    run: deleteLineBoundaryBackward,
+    preventDefault: true
+  },
+  {
+    mac: "Mod-Delete",
+    run: deleteLineBoundaryForward,
+    preventDefault: true
+  }
+].concat(/* @__PURE__ */ emacsStyleKeymap.map((e6) => ({
+  mac: e6.key,
+  run: e6.run,
+  shift: e6.shift
+}))), defaultKeymap = /* @__PURE__ */ [
+  {
+    key: "Alt-ArrowLeft",
+    mac: "Ctrl-ArrowLeft",
+    run: cursorSyntaxLeft,
+    shift: selectSyntaxLeft
+  },
+  {
+    key: "Alt-ArrowRight",
+    mac: "Ctrl-ArrowRight",
+    run: cursorSyntaxRight,
+    shift: selectSyntaxRight
+  },
+  {
+    key: "Alt-ArrowUp",
+    run: moveLineUp
+  },
+  {
+    key: "Shift-Alt-ArrowUp",
+    run: copyLineUp
+  },
+  {
+    key: "Alt-ArrowDown",
+    run: moveLineDown
+  },
+  {
+    key: "Shift-Alt-ArrowDown",
+    run: copyLineDown
+  },
+  {
+    key: "Mod-Alt-ArrowUp",
+    run: addCursorAbove
+  },
+  {
+    key: "Mod-Alt-ArrowDown",
+    run: addCursorBelow
+  },
+  {
+    key: "Escape",
+    run: simplifySelection
+  },
+  {
+    key: "Mod-Enter",
+    run: insertBlankLine
+  },
+  {
+    key: "Alt-l",
+    mac: "Ctrl-l",
+    run: selectLine
+  },
+  {
+    key: "Mod-i",
+    run: selectParentSyntax,
+    preventDefault: true
+  },
+  {
+    key: "Mod-[",
+    run: indentLess
+  },
+  {
+    key: "Mod-]",
+    run: indentMore
+  },
+  {
+    key: "Mod-Alt-\\",
+    run: indentSelection
+  },
+  {
+    key: "Shift-Mod-k",
+    run: deleteLine
+  },
+  {
+    key: "Shift-Mod-\\",
+    run: cursorMatchingBracket
+  },
+  {
+    key: "Mod-/",
+    run: toggleComment
+  },
+  {
+    key: "Alt-A",
+    run: toggleBlockComment
+  },
+  {
+    key: "Ctrl-m",
+    mac: "Shift-Alt-m",
+    run: toggleTabFocusMode
+  }
+].concat(standardKeymap), indentWithTab = {
+  key: "Tab",
+  run: indentMore,
+  shift: indentLess
+}, SelectedDiagnostic = class {
+  constructor(e6, x, S) {
+    this.from = e6, this.to = x, this.diagnostic = S;
+  }
+}, LintState = class e3 {
+  constructor(e6, x, S) {
+    this.diagnostics = e6, this.panel = x, this.selected = S;
+  }
+  static init(x, S, C) {
+    let w = C.facet(lintConfig).markerFilter;
+    w && (x = w(x, C));
+    let T = x.slice().sort((e6, x2) => e6.from - x2.from || e6.to - x2.to), E = new RangeSetBuilder(), D = [], O = 0, k = C.doc.iter(), A = 0, j = C.doc.length;
+    for (let e6 = 0; ; ) {
+      let x2 = e6 == T.length ? null : T[e6];
+      if (!x2 && !D.length) break;
+      let S2, C2;
+      if (D.length) S2 = O, C2 = D.reduce((e7, x3) => Math.min(e7, x3.to), x2 && x2.from > S2 ? x2.from : 1e8);
+      else {
+        if (S2 = x2.from, S2 > j) break;
+        C2 = x2.to, D.push(x2), e6++;
+      }
+      for (; e6 < T.length; ) {
+        let x3 = T[e6];
+        if (x3.from == S2 && (x3.to > x3.from || x3.to == S2)) D.push(x3), e6++, C2 = Math.min(x3.to, C2);
+        else {
+          C2 = Math.min(x3.from, C2);
+          break;
+        }
+      }
+      C2 = Math.min(C2, j);
+      let w2 = false;
+      if (D.some((e7) => e7.from == S2 && (e7.to == C2 || C2 == j)) && (w2 = S2 == C2, !w2 && C2 - S2 < 10)) {
+        let e7 = S2 - (A + k.value.length);
+        e7 > 0 && (k.next(e7), A = S2);
+        for (let e8 = S2; ; ) {
+          if (e8 >= C2) {
+            w2 = true;
+            break;
+          }
+          if (!k.lineBreak && A + k.value.length > e8) break;
+          e8 = A + k.value.length, A += k.value.length, k.next();
+        }
+      }
+      let M2 = maxSeverity(D);
+      if (w2) E.add(S2, S2, Decoration.widget({
+        widget: new DiagnosticWidget(M2),
+        diagnostics: D.slice()
+      }));
+      else {
+        let e7 = D.reduce((e8, x3) => x3.markClass ? e8 + " " + x3.markClass : e8, "");
+        E.add(S2, C2, Decoration.mark({
+          class: "cm-lintRange cm-lintRange-" + M2 + e7,
+          diagnostics: D.slice(),
+          inclusiveEnd: D.some((e8) => e8.to > C2)
+        }));
+      }
+      if (O = C2, O == j) break;
+      for (let e7 = 0; e7 < D.length; e7++) D[e7].to <= O && D.splice(e7--, 1);
+    }
+    let M = E.finish();
+    return new e3(M, S, findDiagnostic(M));
+  }
+};
+function findDiagnostic(e6, x = null, S = 0) {
+  let C = null;
+  return e6.between(S, 1e9, (e7, S2, { spec: w }) => {
+    if (!(x && w.diagnostics.indexOf(x) < 0)) if (!C) C = new SelectedDiagnostic(e7, S2, x || w.diagnostics[0]);
+    else if (w.diagnostics.indexOf(C.diagnostic) < 0) return false;
+    else C = new SelectedDiagnostic(C.from, S2, C.diagnostic);
+  }), C;
+}
+function hideTooltip(e6, x) {
+  let S = x.pos, C = x.end || S, w = e6.state.facet(lintConfig).hideOn(e6, S, C);
+  if (w != null) return w;
+  let T = e6.startState.doc.lineAt(x.pos);
+  return !!(e6.effects.some((e7) => e7.is(setDiagnosticsEffect)) || e6.changes.touchesRange(T.from, Math.max(T.to, C)));
+}
+function maybeEnableLint(e6, x) {
+  return e6.field(lintState, false) ? x : x.concat(StateEffect.appendConfig.of(lintExtensions));
+}
+function setDiagnostics(e6, x) {
+  return { effects: maybeEnableLint(e6, [setDiagnosticsEffect.of(x)]) };
+}
+var setDiagnosticsEffect = /* @__PURE__ */ StateEffect.define(), togglePanel$1 = /* @__PURE__ */ StateEffect.define(), movePanelSelection = /* @__PURE__ */ StateEffect.define(), lintState = /* @__PURE__ */ StateField.define({
+  create() {
+    return new LintState(Decoration.none, null, null);
+  },
+  update(e6, x) {
+    if (x.docChanged && e6.diagnostics.size) {
+      let S = e6.diagnostics.map(x.changes), C = null, w = e6.panel;
+      if (e6.selected) {
+        let w2 = x.changes.mapPos(e6.selected.from, 1);
+        C = findDiagnostic(S, e6.selected.diagnostic, w2) || findDiagnostic(S, null, w2);
+      }
+      !S.size && w && x.state.facet(lintConfig).autoPanel && (w = null), e6 = new LintState(S, w, C);
+    }
+    for (let S of x.effects) if (S.is(setDiagnosticsEffect)) {
+      let C = x.state.facet(lintConfig).autoPanel ? S.value.length ? LintPanel.open : null : e6.panel;
+      e6 = LintState.init(S.value, C, x.state);
+    } else S.is(togglePanel$1) ? e6 = new LintState(e6.diagnostics, S.value ? LintPanel.open : null, e6.selected) : S.is(movePanelSelection) && (e6 = new LintState(e6.diagnostics, e6.panel, S.value));
+    return e6;
+  },
+  provide: (e6) => [showPanel.from(e6, (e7) => e7.panel), EditorView.decorations.from(e6, (e7) => e7.diagnostics)]
+}), activeMark = /* @__PURE__ */ Decoration.mark({ class: "cm-lintRange cm-lintRange-active" });
+function lintTooltip(e6, x, S) {
+  let { diagnostics: C } = e6.state.field(lintState), w, T = -1, E = -1;
+  C.between(x - (S < 0 ? 1 : 0), x + (S > 0 ? 1 : 0), (e7, C2, { spec: D2 }) => {
+    if (x >= e7 && x <= C2 && (e7 == C2 || (x > e7 || S > 0) && (x < C2 || S < 0))) return w = D2.diagnostics, T = e7, E = C2, false;
+  });
+  let D = e6.state.facet(lintConfig).tooltipFilter;
+  return w && D && (w = D(w, e6.state)), w ? {
+    pos: T,
+    end: E,
+    above: e6.state.doc.lineAt(T).to < E,
+    create() {
+      return { dom: diagnosticsTooltip(e6, w) };
+    }
+  } : null;
+}
+function diagnosticsTooltip(e6, x) {
+  return crelt("ul", { class: "cm-tooltip-lint" }, x.map((x2) => renderDiagnostic(e6, x2, false)));
+}
+var openLintPanel = (e6) => {
+  let x = e6.state.field(lintState, false);
+  (!x || !x.panel) && e6.dispatch({ effects: maybeEnableLint(e6.state, [togglePanel$1.of(true)]) });
+  let S = getPanel(e6, LintPanel.open);
+  return S && S.dom.querySelector(".cm-panel-lint ul").focus(), true;
+}, closeLintPanel = (e6) => {
+  let x = e6.state.field(lintState, false);
+  return !x || !x.panel ? false : (e6.dispatch({ effects: togglePanel$1.of(false) }), true);
+}, lintKeymap = [{
+  key: "Mod-Shift-m",
+  run: openLintPanel,
+  preventDefault: true
+}, {
+  key: "F8",
+  run: (e6) => {
+    let x = e6.state.field(lintState, false);
+    if (!x) return false;
+    let S = e6.state.selection.main, C = findDiagnostic(x.diagnostics, null, S.to + 1);
+    return !C && (C = findDiagnostic(x.diagnostics, null, 0), !C || C.from == S.from && C.to == S.to) ? false : (e6.dispatch({
+      selection: {
+        anchor: C.from,
+        head: C.to
+      },
+      scrollIntoView: true
+    }), true);
+  }
+}], lintPlugin = /* @__PURE__ */ ViewPlugin.fromClass(class {
+  constructor(e6) {
+    this.view = e6, this.timeout = -1, this.set = true;
+    let { delay: x } = e6.state.facet(lintConfig);
+    this.lintTime = Date.now() + x, this.run = this.run.bind(this), this.timeout = setTimeout(this.run, x);
+  }
+  run() {
+    clearTimeout(this.timeout);
+    let e6 = Date.now();
+    if (e6 < this.lintTime - 10) this.timeout = setTimeout(this.run, this.lintTime - e6);
+    else {
+      this.set = false;
+      let { state: e7 } = this.view, { sources: x } = e7.facet(lintConfig);
+      x.length && batchResults(x.map((e8) => Promise.resolve(e8(this.view))), (x2) => {
+        this.view.state.doc == e7.doc && this.view.dispatch(setDiagnostics(this.view.state, x2.reduce((e8, x3) => e8.concat(x3))));
+      }, (e8) => {
+        logException(this.view.state, e8);
+      });
+    }
+  }
+  update(e6) {
+    let x = e6.state.facet(lintConfig);
+    (e6.docChanged || x != e6.startState.facet(lintConfig) || x.needsRefresh && x.needsRefresh(e6)) && (this.lintTime = Date.now() + x.delay, this.set || (this.set = true, this.timeout = setTimeout(this.run, x.delay)));
+  }
+  force() {
+    this.set && (this.lintTime = Date.now(), this.run());
+  }
+  destroy() {
+    clearTimeout(this.timeout);
+  }
+});
+function batchResults(e6, x, S) {
+  let C = [], w = -1;
+  for (let T of e6) T.then((S2) => {
+    C.push(S2), clearTimeout(w), C.length == e6.length ? x(C) : w = setTimeout(() => x(C), 200);
+  }, S);
+}
+var lintConfig = /* @__PURE__ */ Facet.define({ combine(e6) {
+  return {
+    sources: e6.map((e7) => e7.source).filter((e7) => e7 != null),
+    ...combineConfig(e6.map((e7) => e7.config), {
+      delay: 750,
+      markerFilter: null,
+      tooltipFilter: null,
+      needsRefresh: null,
+      hideOn: () => null
+    }, {
+      delay: Math.max,
+      markerFilter: combineFilter,
+      tooltipFilter: combineFilter,
+      needsRefresh: (e7, x) => e7 ? x ? (S) => e7(S) || x(S) : e7 : x,
+      hideOn: (e7, x) => e7 ? x ? (S, C, w) => e7(S, C, w) || x(S, C, w) : e7 : x,
+      autoPanel: (e7, x) => e7 || x
+    })
+  };
+} });
+function combineFilter(e6, x) {
+  return e6 ? x ? (S, C) => x(e6(S, C), C) : e6 : x;
+}
+function linter(e6, x = {}) {
+  return [
+    lintConfig.of({
+      source: e6,
+      config: x
+    }),
+    lintPlugin,
+    lintExtensions
+  ];
+}
+function assignKeys(e6) {
+  let x = [];
+  if (e6) actions: for (let { name: S } of e6) {
+    for (let e7 = 0; e7 < S.length; e7++) {
+      let C = S[e7];
+      if (/[a-zA-Z]/.test(C) && !x.some((e8) => e8.toLowerCase() == C.toLowerCase())) {
+        x.push(C);
+        continue actions;
+      }
+    }
+    x.push("");
+  }
+  return x;
+}
+function renderDiagnostic(e6, x, S) {
+  var _a;
+  let C = S ? assignKeys(x.actions) : [];
+  return crelt("li", { class: "cm-diagnostic cm-diagnostic-" + x.severity }, crelt("span", { class: "cm-diagnosticText" }, x.renderMessage ? x.renderMessage(e6) : x.message), (_a = x.actions) == null ? void 0 : _a.map((S2, w) => {
+    let T = false, E = (C2) => {
+      if (C2.preventDefault(), T) return;
+      T = true;
+      let w2 = findDiagnostic(e6.state.field(lintState).diagnostics, x);
+      w2 && S2.apply(e6, w2.from, w2.to);
+    }, { name: D } = S2, O = C[w] ? D.indexOf(C[w]) : -1, k = O < 0 ? D : [
+      D.slice(0, O),
+      crelt("u", D.slice(O, O + 1)),
+      D.slice(O + 1)
+    ];
+    return crelt("button", {
+      type: "button",
+      class: "cm-diagnosticAction" + (S2.markClass ? " " + S2.markClass : ""),
+      onclick: E,
+      onmousedown: E,
+      "aria-label": ` Action: ${D}${O < 0 ? "" : ` (access key "${C[w]})"`}.`
+    }, k);
+  }), x.source && crelt("div", { class: "cm-diagnosticSource" }, x.source));
+}
+var DiagnosticWidget = class extends WidgetType {
+  constructor(e6) {
+    super(), this.sev = e6;
+  }
+  eq(e6) {
+    return e6.sev == this.sev;
+  }
+  toDOM() {
+    return crelt("span", { class: "cm-lintPoint cm-lintPoint-" + this.sev });
+  }
+}, PanelItem = class {
+  constructor(e6, x) {
+    this.diagnostic = x, this.id = "item_" + Math.floor(Math.random() * 4294967295).toString(16), this.dom = renderDiagnostic(e6, x, true), this.dom.id = this.id, this.dom.setAttribute("role", "option");
+  }
+}, LintPanel = class e4 {
+  constructor(e6) {
+    this.view = e6, this.items = [];
+    let x = (x2) => {
+      if (!(x2.ctrlKey || x2.altKey || x2.metaKey)) {
+        if (x2.keyCode == 27) closeLintPanel(this.view), this.view.focus();
+        else if (x2.keyCode == 38 || x2.keyCode == 33) this.moveSelection((this.selectedIndex - 1 + this.items.length) % this.items.length);
+        else if (x2.keyCode == 40 || x2.keyCode == 34) this.moveSelection((this.selectedIndex + 1) % this.items.length);
+        else if (x2.keyCode == 36) this.moveSelection(0);
+        else if (x2.keyCode == 35) this.moveSelection(this.items.length - 1);
+        else if (x2.keyCode == 13) this.view.focus();
+        else if (x2.keyCode >= 65 && x2.keyCode <= 90 && this.selectedIndex >= 0) {
+          let { diagnostic: S2 } = this.items[this.selectedIndex], C = assignKeys(S2.actions);
+          for (let w = 0; w < C.length; w++) if (C[w].toUpperCase().charCodeAt(0) == x2.keyCode) {
+            let x3 = findDiagnostic(this.view.state.field(lintState).diagnostics, S2);
+            x3 && S2.actions[w].apply(e6, x3.from, x3.to);
+          }
+        } else return;
+        x2.preventDefault();
+      }
+    }, S = (e7) => {
+      for (let x2 = 0; x2 < this.items.length; x2++) this.items[x2].dom.contains(e7.target) && this.moveSelection(x2);
+    };
+    this.list = crelt("ul", {
+      tabIndex: 0,
+      role: "listbox",
+      "aria-label": this.view.state.phrase("Diagnostics"),
+      onkeydown: x,
+      onclick: S
+    }), this.dom = crelt("div", { class: "cm-panel-lint" }, this.list, crelt("button", {
+      type: "button",
+      name: "close",
+      "aria-label": this.view.state.phrase("close"),
+      onclick: () => closeLintPanel(this.view)
+    }, "\xD7")), this.update();
+  }
+  get selectedIndex() {
+    let e6 = this.view.state.field(lintState).selected;
+    if (!e6) return -1;
+    for (let x = 0; x < this.items.length; x++) if (this.items[x].diagnostic == e6.diagnostic) return x;
+    return -1;
+  }
+  update() {
+    let { diagnostics: e6, selected: x } = this.view.state.field(lintState), S = 0, C = false, w = null, T = /* @__PURE__ */ new Set();
+    for (e6.between(0, this.view.state.doc.length, (e7, E, { spec: D }) => {
+      for (let e8 of D.diagnostics) {
+        if (T.has(e8)) continue;
+        T.add(e8);
+        let E2 = -1, D2;
+        for (let x2 = S; x2 < this.items.length; x2++) if (this.items[x2].diagnostic == e8) {
+          E2 = x2;
+          break;
+        }
+        E2 < 0 ? (D2 = new PanelItem(this.view, e8), this.items.splice(S, 0, D2), C = true) : (D2 = this.items[E2], E2 > S && (this.items.splice(S, E2 - S), C = true)), x && D2.diagnostic == x.diagnostic ? D2.dom.hasAttribute("aria-selected") || (D2.dom.setAttribute("aria-selected", "true"), w = D2) : D2.dom.hasAttribute("aria-selected") && D2.dom.removeAttribute("aria-selected"), S++;
+      }
+    }); S < this.items.length && !(this.items.length == 1 && this.items[0].diagnostic.from < 0); ) C = true, this.items.pop();
+    this.items.length == 0 && (this.items.push(new PanelItem(this.view, {
+      from: -1,
+      to: -1,
+      severity: "info",
+      message: this.view.state.phrase("No diagnostics")
+    })), C = true), w ? (this.list.setAttribute("aria-activedescendant", w.id), this.view.requestMeasure({
+      key: this,
+      read: () => ({
+        sel: w.dom.getBoundingClientRect(),
+        panel: this.list.getBoundingClientRect()
+      }),
+      write: ({ sel: e7, panel: x2 }) => {
+        let S2 = x2.height / this.list.offsetHeight;
+        e7.top < x2.top ? this.list.scrollTop -= (x2.top - e7.top) / S2 : e7.bottom > x2.bottom && (this.list.scrollTop += (e7.bottom - x2.bottom) / S2);
+      }
+    })) : this.selectedIndex < 0 && this.list.removeAttribute("aria-activedescendant"), C && this.sync();
+  }
+  sync() {
+    let e6 = this.list.firstChild;
+    function x() {
+      let x2 = e6;
+      e6 = x2.nextSibling, x2.remove();
+    }
+    for (let S of this.items) if (S.dom.parentNode == this.list) {
+      for (; e6 != S.dom; ) x();
+      e6 = S.dom.nextSibling;
+    } else this.list.insertBefore(S.dom, e6);
+    for (; e6; ) x();
+  }
+  moveSelection(e6) {
+    if (this.selectedIndex < 0) return;
+    let x = findDiagnostic(this.view.state.field(lintState).diagnostics, this.items[e6].diagnostic);
+    x && this.view.dispatch({
+      selection: {
+        anchor: x.from,
+        head: x.to
+      },
+      scrollIntoView: true,
+      effects: movePanelSelection.of(x)
+    });
+  }
+  static open(x) {
+    return new e4(x);
+  }
+};
+function svg(e6, x = 'viewBox="0 0 40 40"') {
+  return `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" ${x}>${encodeURIComponent(e6)}</svg>')`;
+}
+function underline(e6) {
+  return svg(`<path d="m0 2.5 l2 -1.5 l1 0 l2 1.5 l1 0" stroke="${e6}" fill="none" stroke-width=".7"/>`, 'width="6" height="3"');
+}
+var baseTheme$1 = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-diagnostic": {
+    padding: "3px 6px 3px 8px",
+    marginLeft: "-1px",
+    display: "block",
+    whiteSpace: "pre-wrap"
+  },
+  ".cm-diagnostic-error": { borderLeft: "5px solid #d11" },
+  ".cm-diagnostic-warning": { borderLeft: "5px solid orange" },
+  ".cm-diagnostic-info": { borderLeft: "5px solid #999" },
+  ".cm-diagnostic-hint": { borderLeft: "5px solid #66d" },
+  ".cm-diagnosticAction": {
+    font: "inherit",
+    border: "none",
+    padding: "2px 4px",
+    backgroundColor: "#444",
+    color: "white",
+    borderRadius: "3px",
+    marginLeft: "8px",
+    cursor: "pointer"
+  },
+  ".cm-diagnosticSource": {
+    fontSize: "70%",
+    opacity: 0.7
+  },
+  ".cm-lintRange": {
+    backgroundPosition: "left bottom",
+    backgroundRepeat: "repeat-x",
+    paddingBottom: "0.7px"
+  },
+  ".cm-lintRange-error": { backgroundImage: /* @__PURE__ */ underline("#d11") },
+  ".cm-lintRange-warning": { backgroundImage: /* @__PURE__ */ underline("orange") },
+  ".cm-lintRange-info": { backgroundImage: /* @__PURE__ */ underline("#999") },
+  ".cm-lintRange-hint": { backgroundImage: /* @__PURE__ */ underline("#66d") },
+  ".cm-lintRange-active": { backgroundColor: "#ffdd9980" },
+  ".cm-tooltip-lint": {
+    padding: 0,
+    margin: 0
+  },
+  ".cm-lintPoint": {
+    position: "relative",
+    "&:after": {
+      content: '""',
+      position: "absolute",
+      bottom: 0,
+      left: "-2px",
+      borderLeft: "3px solid transparent",
+      borderRight: "3px solid transparent",
+      borderBottom: "4px solid #d11"
+    }
+  },
+  ".cm-lintPoint-warning": { "&:after": { borderBottomColor: "orange" } },
+  ".cm-lintPoint-info": { "&:after": { borderBottomColor: "#999" } },
+  ".cm-lintPoint-hint": { "&:after": { borderBottomColor: "#66d" } },
+  ".cm-panel.cm-panel-lint": {
+    position: "relative",
+    "& ul": {
+      maxHeight: "100px",
+      overflowY: "auto",
+      "& [aria-selected]": {
+        backgroundColor: "#ddd",
+        "& u": { textDecoration: "underline" }
+      },
+      "&:focus [aria-selected]": {
+        background_fallback: "#bdf",
+        backgroundColor: "Highlight",
+        color_fallback: "white",
+        color: "HighlightText"
+      },
+      "& u": { textDecoration: "none" },
+      padding: 0,
+      margin: 0
+    },
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      right: "2px",
+      background: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: 0,
+      margin: 0
+    }
+  },
+  "&dark .cm-lintRange-active": { backgroundColor: "#86714a80" },
+  "&dark .cm-panel.cm-panel-lint ul": { "& [aria-selected]": { backgroundColor: "#2e343e" } }
+});
+function severityWeight(e6) {
+  return e6 == "error" ? 4 : e6 == "warning" ? 3 : e6 == "info" ? 2 : 1;
+}
+function maxSeverity(e6) {
+  let x = "hint", S = 1;
+  for (let C of e6) {
+    let e7 = severityWeight(C.severity);
+    e7 > S && (S = e7, x = C.severity);
+  }
+  return x;
+}
+var lintExtensions = [
+  lintState,
+  /* @__PURE__ */ EditorView.decorations.compute([lintState], (e6) => {
+    let { selected: x, panel: S } = e6.field(lintState);
+    return !x || !S || x.from == x.to ? Decoration.none : Decoration.set([activeMark.range(x.from, x.to)]);
+  }),
+  /* @__PURE__ */ hoverTooltip(lintTooltip, { hideOn: hideTooltip }),
+  baseTheme$1
+];
+function forEachDiagnostic(e6, x) {
+  let S = e6.field(lintState, false);
+  if (S && S.diagnostics.size) {
+    let e7 = [], C = [], w = -1;
+    for (let T = RangeSet.iter([S.diagnostics]); ; T.next()) {
+      for (let S2 = 0; S2 < e7.length; S2++) (!T.value || T.value.spec.diagnostics.indexOf(e7[S2]) < 0) && (x(e7[S2], C[S2], w), e7.splice(S2, 1), C.splice(S2--, 1));
+      if (!T.value) break;
+      for (let x2 of T.value.spec.diagnostics) e7.indexOf(x2) < 0 && (e7.push(x2), C.push(T.from));
+      w = T.to;
+    }
+  }
+}
+var basicNormalize = typeof String.prototype.normalize == "function" ? (e6) => e6.normalize("NFKD") : (e6) => e6, SearchCursor = class {
+  constructor(e6, x, S = 0, C = e6.length, w, T) {
+    this.test = T, this.value = {
+      from: 0,
+      to: 0
+    }, this.done = false, this.matches = [], this.buffer = "", this.bufferPos = 0, this.iter = e6.iterRange(S, C), this.bufferStart = S, this.normalize = w ? (e7) => w(basicNormalize(e7)) : basicNormalize, this.query = this.normalize(x);
+  }
+  peek() {
+    if (this.bufferPos == this.buffer.length) {
+      if (this.bufferStart += this.buffer.length, this.iter.next(), this.iter.done) return -1;
+      this.bufferPos = 0, this.buffer = this.iter.value;
+    }
+    return codePointAt(this.buffer, this.bufferPos);
+  }
+  next() {
+    for (; this.matches.length; ) this.matches.pop();
+    return this.nextOverlapping();
+  }
+  nextOverlapping() {
+    for (; ; ) {
+      let e6 = this.peek();
+      if (e6 < 0) return this.done = true, this;
+      let x = fromCodePoint(e6), S = this.bufferStart + this.bufferPos;
+      this.bufferPos += codePointSize(e6);
+      let C = this.normalize(x);
+      if (C.length) for (let e7 = 0, w = S; ; e7++) {
+        let T = C.charCodeAt(e7), E = this.match(T, w, this.bufferPos + this.bufferStart);
+        if (e7 == C.length - 1) {
+          if (E) return this.value = E, this;
+          break;
+        }
+        w == S && e7 < x.length && x.charCodeAt(e7) == T && w++;
+      }
+    }
+  }
+  match(e6, x, S) {
+    let C = null;
+    for (let x2 = 0; x2 < this.matches.length; x2 += 2) {
+      let w = this.matches[x2], T = false;
+      this.query.charCodeAt(w) == e6 && (w == this.query.length - 1 ? C = {
+        from: this.matches[x2 + 1],
+        to: S
+      } : (this.matches[x2]++, T = true)), T || (this.matches.splice(x2, 2), x2 -= 2);
+    }
+    return this.query.charCodeAt(0) == e6 && (this.query.length == 1 ? C = {
+      from: x,
+      to: S
+    } : this.matches.push(1, x)), C && this.test && !this.test(C.from, C.to, this.buffer, this.bufferStart) && (C = null), C;
+  }
+};
+typeof Symbol < "u" && (SearchCursor.prototype[Symbol.iterator] = function() {
+  return this;
+});
+var empty = {
+  from: -1,
+  to: -1,
+  match: /* @__PURE__ */ /.*/.exec("")
+}, baseFlags = "gm" + (/x/.unicode == null ? "" : "u"), RegExpCursor = class {
+  constructor(e6, x, S, C = 0, w = e6.length) {
+    if (this.text = e6, this.to = w, this.curLine = "", this.done = false, this.value = empty, /\\[sWDnr]|\n|\r|\[\^/.test(x)) return new MultilineRegExpCursor(e6, x, S, C, w);
+    this.re = new RegExp(x, baseFlags + ((S == null ? void 0 : S.ignoreCase) ? "i" : "")), this.test = S == null ? void 0 : S.test, this.iter = e6.iter(), this.curLineStart = e6.lineAt(C).from, this.matchPos = toCharEnd(e6, C), this.getLine(this.curLineStart);
+  }
+  getLine(e6) {
+    this.iter.next(e6), this.iter.lineBreak ? this.curLine = "" : (this.curLine = this.iter.value, this.curLineStart + this.curLine.length > this.to && (this.curLine = this.curLine.slice(0, this.to - this.curLineStart)), this.iter.next());
+  }
+  nextLine() {
+    this.curLineStart = this.curLineStart + this.curLine.length + 1, this.curLineStart > this.to ? this.curLine = "" : this.getLine(0);
+  }
+  next() {
+    for (let e6 = this.matchPos - this.curLineStart; ; ) {
+      this.re.lastIndex = e6;
+      let x = this.matchPos <= this.to && this.re.exec(this.curLine);
+      if (x) {
+        let S = this.curLineStart + x.index, C = S + x[0].length;
+        if (this.matchPos = toCharEnd(this.text, C + (S == C ? 1 : 0)), S == this.curLineStart + this.curLine.length && this.nextLine(), (S < C || S > this.value.to) && (!this.test || this.test(S, C, x))) return this.value = {
+          from: S,
+          to: C,
+          match: x
+        }, this;
+        e6 = this.matchPos - this.curLineStart;
+      } else if (this.curLineStart + this.curLine.length < this.to) this.nextLine(), e6 = 0;
+      else return this.done = true, this;
+    }
+  }
+}, flattened = /* @__PURE__ */ new WeakMap(), FlattenedDoc = class e5 {
+  constructor(e6, x) {
+    this.from = e6, this.text = x;
+  }
+  get to() {
+    return this.from + this.text.length;
+  }
+  static get(x, S, C) {
+    let w = flattened.get(x);
+    if (!w || w.from >= C || w.to <= S) {
+      let w2 = new e5(S, x.sliceString(S, C));
+      return flattened.set(x, w2), w2;
+    }
+    if (w.from == S && w.to == C) return w;
+    let { text: T, from: E } = w;
+    return E > S && (T = x.sliceString(S, E) + T, E = S), w.to < C && (T += x.sliceString(w.to, C)), flattened.set(x, new e5(E, T)), new e5(S, T.slice(S - E, C - E));
+  }
+}, MultilineRegExpCursor = class {
+  constructor(e6, x, S, C, w) {
+    this.text = e6, this.to = w, this.done = false, this.value = empty, this.matchPos = toCharEnd(e6, C), this.re = new RegExp(x, baseFlags + ((S == null ? void 0 : S.ignoreCase) ? "i" : "")), this.test = S == null ? void 0 : S.test, this.flat = FlattenedDoc.get(e6, C, this.chunkEnd(C + 5e3));
+  }
+  chunkEnd(e6) {
+    return e6 >= this.to ? this.to : this.text.lineAt(e6).to;
+  }
+  next() {
+    for (; ; ) {
+      let e6 = this.re.lastIndex = this.matchPos - this.flat.from, x = this.re.exec(this.flat.text);
+      if (x && !x[0] && x.index == e6 && (this.re.lastIndex = e6 + 1, x = this.re.exec(this.flat.text)), x) {
+        let e7 = this.flat.from + x.index, S = e7 + x[0].length;
+        if ((this.flat.to >= this.to || x.index + x[0].length <= this.flat.text.length - 10) && (!this.test || this.test(e7, S, x))) return this.value = {
+          from: e7,
+          to: S,
+          match: x
+        }, this.matchPos = toCharEnd(this.text, S + (e7 == S ? 1 : 0)), this;
+      }
+      if (this.flat.to == this.to) return this.done = true, this;
+      this.flat = FlattenedDoc.get(this.text, this.flat.from, this.chunkEnd(this.flat.from + this.flat.text.length * 2));
+    }
+  }
+};
+typeof Symbol < "u" && (RegExpCursor.prototype[Symbol.iterator] = MultilineRegExpCursor.prototype[Symbol.iterator] = function() {
+  return this;
+});
+function validRegExp(e6) {
+  try {
+    return new RegExp(e6, baseFlags), true;
+  } catch {
+    return false;
+  }
+}
+function toCharEnd(e6, x) {
+  if (x >= e6.length) return x;
+  let S = e6.lineAt(x), C;
+  for (; x < S.to && (C = S.text.charCodeAt(x - S.from)) >= 56320 && C < 57344; ) x++;
+  return x;
+}
+var gotoLine = (e6) => {
+  let { state: x } = e6, S = String(x.doc.lineAt(e6.state.selection.main.head).number), { close: C, result: w } = showDialog(e6, {
+    label: x.phrase("Go to line"),
+    input: {
+      type: "text",
+      name: "line",
+      value: S
+    },
+    focus: true,
+    submitLabel: x.phrase("go")
+  });
+  return w.then((S2) => {
+    let w2 = S2 && /^([+-])?(\d+)?(:\d+)?(%)?$/.exec(S2.elements.line.value);
+    if (!w2) {
+      e6.dispatch({ effects: C });
+      return;
+    }
+    let T = x.doc.lineAt(x.selection.main.head), [, E, D, O, k] = w2, A = O ? +O.slice(1) : 0, j = D ? +D : T.number;
+    if (D && k) {
+      let e7 = j / 100;
+      E && (e7 = e7 * (E == "-" ? -1 : 1) + T.number / x.doc.lines), j = Math.round(x.doc.lines * e7);
+    } else D && E && (j = j * (E == "-" ? -1 : 1) + T.number);
+    let M = x.doc.line(Math.max(1, Math.min(x.doc.lines, j))), N = EditorSelection.cursor(M.from + Math.max(0, Math.min(A, M.length)));
+    e6.dispatch({
+      effects: [C, EditorView.scrollIntoView(N.from, { y: "center" })],
+      selection: N
+    });
+  }), true;
+}, defaultHighlightOptions = {
+  highlightWordAroundCursor: false,
+  minSelectionLength: 1,
+  maxMatches: 100,
+  wholeWords: false
+}, highlightConfig = /* @__PURE__ */ Facet.define({ combine(e6) {
+  return combineConfig(e6, defaultHighlightOptions, {
+    highlightWordAroundCursor: (e7, x) => e7 || x,
+    minSelectionLength: Math.min,
+    maxMatches: Math.min
+  });
+} });
+function highlightSelectionMatches(e6) {
+  let x = [defaultTheme, matchHighlighter];
+  return e6 && x.push(highlightConfig.of(e6)), x;
+}
+var matchDeco = /* @__PURE__ */ Decoration.mark({ class: "cm-selectionMatch" }), mainMatchDeco = /* @__PURE__ */ Decoration.mark({ class: "cm-selectionMatch cm-selectionMatch-main" });
+function insideWordBoundaries(e6, x, S, C) {
+  return (S == 0 || e6(x.sliceDoc(S - 1, S)) != CharCategory.Word) && (C == x.doc.length || e6(x.sliceDoc(C, C + 1)) != CharCategory.Word);
+}
+function insideWord(e6, x, S, C) {
+  return e6(x.sliceDoc(S, S + 1)) == CharCategory.Word && e6(x.sliceDoc(C - 1, C)) == CharCategory.Word;
+}
+var matchHighlighter = /* @__PURE__ */ ViewPlugin.fromClass(class {
+  constructor(e6) {
+    this.decorations = this.getDeco(e6);
+  }
+  update(e6) {
+    (e6.selectionSet || e6.docChanged || e6.viewportChanged) && (this.decorations = this.getDeco(e6.view));
+  }
+  getDeco(e6) {
+    let x = e6.state.facet(highlightConfig), { state: S } = e6, C = S.selection;
+    if (C.ranges.length > 1) return Decoration.none;
+    let w = C.main, T, E = null;
+    if (w.empty) {
+      if (!x.highlightWordAroundCursor) return Decoration.none;
+      let e7 = S.wordAt(w.head);
+      if (!e7) return Decoration.none;
+      E = S.charCategorizer(w.head), T = S.sliceDoc(e7.from, e7.to);
+    } else {
+      let e7 = w.to - w.from;
+      if (e7 < x.minSelectionLength || e7 > 200) return Decoration.none;
+      if (x.wholeWords) {
+        if (T = S.sliceDoc(w.from, w.to), E = S.charCategorizer(w.head), !(insideWordBoundaries(E, S, w.from, w.to) && insideWord(E, S, w.from, w.to))) return Decoration.none;
+      } else if (T = S.sliceDoc(w.from, w.to), !T) return Decoration.none;
+    }
+    let D = [];
+    for (let C2 of e6.visibleRanges) {
+      let e7 = new SearchCursor(S.doc, T, C2.from, C2.to);
+      for (; !e7.next().done; ) {
+        let { from: C3, to: T2 } = e7.value;
+        if ((!E || insideWordBoundaries(E, S, C3, T2)) && (w.empty && C3 <= w.from && T2 >= w.to ? D.push(mainMatchDeco.range(C3, T2)) : (C3 >= w.to || T2 <= w.from) && D.push(matchDeco.range(C3, T2)), D.length > x.maxMatches)) return Decoration.none;
+      }
+    }
+    return Decoration.set(D);
+  }
+}, { decorations: (e6) => e6.decorations }), defaultTheme = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-selectionMatch": { backgroundColor: "#99ff7780" },
+  ".cm-searchMatch .cm-selectionMatch": { backgroundColor: "transparent" }
+}), selectWord = ({ state: e6, dispatch: x }) => {
+  let { selection: S } = e6, C = EditorSelection.create(S.ranges.map((x2) => e6.wordAt(x2.head) || EditorSelection.cursor(x2.head)), S.mainIndex);
+  return C.eq(S) ? false : (x(e6.update({ selection: C })), true);
+};
+function findNextOccurrence(e6, x) {
+  let { main: S, ranges: C } = e6.selection, w = e6.wordAt(S.head), T = w && w.from == S.from && w.to == S.to;
+  for (let S2 = false, w2 = new SearchCursor(e6.doc, x, C[C.length - 1].to); ; ) if (w2.next(), w2.done) {
+    if (S2) return null;
+    w2 = new SearchCursor(e6.doc, x, 0, Math.max(0, C[C.length - 1].from - 1)), S2 = true;
+  } else {
+    if (S2 && C.some((e7) => e7.from == w2.value.from)) continue;
+    if (T) {
+      let x2 = e6.wordAt(w2.value.from);
+      if (!x2 || x2.from != w2.value.from || x2.to != w2.value.to) continue;
+    }
+    return w2.value;
+  }
+}
+var selectNextOccurrence = ({ state: e6, dispatch: x }) => {
+  let { ranges: S } = e6.selection;
+  if (S.some((e7) => e7.from === e7.to)) return selectWord({
+    state: e6,
+    dispatch: x
+  });
+  let C = e6.sliceDoc(S[0].from, S[0].to);
+  if (e6.selection.ranges.some((x2) => e6.sliceDoc(x2.from, x2.to) != C)) return false;
+  let w = findNextOccurrence(e6, C);
+  return w ? (x(e6.update({
+    selection: e6.selection.addRange(EditorSelection.range(w.from, w.to), false),
+    effects: EditorView.scrollIntoView(w.to)
+  })), true) : false;
+}, searchConfigFacet = /* @__PURE__ */ Facet.define({ combine(e6) {
+  return combineConfig(e6, {
+    top: false,
+    caseSensitive: false,
+    literal: false,
+    regexp: false,
+    wholeWord: false,
+    createPanel: (e7) => new SearchPanel(e7),
+    scrollToMatch: (e7) => EditorView.scrollIntoView(e7)
+  });
+} }), SearchQuery = class {
+  constructor(e6) {
+    this.search = e6.search, this.caseSensitive = !!e6.caseSensitive, this.literal = !!e6.literal, this.regexp = !!e6.regexp, this.replace = e6.replace || "", this.valid = !!this.search && (!this.regexp || validRegExp(this.search)), this.unquoted = this.unquote(this.search), this.wholeWord = !!e6.wholeWord, this.test = e6.test;
+  }
+  unquote(e6) {
+    return this.literal ? e6 : e6.replace(/\\([nrt\\])/g, (e7, x) => x == "n" ? "\n" : x == "r" ? "\r" : x == "t" ? "	" : "\\");
+  }
+  eq(e6) {
+    return this.search == e6.search && this.replace == e6.replace && this.caseSensitive == e6.caseSensitive && this.regexp == e6.regexp && this.wholeWord == e6.wholeWord && this.test == e6.test;
+  }
+  create() {
+    return this.regexp ? new RegExpQuery(this) : new StringQuery(this);
+  }
+  getCursor(e6, x = 0, S) {
+    let C = e6.doc ? e6 : EditorState.create({ doc: e6 });
+    return S ?? (S = C.doc.length), this.regexp ? regexpCursor(this, C, x, S) : stringCursor(this, C, x, S);
+  }
+}, QueryType = class {
+  constructor(e6) {
+    this.spec = e6;
+  }
+};
+function wrapStringTest(e6, x, S) {
+  return (C, w, T, E) => S && !S(C, w, T, E) ? false : e6(C >= E && w <= E + T.length ? T.slice(C - E, w - E) : x.doc.sliceString(C, w), x, C, w);
+}
+function stringCursor(e6, x, S, C) {
+  let w;
+  return e6.wholeWord && (w = stringWordTest(x.doc, x.charCategorizer(x.selection.main.head))), e6.test && (w = wrapStringTest(e6.test, x, w)), new SearchCursor(x.doc, e6.unquoted, S, C, e6.caseSensitive ? void 0 : (e7) => e7.toLowerCase(), w);
+}
+function stringWordTest(e6, x) {
+  return (S, C, w, T) => ((T > S || T + w.length < C) && (T = Math.max(0, S - 2), w = e6.sliceString(T, Math.min(e6.length, C + 2))), (x(charBefore(w, S - T)) != CharCategory.Word || x(charAfter(w, S - T)) != CharCategory.Word) && (x(charAfter(w, C - T)) != CharCategory.Word || x(charBefore(w, C - T)) != CharCategory.Word));
+}
+var StringQuery = class extends QueryType {
+  constructor(e6) {
+    super(e6);
+  }
+  nextMatch(e6, x, S) {
+    let C = stringCursor(this.spec, e6, S, e6.doc.length).nextOverlapping();
+    if (C.done) {
+      let S2 = Math.min(e6.doc.length, x + this.spec.unquoted.length);
+      C = stringCursor(this.spec, e6, 0, S2).nextOverlapping();
+    }
+    return C.done || C.value.from == x && C.value.to == S ? null : C.value;
+  }
+  prevMatchInRange(e6, x, S) {
+    for (let C = S; ; ) {
+      let S2 = Math.max(x, C - 1e4 - this.spec.unquoted.length), w = stringCursor(this.spec, e6, S2, C), T = null;
+      for (; !w.nextOverlapping().done; ) T = w.value;
+      if (T) return T;
+      if (S2 == x) return null;
+      C -= 1e4;
+    }
+  }
+  prevMatch(e6, x, S) {
+    let C = this.prevMatchInRange(e6, 0, x);
+    return C || (C = this.prevMatchInRange(e6, Math.max(0, S - this.spec.unquoted.length), e6.doc.length)), C && (C.from != x || C.to != S) ? C : null;
+  }
+  getReplacement(e6) {
+    return this.spec.unquote(this.spec.replace);
+  }
+  matchAll(e6, x) {
+    let S = stringCursor(this.spec, e6, 0, e6.doc.length), C = [];
+    for (; !S.next().done; ) {
+      if (C.length >= x) return null;
+      C.push(S.value);
+    }
+    return C;
+  }
+  highlight(e6, x, S, C) {
+    let w = stringCursor(this.spec, e6, Math.max(0, x - this.spec.unquoted.length), Math.min(S + this.spec.unquoted.length, e6.doc.length));
+    for (; !w.next().done; ) C(w.value.from, w.value.to);
+  }
+};
+function wrapRegexpTest(e6, x, S) {
+  return (C, w, T) => (!S || S(C, w, T)) && e6(T[0], x, C, w);
+}
+function regexpCursor(e6, x, S, C) {
+  let w;
+  return e6.wholeWord && (w = regexpWordTest(x.charCategorizer(x.selection.main.head))), e6.test && (w = wrapRegexpTest(e6.test, x, w)), new RegExpCursor(x.doc, e6.search, {
+    ignoreCase: !e6.caseSensitive,
+    test: w
+  }, S, C);
+}
+function charBefore(e6, x) {
+  return e6.slice(findClusterBreak(e6, x, false), x);
+}
+function charAfter(e6, x) {
+  return e6.slice(x, findClusterBreak(e6, x));
+}
+function regexpWordTest(e6) {
+  return (x, S, C) => !C[0].length || (e6(charBefore(C.input, C.index)) != CharCategory.Word || e6(charAfter(C.input, C.index)) != CharCategory.Word) && (e6(charAfter(C.input, C.index + C[0].length)) != CharCategory.Word || e6(charBefore(C.input, C.index + C[0].length)) != CharCategory.Word);
+}
+var RegExpQuery = class extends QueryType {
+  nextMatch(e6, x, S) {
+    let C = regexpCursor(this.spec, e6, S, e6.doc.length).next();
+    return C.done && (C = regexpCursor(this.spec, e6, 0, x).next()), C.done ? null : C.value;
+  }
+  prevMatchInRange(e6, x, S) {
+    for (let C = 1; ; C++) {
+      let w = Math.max(x, S - C * 1e4), T = regexpCursor(this.spec, e6, w, S), E = null;
+      for (; !T.next().done; ) E = T.value;
+      if (E && (w == x || E.from > w + 10)) return E;
+      if (w == x) return null;
+    }
+  }
+  prevMatch(e6, x, S) {
+    return this.prevMatchInRange(e6, 0, x) || this.prevMatchInRange(e6, S, e6.doc.length);
+  }
+  getReplacement(e6) {
+    return this.spec.unquote(this.spec.replace).replace(/\$([$&]|\d+)/g, (x, S) => {
+      if (S == "&") return e6.match[0];
+      if (S == "$") return "$";
+      for (let x2 = S.length; x2 > 0; x2--) {
+        let C = +S.slice(0, x2);
+        if (C > 0 && C < e6.match.length) return e6.match[C] + S.slice(x2);
+      }
+      return x;
+    });
+  }
+  matchAll(e6, x) {
+    let S = regexpCursor(this.spec, e6, 0, e6.doc.length), C = [];
+    for (; !S.next().done; ) {
+      if (C.length >= x) return null;
+      C.push(S.value);
+    }
+    return C;
+  }
+  highlight(e6, x, S, C) {
+    let w = regexpCursor(this.spec, e6, Math.max(0, x - 250), Math.min(S + 250, e6.doc.length));
+    for (; !w.next().done; ) C(w.value.from, w.value.to);
+  }
+}, setSearchQuery = /* @__PURE__ */ StateEffect.define(), togglePanel = /* @__PURE__ */ StateEffect.define(), searchState = /* @__PURE__ */ StateField.define({
+  create(e6) {
+    return new SearchState(defaultQuery(e6).create(), null);
+  },
+  update(e6, x) {
+    for (let S of x.effects) S.is(setSearchQuery) ? e6 = new SearchState(S.value.create(), e6.panel) : S.is(togglePanel) && (e6 = new SearchState(e6.query, S.value ? createSearchPanel : null));
+    return e6;
+  },
+  provide: (e6) => showPanel.from(e6, (e7) => e7.panel)
+}), SearchState = class {
+  constructor(e6, x) {
+    this.query = e6, this.panel = x;
+  }
+}, matchMark = /* @__PURE__ */ Decoration.mark({ class: "cm-searchMatch" }), selectedMatchMark = /* @__PURE__ */ Decoration.mark({ class: "cm-searchMatch cm-searchMatch-selected" }), searchHighlighter = /* @__PURE__ */ ViewPlugin.fromClass(class {
+  constructor(e6) {
+    this.view = e6, this.decorations = this.highlight(e6.state.field(searchState));
+  }
+  update(e6) {
+    let x = e6.state.field(searchState);
+    (x != e6.startState.field(searchState) || e6.docChanged || e6.selectionSet || e6.viewportChanged) && (this.decorations = this.highlight(x));
+  }
+  highlight({ query: e6, panel: x }) {
+    if (!x || !e6.spec.valid) return Decoration.none;
+    let { view: S } = this, C = new RangeSetBuilder();
+    for (let x2 = 0, w = S.visibleRanges, T = w.length; x2 < T; x2++) {
+      let { from: E, to: D } = w[x2];
+      for (; x2 < T - 1 && D > w[x2 + 1].from - 500; ) D = w[++x2].to;
+      e6.highlight(S.state, E, D, (e7, x3) => {
+        let w2 = S.state.selection.ranges.some((S2) => S2.from == e7 && S2.to == x3);
+        C.add(e7, x3, w2 ? selectedMatchMark : matchMark);
+      });
+    }
+    return C.finish();
+  }
+}, { decorations: (e6) => e6.decorations });
+function searchCommand(e6) {
+  return (x) => {
+    let S = x.state.field(searchState, false);
+    return S && S.query.spec.valid ? e6(x, S) : openSearchPanel(x);
+  };
+}
+var findNext = /* @__PURE__ */ searchCommand((e6, { query: x }) => {
+  let { to: S } = e6.state.selection.main, C = x.nextMatch(e6.state, S, S);
+  if (!C) return false;
+  let w = EditorSelection.single(C.from, C.to), T = e6.state.facet(searchConfigFacet);
+  return e6.dispatch({
+    selection: w,
+    effects: [announceMatch(e6, C), T.scrollToMatch(w.main, e6)],
+    userEvent: "select.search"
+  }), selectSearchInput(e6), true;
+}), findPrevious = /* @__PURE__ */ searchCommand((e6, { query: x }) => {
+  let { state: S } = e6, { from: C } = S.selection.main, w = x.prevMatch(S, C, C);
+  if (!w) return false;
+  let T = EditorSelection.single(w.from, w.to), E = e6.state.facet(searchConfigFacet);
+  return e6.dispatch({
+    selection: T,
+    effects: [announceMatch(e6, w), E.scrollToMatch(T.main, e6)],
+    userEvent: "select.search"
+  }), selectSearchInput(e6), true;
+}), selectMatches = /* @__PURE__ */ searchCommand((e6, { query: x }) => {
+  let S = x.matchAll(e6.state, 1e3);
+  return !S || !S.length ? false : (e6.dispatch({
+    selection: EditorSelection.create(S.map((e7) => EditorSelection.range(e7.from, e7.to))),
+    userEvent: "select.search.matches"
+  }), true);
+}), selectSelectionMatches = ({ state: e6, dispatch: x }) => {
+  let S = e6.selection;
+  if (S.ranges.length > 1 || S.main.empty) return false;
+  let { from: C, to: w } = S.main, T = [], E = 0;
+  for (let x2 = new SearchCursor(e6.doc, e6.sliceDoc(C, w)); !x2.next().done; ) {
+    if (T.length > 1e3) return false;
+    x2.value.from == C && (E = T.length), T.push(EditorSelection.range(x2.value.from, x2.value.to));
+  }
+  return x(e6.update({
+    selection: EditorSelection.create(T, E),
+    userEvent: "select.search.matches"
+  })), true;
+}, replaceNext = /* @__PURE__ */ searchCommand((e6, { query: x }) => {
+  let { state: S } = e6, { from: C, to: w } = S.selection.main;
+  if (S.readOnly) return false;
+  let T = x.nextMatch(S, C, C);
+  if (!T) return false;
+  let E = T, D = [], O, k, A = [];
+  E.from == C && E.to == w && (k = S.toText(x.getReplacement(E)), D.push({
+    from: E.from,
+    to: E.to,
+    insert: k
+  }), E = x.nextMatch(S, E.from, E.to), A.push(EditorView.announce.of(S.phrase("replaced match on line $", S.doc.lineAt(C).number) + ".")));
+  let j = e6.state.changes(D);
+  return E && (O = EditorSelection.single(E.from, E.to).map(j), A.push(announceMatch(e6, E)), A.push(S.facet(searchConfigFacet).scrollToMatch(O.main, e6))), e6.dispatch({
+    changes: j,
+    selection: O,
+    effects: A,
+    userEvent: "input.replace"
+  }), true;
+}), replaceAll = /* @__PURE__ */ searchCommand((e6, { query: x }) => {
+  if (e6.state.readOnly) return false;
+  let S = x.matchAll(e6.state, 1e9).map((e7) => {
+    let { from: S2, to: C2 } = e7;
+    return {
+      from: S2,
+      to: C2,
+      insert: x.getReplacement(e7)
+    };
+  });
+  if (!S.length) return false;
+  let C = e6.state.phrase("replaced $ matches", S.length) + ".";
+  return e6.dispatch({
+    changes: S,
+    effects: EditorView.announce.of(C),
+    userEvent: "input.replace.all"
+  }), true;
+});
+function createSearchPanel(e6) {
+  return e6.state.facet(searchConfigFacet).createPanel(e6);
+}
+function defaultQuery(e6, x) {
+  let S = e6.selection.main, C = S.empty || S.to > S.from + 100 ? "" : e6.sliceDoc(S.from, S.to);
+  if (x && !C) return x;
+  let w = e6.facet(searchConfigFacet);
+  return new SearchQuery({
+    search: (x == null ? void 0 : x.literal) ?? w.literal ? C : C.replace(/\n/g, "\\n"),
+    caseSensitive: (x == null ? void 0 : x.caseSensitive) ?? w.caseSensitive,
+    literal: (x == null ? void 0 : x.literal) ?? w.literal,
+    regexp: (x == null ? void 0 : x.regexp) ?? w.regexp,
+    wholeWord: (x == null ? void 0 : x.wholeWord) ?? w.wholeWord
+  });
+}
+function getSearchInput(e6) {
+  let x = getPanel(e6, createSearchPanel);
+  return x && x.dom.querySelector("[main-field]");
+}
+function selectSearchInput(e6) {
+  let x = getSearchInput(e6);
+  x && x == e6.root.activeElement && x.select();
+}
+var openSearchPanel = (e6) => {
+  let x = e6.state.field(searchState, false);
+  if (x && x.panel) {
+    let S = getSearchInput(e6);
+    if (S && S != e6.root.activeElement) {
+      let C = defaultQuery(e6.state, x.query.spec);
+      C.valid && e6.dispatch({ effects: setSearchQuery.of(C) }), S.focus(), S.select();
+    }
+  } else e6.dispatch({ effects: [togglePanel.of(true), x ? setSearchQuery.of(defaultQuery(e6.state, x.query.spec)) : StateEffect.appendConfig.of(searchExtensions)] });
+  return true;
+}, closeSearchPanel = (e6) => {
+  let x = e6.state.field(searchState, false);
+  if (!x || !x.panel) return false;
+  let S = getPanel(e6, createSearchPanel);
+  return S && S.dom.contains(e6.root.activeElement) && e6.focus(), e6.dispatch({ effects: togglePanel.of(false) }), true;
+}, searchKeymap = [
+  {
+    key: "Mod-f",
+    run: openSearchPanel,
+    scope: "editor search-panel"
+  },
+  {
+    key: "F3",
+    run: findNext,
+    shift: findPrevious,
+    scope: "editor search-panel",
+    preventDefault: true
+  },
+  {
+    key: "Mod-g",
+    run: findNext,
+    shift: findPrevious,
+    scope: "editor search-panel",
+    preventDefault: true
+  },
+  {
+    key: "Escape",
+    run: closeSearchPanel,
+    scope: "editor search-panel"
+  },
+  {
+    key: "Mod-Shift-l",
+    run: selectSelectionMatches
+  },
+  {
+    key: "Mod-Alt-g",
+    run: gotoLine
+  },
+  {
+    key: "Mod-d",
+    run: selectNextOccurrence,
+    preventDefault: true
+  }
+], SearchPanel = class {
+  constructor(e6) {
+    this.view = e6;
+    let x = this.query = e6.state.field(searchState).query.spec;
+    this.commit = this.commit.bind(this), this.searchField = crelt("input", {
+      value: x.search,
+      placeholder: phrase(e6, "Find"),
+      "aria-label": phrase(e6, "Find"),
+      class: "cm-textfield",
+      name: "search",
+      form: "",
+      "main-field": "true",
+      onchange: this.commit,
+      onkeyup: this.commit
+    }), this.replaceField = crelt("input", {
+      value: x.replace,
+      placeholder: phrase(e6, "Replace"),
+      "aria-label": phrase(e6, "Replace"),
+      class: "cm-textfield",
+      name: "replace",
+      form: "",
+      onchange: this.commit,
+      onkeyup: this.commit
+    }), this.caseField = crelt("input", {
+      type: "checkbox",
+      name: "case",
+      form: "",
+      checked: x.caseSensitive,
+      onchange: this.commit
+    }), this.reField = crelt("input", {
+      type: "checkbox",
+      name: "re",
+      form: "",
+      checked: x.regexp,
+      onchange: this.commit
+    }), this.wordField = crelt("input", {
+      type: "checkbox",
+      name: "word",
+      form: "",
+      checked: x.wholeWord,
+      onchange: this.commit
+    });
+    function S(e7, x2, S2) {
+      return crelt("button", {
+        class: "cm-button",
+        name: e7,
+        onclick: x2,
+        type: "button"
+      }, S2);
+    }
+    this.dom = crelt("div", {
+      onkeydown: (e7) => this.keydown(e7),
+      class: "cm-search"
+    }, [
+      this.searchField,
+      S("next", () => findNext(e6), [phrase(e6, "next")]),
+      S("prev", () => findPrevious(e6), [phrase(e6, "previous")]),
+      S("select", () => selectMatches(e6), [phrase(e6, "all")]),
+      crelt("label", null, [this.caseField, phrase(e6, "match case")]),
+      crelt("label", null, [this.reField, phrase(e6, "regexp")]),
+      crelt("label", null, [this.wordField, phrase(e6, "by word")]),
+      ...e6.state.readOnly ? [] : [
+        crelt("br"),
+        this.replaceField,
+        S("replace", () => replaceNext(e6), [phrase(e6, "replace")]),
+        S("replaceAll", () => replaceAll(e6), [phrase(e6, "replace all")])
+      ],
+      crelt("button", {
+        name: "close",
+        onclick: () => closeSearchPanel(e6),
+        "aria-label": phrase(e6, "close"),
+        type: "button"
+      }, ["\xD7"])
+    ]);
+  }
+  commit() {
+    let e6 = new SearchQuery({
+      search: this.searchField.value,
+      caseSensitive: this.caseField.checked,
+      regexp: this.reField.checked,
+      wholeWord: this.wordField.checked,
+      replace: this.replaceField.value
+    });
+    e6.eq(this.query) || (this.query = e6, this.view.dispatch({ effects: setSearchQuery.of(e6) }));
+  }
+  keydown(e6) {
+    runScopeHandlers(this.view, e6, "search-panel") ? e6.preventDefault() : e6.keyCode == 13 && e6.target == this.searchField ? (e6.preventDefault(), (e6.shiftKey ? findPrevious : findNext)(this.view)) : e6.keyCode == 13 && e6.target == this.replaceField && (e6.preventDefault(), replaceNext(this.view));
+  }
+  update(e6) {
+    for (let x of e6.transactions) for (let e7 of x.effects) e7.is(setSearchQuery) && !e7.value.eq(this.query) && this.setQuery(e7.value);
+  }
+  setQuery(e6) {
+    this.query = e6, this.searchField.value = e6.search, this.replaceField.value = e6.replace, this.caseField.checked = e6.caseSensitive, this.reField.checked = e6.regexp, this.wordField.checked = e6.wholeWord;
+  }
+  mount() {
+    this.searchField.select();
+  }
+  get pos() {
+    return 80;
+  }
+  get top() {
+    return this.view.state.facet(searchConfigFacet).top;
+  }
+};
+function phrase(e6, x) {
+  return e6.state.phrase(x);
+}
+var AnnounceMargin = 30, Break = /[\s\.,:;?!]/;
+function announceMatch(e6, { from: x, to: S }) {
+  let C = e6.state.doc.lineAt(x), w = e6.state.doc.lineAt(S).to, T = Math.max(C.from, x - AnnounceMargin), E = Math.min(w, S + AnnounceMargin), D = e6.state.sliceDoc(T, E);
+  if (T != C.from) {
+    for (let e7 = 0; e7 < AnnounceMargin; e7++) if (!Break.test(D[e7 + 1]) && Break.test(D[e7])) {
+      D = D.slice(e7);
+      break;
+    }
+  }
+  if (E != w) {
+    for (let e7 = D.length - 1; e7 > D.length - AnnounceMargin; e7--) if (!Break.test(D[e7 - 1]) && Break.test(D[e7])) {
+      D = D.slice(0, e7);
+      break;
+    }
+  }
+  return EditorView.announce.of(`${e6.state.phrase("current match")}. ${D} ${e6.state.phrase("on line")} ${C.number}.`);
+}
+var baseTheme = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-panel.cm-search": {
+    padding: "2px 6px 4px",
+    position: "relative",
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      right: "4px",
+      backgroundColor: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: 0,
+      margin: 0
+    },
+    "& input, & button, & label": { margin: ".2em .6em .2em 0" },
+    "& input[type=checkbox]": { marginRight: ".2em" },
+    "& label": {
+      fontSize: "80%",
+      whiteSpace: "pre"
+    }
+  },
+  "&light .cm-searchMatch": { backgroundColor: "#ffff0054" },
+  "&dark .cm-searchMatch": { backgroundColor: "#00ffff8a" },
+  "&light .cm-searchMatch-selected": { backgroundColor: "#ff6a0054" },
+  "&dark .cm-searchMatch-selected": { backgroundColor: "#ff00ff8a" }
+}), searchExtensions = [
+  searchState,
+  /* @__PURE__ */ Prec.low(searchHighlighter),
+  baseTheme
+];
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(e6) {
+    for (var x = 1; x < arguments.length; x++) {
+      var S = arguments[x];
+      for (var C in S) ({}).hasOwnProperty.call(S, C) && (e6[C] = S[C]);
+    }
+    return e6;
+  }, _extends.apply(null, arguments);
+}
+function _objectWithoutPropertiesLoose(e6, x) {
+  if (e6 == null) return {};
+  var S = {};
+  for (var C in e6) if ({}.hasOwnProperty.call(e6, C)) {
+    if (x.indexOf(C) !== -1) continue;
+    S[C] = e6[C];
+  }
+  return S;
+}
+var basicSetup = function(e6) {
+  e6 === void 0 && (e6 = {});
+  var { crosshairCursor: x = false } = e6, S = [];
+  e6.closeBracketsKeymap !== false && (S = S.concat(closeBracketsKeymap)), e6.defaultKeymap !== false && (S = S.concat(defaultKeymap)), e6.searchKeymap !== false && (S = S.concat(searchKeymap)), e6.historyKeymap !== false && (S = S.concat(historyKeymap)), e6.foldKeymap !== false && (S = S.concat(foldKeymap)), e6.completionKeymap !== false && (S = S.concat(completionKeymap)), e6.lintKeymap !== false && (S = S.concat(lintKeymap));
+  var C = [];
+  return e6.lineNumbers !== false && C.push(lineNumbers()), e6.highlightActiveLineGutter !== false && C.push(highlightActiveLineGutter()), e6.highlightSpecialChars !== false && C.push(highlightSpecialChars()), e6.history !== false && C.push(history()), e6.foldGutter !== false && C.push(foldGutter()), e6.drawSelection !== false && C.push(drawSelection()), e6.dropCursor !== false && C.push(dropCursor()), e6.allowMultipleSelections !== false && C.push(EditorState.allowMultipleSelections.of(true)), e6.indentOnInput !== false && C.push(indentOnInput()), e6.syntaxHighlighting !== false && C.push(syntaxHighlighting(defaultHighlightStyle, { fallback: true })), e6.bracketMatching !== false && C.push(bracketMatching()), e6.closeBrackets !== false && C.push(closeBrackets()), e6.autocompletion !== false && C.push(autocompletion()), e6.rectangularSelection !== false && C.push(rectangularSelection()), x !== false && C.push(crosshairCursor()), e6.highlightActiveLine !== false && C.push(highlightActiveLine()), e6.highlightSelectionMatches !== false && C.push(highlightSelectionMatches()), e6.tabSize && typeof e6.tabSize == "number" && C.push(indentUnit.of(" ".repeat(e6.tabSize))), C.concat([keymap.of(S.flat())]).filter(Boolean);
+}, minimalSetup = function(e6) {
+  e6 === void 0 && (e6 = {});
+  var x = [];
+  e6.defaultKeymap !== false && (x = x.concat(defaultKeymap)), e6.historyKeymap !== false && (x = x.concat(historyKeymap));
+  var S = [];
+  return e6.highlightSpecialChars !== false && S.push(highlightSpecialChars()), e6.history !== false && S.push(history()), e6.drawSelection !== false && S.push(drawSelection()), e6.syntaxHighlighting !== false && S.push(syntaxHighlighting(defaultHighlightStyle, { fallback: true })), S.concat([keymap.of(x.flat())]).filter(Boolean);
+}, chalky = "#e5c07b", coral = "#e06c75", cyan = "#56b6c2", invalid = "#ffffff", ivory = "#abb2bf", stone = "#7d8799", malibu = "#61afef", sage = "#98c379", whiskey = "#d19a66", violet = "#c678dd", darkBackground = "#21252b", highlightBackground = "#2c313a", background = "#282c34", tooltipBackground = "#353a42", selection = "#3E4451", cursor = "#528bff", oneDark = [/* @__PURE__ */ EditorView.theme({
+  "&": {
+    color: ivory,
+    backgroundColor: background
+  },
+  ".cm-content": { caretColor: cursor },
+  ".cm-cursor, .cm-dropCursor": { borderLeftColor: cursor },
+  "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection": { backgroundColor: selection },
+  ".cm-panels": {
+    backgroundColor: darkBackground,
+    color: ivory
+  },
+  ".cm-panels.cm-panels-top": { borderBottom: "2px solid black" },
+  ".cm-panels.cm-panels-bottom": { borderTop: "2px solid black" },
+  ".cm-searchMatch": {
+    backgroundColor: "#72a1ff59",
+    outline: "1px solid #457dff"
+  },
+  ".cm-searchMatch.cm-searchMatch-selected": { backgroundColor: "#6199ff2f" },
+  ".cm-activeLine": { backgroundColor: "#6699ff0b" },
+  ".cm-selectionMatch": { backgroundColor: "#aafe661a" },
+  "&.cm-focused .cm-matchingBracket, &.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bad0f847" },
+  ".cm-gutters": {
+    backgroundColor: background,
+    color: stone,
+    border: "none"
+  },
+  ".cm-activeLineGutter": { backgroundColor: highlightBackground },
+  ".cm-foldPlaceholder": {
+    backgroundColor: "transparent",
+    border: "none",
+    color: "#ddd"
+  },
+  ".cm-tooltip": {
+    border: "none",
+    backgroundColor: tooltipBackground
+  },
+  ".cm-tooltip .cm-tooltip-arrow:before": {
+    borderTopColor: "transparent",
+    borderBottomColor: "transparent"
+  },
+  ".cm-tooltip .cm-tooltip-arrow:after": {
+    borderTopColor: tooltipBackground,
+    borderBottomColor: tooltipBackground
+  },
+  ".cm-tooltip-autocomplete": { "& > ul > li[aria-selected]": {
+    backgroundColor: highlightBackground,
+    color: ivory
+  } }
+}, { dark: true }), /* @__PURE__ */ syntaxHighlighting(/* @__PURE__ */ HighlightStyle.define([
+  {
+    tag: tags.keyword,
+    color: violet
+  },
+  {
+    tag: [
+      tags.name,
+      tags.deleted,
+      tags.character,
+      tags.propertyName,
+      tags.macroName
+    ],
+    color: coral
+  },
+  {
+    tag: [/* @__PURE__ */ tags.function(tags.variableName), tags.labelName],
+    color: malibu
+  },
+  {
+    tag: [
+      tags.color,
+      /* @__PURE__ */ tags.constant(tags.name),
+      /* @__PURE__ */ tags.standard(tags.name)
+    ],
+    color: whiskey
+  },
+  {
+    tag: [/* @__PURE__ */ tags.definition(tags.name), tags.separator],
+    color: ivory
+  },
+  {
+    tag: [
+      tags.typeName,
+      tags.className,
+      tags.number,
+      tags.changed,
+      tags.annotation,
+      tags.modifier,
+      tags.self,
+      tags.namespace
+    ],
+    color: chalky
+  },
+  {
+    tag: [
+      tags.operator,
+      tags.operatorKeyword,
+      tags.url,
+      tags.escape,
+      tags.regexp,
+      tags.link,
+      /* @__PURE__ */ tags.special(tags.string)
+    ],
+    color: cyan
+  },
+  {
+    tag: [tags.meta, tags.comment],
+    color: stone
+  },
+  {
+    tag: tags.strong,
+    fontWeight: "bold"
+  },
+  {
+    tag: tags.emphasis,
+    fontStyle: "italic"
+  },
+  {
+    tag: tags.strikethrough,
+    textDecoration: "line-through"
+  },
+  {
+    tag: tags.link,
+    color: stone,
+    textDecoration: "underline"
+  },
+  {
+    tag: tags.heading,
+    fontWeight: "bold",
+    color: coral
+  },
+  {
+    tag: [
+      tags.atom,
+      tags.bool,
+      /* @__PURE__ */ tags.special(tags.variableName)
+    ],
+    color: whiskey
+  },
+  {
+    tag: [
+      tags.processingInstruction,
+      tags.string,
+      tags.inserted
+    ],
+    color: sage
+  },
+  {
+    tag: tags.invalid,
+    color: invalid
+  }
+]))], defaultLightThemeOption = EditorView.theme({ "&": { backgroundColor: "#fff" } }, { dark: false }), getDefaultExtensions = function(e6) {
+  e6 === void 0 && (e6 = {});
+  var { indentWithTab: x = true, editable: S = true, readOnly: C = false, theme: w = "light", placeholder: T = "", basicSetup: E = true } = e6, D = [];
+  switch (x && D.unshift(keymap.of([indentWithTab])), E && (typeof E == "boolean" ? D.unshift(basicSetup()) : D.unshift(basicSetup(E))), T && D.unshift(placeholder(T)), w) {
+    case "light":
+      D.push(defaultLightThemeOption);
+      break;
+    case "dark":
+      D.push(oneDark);
+      break;
+    case "none":
+      break;
+    default:
+      D.push(w);
+      break;
+  }
+  return S === false && D.push(EditorView.editable.of(false)), C && D.push(EditorState.readOnly.of(true)), [...D];
+}, getStatistics = (e6) => ({
+  line: e6.state.doc.lineAt(e6.state.selection.main.from),
+  lineCount: e6.state.doc.lines,
+  lineBreak: e6.state.lineBreak,
+  length: e6.state.doc.length,
+  readOnly: e6.state.readOnly,
+  tabSize: e6.state.tabSize,
+  selection: e6.state.selection,
+  selectionAsSingle: e6.state.selection.asSingle().main,
+  ranges: e6.state.selection.ranges,
+  selectionCode: e6.state.sliceDoc(e6.state.selection.main.from, e6.state.selection.main.to),
+  selections: e6.state.selection.ranges.map((x) => e6.state.sliceDoc(x.from, x.to)),
+  selectedText: e6.state.selection.ranges.some((e7) => !e7.empty)
+}), TimeoutLatch = class {
+  constructor(e6, x) {
+    this.timeLeftMS = void 0, this.timeoutMS = void 0, this.isCancelled = false, this.isTimeExhausted = false, this.callbacks = [], this.timeLeftMS = x, this.timeoutMS = x, this.callbacks.push(e6);
+  }
+  tick() {
+    if (!this.isCancelled && !this.isTimeExhausted && (this.timeLeftMS--, this.timeLeftMS <= 0)) {
+      this.isTimeExhausted = true;
+      var e6 = this.callbacks.slice();
+      this.callbacks.length = 0, e6.forEach((e7) => {
+        try {
+          e7();
+        } catch (e8) {
+          console.error("TimeoutLatch callback error:", e8);
+        }
+      });
+    }
+  }
+  cancel() {
+    this.isCancelled = true, this.callbacks.length = 0;
+  }
+  reset() {
+    this.timeLeftMS = this.timeoutMS, this.isCancelled = false, this.isTimeExhausted = false;
+  }
+  get isDone() {
+    return this.isCancelled || this.isTimeExhausted;
+  }
+}, Scheduler = class {
+  constructor() {
+    this.interval = null, this.latches = /* @__PURE__ */ new Set();
+  }
+  add(e6) {
+    this.latches.add(e6), this.start();
+  }
+  remove(e6) {
+    this.latches.delete(e6), this.latches.size === 0 && this.stop();
+  }
+  start() {
+    this.interval === null && (this.interval = setInterval(() => {
+      this.latches.forEach((e6) => {
+        e6.tick(), e6.isDone && this.remove(e6);
+      });
+    }, 1));
+  }
+  stop() {
+    this.interval !== null && (clearInterval(this.interval), this.interval = null);
+  }
+}, globalScheduler = null, getScheduler = () => typeof window > "u" ? new Scheduler() : (globalScheduler || (globalScheduler = new Scheduler()), globalScheduler), ExternalChange = Annotation.define(), TYPING_TIMOUT = 200, emptyExtensions = [];
+function useCodeMirror(e6) {
+  var { value: x, selection: S, onChange: C, onStatistics: w, onCreateEditor: T, onUpdate: E, extensions: D = emptyExtensions, autoFocus: O, theme: k = "light", height: A = null, minHeight: j = null, maxHeight: M = null, width: N = null, minWidth: P = null, maxWidth: F = null, placeholder: I = "", editable: L = true, readOnly: R = false, indentWithTab: B = true, basicSetup: V = true, root: H, initialState: U } = e6, [W, G] = (0, import_react.useState)(), [K, q] = (0, import_react.useState)(), [J, Y] = (0, import_react.useState)(), X = (0, import_react.useState)(() => ({ current: null }))[0], Z = (0, import_react.useState)(() => ({ current: null }))[0], Q = EditorView.theme({
+    "&": {
+      height: A,
+      minHeight: j,
+      maxHeight: M,
+      width: N,
+      minWidth: P,
+      maxWidth: F
+    },
+    "& .cm-scroller": { height: "100% !important" }
+  }), $ = [
+    EditorView.updateListener.of((e7) => {
+      e7.docChanged && typeof C == "function" && !e7.transactions.some((e8) => e8.annotation(ExternalChange)) && (X.current ? X.current.reset() : (X.current = new TimeoutLatch(() => {
+        if (Z.current) {
+          var e8 = Z.current;
+          Z.current = null, e8();
+        }
+        X.current = null;
+      }, TYPING_TIMOUT), getScheduler().add(X.current)), C(e7.state.doc.toString(), e7)), w && w(getStatistics(e7));
+    }),
+    Q,
+    ...getDefaultExtensions({
+      theme: k,
+      editable: L,
+      readOnly: R,
+      placeholder: I,
+      indentWithTab: B,
+      basicSetup: V
+    })
+  ];
+  return E && typeof E == "function" && $.push(EditorView.updateListener.of(E)), $ = $.concat(D), (0, import_react.useLayoutEffect)(() => {
+    if (W && !J) {
+      var e7 = {
+        doc: x,
+        selection: S,
+        extensions: $
+      }, C2 = U ? EditorState.fromJSON(U.json, e7, U.fields) : EditorState.create(e7);
+      if (Y(C2), !K) {
+        var w2 = new EditorView({
+          state: C2,
+          parent: W,
+          root: H
+        });
+        q(w2), T && T(w2, C2);
+      }
+    }
+    return () => {
+      K && (Y(void 0), q(void 0));
+    };
+  }, [W, J]), (0, import_react.useEffect)(() => {
+    e6.container && G(e6.container);
+  }, [e6.container]), (0, import_react.useEffect)(() => () => {
+    K && (K.destroy(), q(void 0)), X.current && (X.current = (X.current.cancel(), null));
+  }, [K]), (0, import_react.useEffect)(() => {
+    O && K && K.focus();
+  }, [O, K]), (0, import_react.useEffect)(() => {
+    K && K.dispatch({ effects: StateEffect.reconfigure.of($) });
+  }, [
+    k,
+    D,
+    A,
+    j,
+    M,
+    N,
+    P,
+    F,
+    I,
+    L,
+    R,
+    B,
+    V,
+    C,
+    E
+  ]), (0, import_react.useEffect)(() => {
+    if (x !== void 0) {
+      var e7 = K ? K.state.doc.toString() : "";
+      if (K && x !== e7) {
+        var S2 = X.current && !X.current.isDone, C2 = () => {
+          K && x !== K.state.doc.toString() && K.dispatch({
+            changes: {
+              from: 0,
+              to: K.state.doc.toString().length,
+              insert: x || ""
+            },
+            annotations: [ExternalChange.of(true)]
+          });
+        };
+        S2 ? Z.current = C2 : C2();
+      }
+    }
+  }, [x, K]), {
+    state: J,
+    setState: Y,
+    view: K,
+    setView: q,
+    container: W,
+    setContainer: G
+  };
+}
+var _excluded = [
+  "className",
+  "value",
+  "selection",
+  "extensions",
+  "onChange",
+  "onStatistics",
+  "onCreateEditor",
+  "onUpdate",
+  "autoFocus",
+  "theme",
+  "height",
+  "minHeight",
+  "maxHeight",
+  "width",
+  "minWidth",
+  "maxWidth",
+  "basicSetup",
+  "placeholder",
+  "indentWithTab",
+  "editable",
+  "readOnly",
+  "root",
+  "initialState"
+], ReactCodeMirror = /* @__PURE__ */ (0, import_react.forwardRef)((e6, x) => {
+  var { className: S, value: C = "", selection: w, extensions: T = [], onChange: E, onStatistics: D, onCreateEditor: O, onUpdate: k, autoFocus: A, theme: j = "light", height: M, minHeight: N, maxHeight: P, width: F, minWidth: I, maxWidth: L, basicSetup: R, placeholder: z, indentWithTab: B, editable: V, readOnly: H, root: U, initialState: W } = e6, G = _objectWithoutPropertiesLoose(e6, _excluded), K = (0, import_react.useRef)(null), { state: q, view: J, container: Y, setContainer: X } = useCodeMirror({
+    root: U,
+    value: C,
+    autoFocus: A,
+    theme: j,
+    height: M,
+    minHeight: N,
+    maxHeight: P,
+    width: F,
+    minWidth: I,
+    maxWidth: L,
+    basicSetup: R,
+    placeholder: z,
+    indentWithTab: B,
+    editable: V,
+    readOnly: H,
+    selection: w,
+    onChange: E,
+    onStatistics: D,
+    onCreateEditor: O,
+    onUpdate: k,
+    extensions: T,
+    initialState: W
+  });
+  (0, import_react.useImperativeHandle)(x, () => ({
+    editor: K.current,
+    state: q,
+    view: J
+  }), [
+    K,
+    Y,
+    q,
+    J
+  ]);
+  var Z = (0, import_react.useCallback)((e7) => {
+    K.current = e7, X(e7);
+  }, [X]);
+  if (typeof C != "string") throw Error("value must be typeof string but got " + typeof C);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", _extends({
+    ref: Z,
+    className: (typeof j == "string" ? "cm-theme-" + j : "cm-theme") + (S ? " " + S : "")
+  }, G));
+});
+ReactCodeMirror.displayName = "CodeMirror";
+var esm_default = ReactCodeMirror;
+export {
+  linter as a,
+  historyField as c,
+  forEachDiagnostic as i,
+  insertTab as l,
+  minimalSetup as n,
+  setDiagnostics as o,
+  _extends as r,
+  history as s,
+  esm_default as t,
+  CopyClipboardIcon as u
+};