@inkandswitch/patchwork-pkg-base 0.0.15 → 0.0.17

package/packages/codemirror-markdown/dist/extensions/markdown.js

@@ -0,0 +1,3476 @@
+import {
+  markdown
+} from "../chunk-PPGERYN5.js";
+import "../chunk-6JT2ASRP.js";
+import "../chunk-46Z6CXSY.js";
+import "../chunk-NEI7FGV4.js";
+import {
+  completionKeymap
+} from "../chunk-CSJO4DNL.js";
+import "../chunk-MBTMKYFQ.js";
+import {
+  HighlightStyle,
+  IndentContext,
+  LanguageDescription,
+  LanguageSupport,
+  NodeProp,
+  StreamLanguage,
+  foldKeymap,
+  getIndentUnit,
+  getIndentation,
+  indentOnInput,
+  indentString,
+  indentUnit,
+  matchBrackets,
+  syntaxHighlighting,
+  syntaxTree,
+  tags
+} from "../chunk-MAW6NPUW.js";
+
+// ../node_modules/.pnpm/@codemirror+commands@6.10.4/node_modules/@codemirror/commands/dist/index.js
+import { Annotation, Facet, combineConfig, StateField, Transaction, ChangeSet, ChangeDesc, EditorSelection, StateEffect, Text, findClusterBreak, countColumn, CharCategory } from "@codemirror/state";
+import { EditorView, Direction } from "@codemirror/view";
+var toggleComment = (target) => {
+  let { state } = target, line = state.doc.lineAt(state.selection.main.from), config = getConfig(target.state, line.from);
+  return config.line ? toggleLineComment(target) : config.block ? toggleBlockCommentByLine(target) : false;
+};
+function command(f, option) {
+  return ({ state, dispatch }) => {
+    if (state.readOnly)
+      return false;
+    let tr = f(option, state);
+    if (!tr)
+      return false;
+    dispatch(state.update(tr));
+    return true;
+  };
+}
+var toggleLineComment = /* @__PURE__ */ command(
+  changeLineComment,
+  0
+  /* CommentOption.Toggle */
+);
+var toggleBlockComment = /* @__PURE__ */ command(
+  changeBlockComment,
+  0
+  /* CommentOption.Toggle */
+);
+var toggleBlockCommentByLine = /* @__PURE__ */ command(
+  (o, s) => changeBlockComment(o, s, selectedLineRanges(s)),
+  0
+  /* CommentOption.Toggle */
+);
+function getConfig(state, pos) {
+  let data = state.languageDataAt("commentTokens", pos, 1);
+  return data.length ? data[0] : {};
+}
+var SearchMargin = 50;
+function findBlockComment(state, { open, close }, from, to) {
+  let textBefore = state.sliceDoc(from - SearchMargin, from);
+  let textAfter = state.sliceDoc(to, to + SearchMargin);
+  let spaceBefore = /\s*$/.exec(textBefore)[0].length, spaceAfter = /^\s*/.exec(textAfter)[0].length;
+  let beforeOff = textBefore.length - spaceBefore;
+  if (textBefore.slice(beforeOff - open.length, beforeOff) == open && textAfter.slice(spaceAfter, spaceAfter + close.length) == close) {
+    return {
+      open: { pos: from - spaceBefore, margin: spaceBefore && 1 },
+      close: { pos: to + spaceAfter, margin: spaceAfter && 1 }
+    };
+  }
+  let startText, endText;
+  if (to - from <= 2 * SearchMargin) {
+    startText = endText = state.sliceDoc(from, to);
+  } else {
+    startText = state.sliceDoc(from, from + SearchMargin);
+    endText = state.sliceDoc(to - SearchMargin, to);
+  }
+  let startSpace = /^\s*/.exec(startText)[0].length, endSpace = /\s*$/.exec(endText)[0].length;
+  let endOff = endText.length - endSpace - close.length;
+  if (startText.slice(startSpace, startSpace + open.length) == open && endText.slice(endOff, endOff + close.length) == close) {
+    return {
+      open: {
+        pos: from + startSpace + open.length,
+        margin: /\s/.test(startText.charAt(startSpace + open.length)) ? 1 : 0
+      },
+      close: {
+        pos: to - endSpace - close.length,
+        margin: /\s/.test(endText.charAt(endOff - 1)) ? 1 : 0
+      }
+    };
+  }
+  return null;
+}
+function selectedLineRanges(state) {
+  let ranges = [];
+  for (let r of state.selection.ranges) {
+    let fromLine = state.doc.lineAt(r.from);
+    let toLine = r.to <= fromLine.to ? fromLine : state.doc.lineAt(r.to);
+    if (toLine.from > fromLine.from && toLine.from == r.to)
+      toLine = r.to == fromLine.to + 1 ? fromLine : state.doc.lineAt(r.to - 1);
+    let last = ranges.length - 1;
+    if (last >= 0 && ranges[last].to > fromLine.from)
+      ranges[last].to = toLine.to;
+    else
+      ranges.push({ from: fromLine.from + /^\s*/.exec(fromLine.text)[0].length, to: toLine.to });
+  }
+  return ranges;
+}
+function changeBlockComment(option, state, ranges = state.selection.ranges) {
+  let tokens = ranges.map((r) => getConfig(state, r.from).block);
+  if (!tokens.every((c) => c))
+    return null;
+  let comments = ranges.map((r, i) => findBlockComment(state, tokens[i], r.from, r.to));
+  if (option != 2 && !comments.every((c) => c)) {
+    return { changes: state.changes(ranges.map((range, i) => {
+      if (comments[i])
+        return [];
+      return [{ from: range.from, insert: tokens[i].open + " " }, { from: range.to, insert: " " + tokens[i].close }];
+    })) };
+  } else if (option != 1 && comments.some((c) => c)) {
+    let changes = [];
+    for (let i = 0, comment; i < comments.length; i++)
+      if (comment = comments[i]) {
+        let token = tokens[i], { open, close } = comment;
+        changes.push({ from: open.pos - token.open.length, to: open.pos + open.margin }, { from: close.pos - close.margin, to: close.pos + token.close.length });
+      }
+    return { changes };
+  }
+  return null;
+}
+function changeLineComment(option, state, ranges = state.selection.ranges) {
+  let lines = [];
+  let prevLine = -1;
+  ranges: for (let { from, to } of ranges) {
+    let startI = lines.length, minIndent = 1e9, token;
+    for (let pos = from; pos <= to; ) {
+      let line = state.doc.lineAt(pos);
+      if (token == void 0) {
+        token = getConfig(state, line.from).line;
+        if (!token)
+          continue ranges;
+      }
+      if (line.from > prevLine && (from == to || to > line.from)) {
+        prevLine = line.from;
+        let indent = /^\s*/.exec(line.text)[0].length;
+        let empty2 = indent == line.length;
+        let comment = line.text.slice(indent, indent + token.length) == token ? indent : -1;
+        if (indent < line.text.length && indent < minIndent)
+          minIndent = indent;
+        lines.push({ line, comment, token, indent, empty: empty2, single: false });
+      }
+      pos = line.to + 1;
+    }
+    if (minIndent < 1e9) {
+      for (let i = startI; i < lines.length; i++)
+        if (lines[i].indent < lines[i].line.text.length)
+          lines[i].indent = minIndent;
+    }
+    if (lines.length == startI + 1)
+      lines[startI].single = true;
+  }
+  if (option != 2 && lines.some((l) => l.comment < 0 && (!l.empty || l.single))) {
+    let changes = [];
+    for (let { line, token, indent, empty: empty2, single } of lines)
+      if (single || !empty2)
+        changes.push({ from: line.from + indent, insert: token + " " });
+    let changeSet = state.changes(changes);
+    return { changes: changeSet, selection: state.selection.map(changeSet, 1) };
+  } else if (option != 1 && lines.some((l) => l.comment >= 0)) {
+    let changes = [];
+    for (let { line, comment, token } of lines)
+      if (comment >= 0) {
+        let from = line.from + comment, to = from + token.length;
+        if (line.text[to - line.from] == " ")
+          to++;
+        changes.push({ from, to });
+      }
+    return { changes };
+  }
+  return null;
+}
+var fromHistory = /* @__PURE__ */ Annotation.define();
+var isolateHistory = /* @__PURE__ */ Annotation.define();
+var invertedEffects = /* @__PURE__ */ Facet.define();
+var historyConfig = /* @__PURE__ */ Facet.define({
+  combine(configs) {
+    return combineConfig(configs, {
+      minDepth: 100,
+      newGroupDelay: 500,
+      joinToEvent: (_t, isAdjacent2) => isAdjacent2
+    }, {
+      minDepth: Math.max,
+      newGroupDelay: Math.min,
+      joinToEvent: (a, b) => (tr, adj) => a(tr, adj) || b(tr, adj)
+    });
+  }
+});
+var historyField_ = /* @__PURE__ */ StateField.define({
+  create() {
+    return HistoryState.empty;
+  },
+  update(state, tr) {
+    let config = tr.state.facet(historyConfig);
+    let fromHist = tr.annotation(fromHistory);
+    if (fromHist) {
+      let item = HistEvent.fromTransaction(tr, fromHist.selection), from = fromHist.side;
+      let other = from == 0 ? state.undone : state.done;
+      if (item)
+        other = updateBranch(other, other.length, config.minDepth, item);
+      else
+        other = addSelection(other, tr.startState.selection);
+      return new HistoryState(from == 0 ? fromHist.rest : other, from == 0 ? other : fromHist.rest);
+    }
+    let isolate = tr.annotation(isolateHistory);
+    if (isolate == "full" || isolate == "before")
+      state = state.isolate();
+    if (tr.annotation(Transaction.addToHistory) === false)
+      return !tr.changes.empty ? state.addMapping(tr.changes.desc) : state;
+    let event = HistEvent.fromTransaction(tr);
+    let time = tr.annotation(Transaction.time), userEvent = tr.annotation(Transaction.userEvent);
+    if (event)
+      state = state.addChanges(event, time, userEvent, config, tr);
+    else if (tr.selection)
+      state = state.addSelection(tr.startState.selection, time, userEvent, config.newGroupDelay);
+    if (isolate == "full" || isolate == "after")
+      state = state.isolate();
+    return state;
+  },
+  toJSON(value) {
+    return { done: value.done.map((e) => e.toJSON()), undone: value.undone.map((e) => e.toJSON()) };
+  },
+  fromJSON(json) {
+    return new HistoryState(json.done.map(HistEvent.fromJSON), json.undone.map(HistEvent.fromJSON));
+  }
+});
+function history(config = {}) {
+  return [
+    historyField_,
+    historyConfig.of(config),
+    EditorView.domEventHandlers({
+      beforeinput(e, view) {
+        let command2 = e.inputType == "historyUndo" ? undo : e.inputType == "historyRedo" ? redo : null;
+        if (!command2)
+          return false;
+        e.preventDefault();
+        return command2(view);
+      }
+    })
+  ];
+}
+function cmd(side, selection) {
+  return function({ state, dispatch }) {
+    if (!selection && state.readOnly)
+      return false;
+    let historyState = state.field(historyField_, false);
+    if (!historyState)
+      return false;
+    let tr = historyState.pop(side, state, selection);
+    if (!tr)
+      return false;
+    dispatch(tr);
+    return true;
+  };
+}
+var undo = /* @__PURE__ */ cmd(0, false);
+var redo = /* @__PURE__ */ cmd(1, false);
+var undoSelection = /* @__PURE__ */ cmd(0, true);
+var redoSelection = /* @__PURE__ */ cmd(1, true);
+var HistEvent = class _HistEvent {
+  constructor(changes, effects, mapped, startSelection, selectionsAfter) {
+    this.changes = changes;
+    this.effects = effects;
+    this.mapped = mapped;
+    this.startSelection = startSelection;
+    this.selectionsAfter = selectionsAfter;
+  }
+  setSelAfter(after) {
+    return new _HistEvent(this.changes, this.effects, this.mapped, this.startSelection, after);
+  }
+  toJSON() {
+    var _a, _b, _c;
+    return {
+      changes: (_a = this.changes) === null || _a === void 0 ? void 0 : _a.toJSON(),
+      mapped: (_b = this.mapped) === null || _b === void 0 ? void 0 : _b.toJSON(),
+      startSelection: (_c = this.startSelection) === null || _c === void 0 ? void 0 : _c.toJSON(),
+      selectionsAfter: this.selectionsAfter.map((s) => s.toJSON())
+    };
+  }
+  static fromJSON(json) {
+    return new _HistEvent(json.changes && ChangeSet.fromJSON(json.changes), [], json.mapped && ChangeDesc.fromJSON(json.mapped), json.startSelection && EditorSelection.fromJSON(json.startSelection), json.selectionsAfter.map(EditorSelection.fromJSON));
+  }
+  // This does not check `addToHistory` and such, it assumes the
+  // transaction needs to be converted to an item. Returns null when
+  // there are no changes or effects in the transaction.
+  static fromTransaction(tr, selection) {
+    let effects = none;
+    for (let invert of tr.startState.facet(invertedEffects)) {
+      let result = invert(tr);
+      if (result.length)
+        effects = effects.concat(result);
+    }
+    if (!effects.length && tr.changes.empty)
+      return null;
+    return new _HistEvent(tr.changes.invert(tr.startState.doc), effects, void 0, selection || tr.startState.selection, none);
+  }
+  static selection(selections) {
+    return new _HistEvent(void 0, none, void 0, void 0, selections);
+  }
+};
+function updateBranch(branch, to, maxLen, newEvent) {
+  let start = to + 1 > maxLen + 20 ? to - maxLen - 1 : 0;
+  let newBranch = branch.slice(start, to);
+  newBranch.push(newEvent);
+  return newBranch;
+}
+function isAdjacent(a, b) {
+  let ranges = [], isAdjacent2 = false;
+  a.iterChangedRanges((f, t) => ranges.push(f, t));
+  b.iterChangedRanges((_f, _t, f, t) => {
+    for (let i = 0; i < ranges.length; ) {
+      let from = ranges[i++], to = ranges[i++];
+      if (t >= from && f <= to)
+        isAdjacent2 = true;
+    }
+  });
+  return isAdjacent2;
+}
+function eqSelectionShape(a, b) {
+  return a.ranges.length == b.ranges.length && a.ranges.filter((r, i) => r.empty != b.ranges[i].empty).length === 0;
+}
+function conc(a, b) {
+  return !a.length ? b : !b.length ? a : a.concat(b);
+}
+var none = [];
+var MaxSelectionsPerEvent = 200;
+function addSelection(branch, selection) {
+  if (!branch.length) {
+    return [HistEvent.selection([selection])];
+  } else {
+    let lastEvent = branch[branch.length - 1];
+    let sels = lastEvent.selectionsAfter.slice(Math.max(0, lastEvent.selectionsAfter.length - MaxSelectionsPerEvent));
+    if (sels.length && sels[sels.length - 1].eq(selection))
+      return branch;
+    sels.push(selection);
+    return updateBranch(branch, branch.length - 1, 1e9, lastEvent.setSelAfter(sels));
+  }
+}
+function popSelection(branch) {
+  let last = branch[branch.length - 1];
+  let newBranch = branch.slice();
+  newBranch[branch.length - 1] = last.setSelAfter(last.selectionsAfter.slice(0, last.selectionsAfter.length - 1));
+  return newBranch;
+}
+function addMappingToBranch(branch, mapping) {
+  if (!branch.length)
+    return branch;
+  let length = branch.length, selections = none;
+  while (length) {
+    let event = mapEvent(branch[length - 1], mapping, selections);
+    if (event.changes && !event.changes.empty || event.effects.length) {
+      let result = branch.slice(0, length);
+      result[length - 1] = event;
+      return result;
+    } else {
+      mapping = event.mapped;
+      length--;
+      selections = event.selectionsAfter;
+    }
+  }
+  return selections.length ? [HistEvent.selection(selections)] : none;
+}
+function mapEvent(event, mapping, extraSelections) {
+  let selections = conc(event.selectionsAfter.length ? event.selectionsAfter.map((s) => s.map(mapping)) : none, extraSelections);
+  if (!event.changes)
+    return HistEvent.selection(selections);
+  let mappedChanges = event.changes.map(mapping), before = mapping.mapDesc(event.changes, true);
+  let fullMapping = event.mapped ? event.mapped.composeDesc(before) : before;
+  return new HistEvent(mappedChanges, StateEffect.mapEffects(event.effects, mapping), fullMapping, event.startSelection.map(before), selections);
+}
+var joinableUserEvent = /^(input\.type|delete)($|\.)/;
+var HistoryState = class _HistoryState {
+  constructor(done, undone, prevTime = 0, prevUserEvent = void 0) {
+    this.done = done;
+    this.undone = undone;
+    this.prevTime = prevTime;
+    this.prevUserEvent = prevUserEvent;
+  }
+  isolate() {
+    return this.prevTime ? new _HistoryState(this.done, this.undone) : this;
+  }
+  addChanges(event, time, userEvent, config, tr) {
+    let done = this.done, lastEvent = done[done.length - 1];
+    if (lastEvent && lastEvent.changes && !lastEvent.changes.empty && event.changes && (!userEvent || joinableUserEvent.test(userEvent)) && (!lastEvent.selectionsAfter.length && time - this.prevTime < config.newGroupDelay && config.joinToEvent(tr, isAdjacent(lastEvent.changes, event.changes)) || // For compose (but not compose.start) events, always join with previous event
+    userEvent == "input.type.compose")) {
+      done = updateBranch(done, done.length - 1, config.minDepth, new HistEvent(event.changes.compose(lastEvent.changes), conc(StateEffect.mapEffects(event.effects, lastEvent.changes), lastEvent.effects), lastEvent.mapped, lastEvent.startSelection, none));
+    } else {
+      done = updateBranch(done, done.length, config.minDepth, event);
+    }
+    return new _HistoryState(done, none, time, userEvent);
+  }
+  addSelection(selection, time, userEvent, newGroupDelay) {
+    let last = this.done.length ? this.done[this.done.length - 1].selectionsAfter : none;
+    if (last.length > 0 && time - this.prevTime < newGroupDelay && userEvent == this.prevUserEvent && userEvent && /^select($|\.)/.test(userEvent) && eqSelectionShape(last[last.length - 1], selection))
+      return this;
+    return new _HistoryState(addSelection(this.done, selection), this.undone, time, userEvent);
+  }
+  addMapping(mapping) {
+    return new _HistoryState(addMappingToBranch(this.done, mapping), addMappingToBranch(this.undone, mapping), this.prevTime, this.prevUserEvent);
+  }
+  pop(side, state, onlySelection) {
+    let branch = side == 0 ? this.done : this.undone;
+    if (branch.length == 0)
+      return null;
+    let event = branch[branch.length - 1], selection = event.selectionsAfter[0] || (event.startSelection ? event.startSelection.map(event.changes.invertedDesc, 1) : state.selection);
+    if (onlySelection && event.selectionsAfter.length) {
+      return state.update({
+        selection: event.selectionsAfter[event.selectionsAfter.length - 1],
+        annotations: fromHistory.of({ side, rest: popSelection(branch), selection }),
+        userEvent: side == 0 ? "select.undo" : "select.redo",
+        scrollIntoView: true
+      });
+    } else if (!event.changes) {
+      return null;
+    } else {
+      let rest = branch.length == 1 ? none : branch.slice(0, branch.length - 1);
+      if (event.mapped)
+        rest = addMappingToBranch(rest, event.mapped);
+      return state.update({
+        changes: event.changes,
+        selection: event.startSelection,
+        effects: event.effects,
+        annotations: fromHistory.of({ side, rest, selection }),
+        filter: false,
+        userEvent: side == 0 ? "undo" : "redo",
+        scrollIntoView: true
+      });
+    }
+  }
+};
+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(sel, by) {
+  return EditorSelection.create(sel.ranges.map(by), sel.mainIndex);
+}
+function setSel(state, selection) {
+  return state.update({ selection, scrollIntoView: true, userEvent: "select" });
+}
+function moveSel({ state, dispatch }, how) {
+  let selection = updateSel(state.selection, how);
+  if (selection.eq(state.selection, true))
+    return false;
+  dispatch(setSel(state, selection));
+  return true;
+}
+function rangeEnd(range, forward) {
+  return EditorSelection.cursor(forward ? range.to : range.from);
+}
+function cursorByChar(view, forward) {
+  return moveSel(view, (range) => range.empty ? view.moveByChar(range, forward) : rangeEnd(range, forward));
+}
+function ltrAtCursor(view) {
+  return view.textDirectionAt(view.state.selection.main.head) == Direction.LTR;
+}
+var cursorCharLeft = (view) => cursorByChar(view, !ltrAtCursor(view));
+var cursorCharRight = (view) => cursorByChar(view, ltrAtCursor(view));
+function cursorByGroup(view, forward) {
+  return moveSel(view, (range) => range.empty ? view.moveByGroup(range, forward) : rangeEnd(range, forward));
+}
+var cursorGroupLeft = (view) => cursorByGroup(view, !ltrAtCursor(view));
+var cursorGroupRight = (view) => cursorByGroup(view, ltrAtCursor(view));
+var segmenter = typeof Intl != "undefined" && Intl.Segmenter ? /* @__PURE__ */ new Intl.Segmenter(void 0, { granularity: "word" }) : null;
+function interestingNode(state, node, bracketProp) {
+  if (node.type.prop(bracketProp))
+    return true;
+  let len = node.to - node.from;
+  return len && (len > 2 || /[^\s,.;:]/.test(state.sliceDoc(node.from, node.to))) || node.firstChild;
+}
+function moveBySyntax(state, start, forward) {
+  let pos = syntaxTree(state).resolveInner(start.head);
+  let bracketProp = forward ? NodeProp.closedBy : NodeProp.openedBy;
+  for (let at = start.head; ; ) {
+    let next = forward ? pos.childAfter(at) : pos.childBefore(at);
+    if (!next)
+      break;
+    if (interestingNode(state, next, bracketProp))
+      pos = next;
+    else
+      at = forward ? next.to : next.from;
+  }
+  let bracket = pos.type.prop(bracketProp), match, newPos;
+  if (bracket && (match = forward ? matchBrackets(state, pos.from, 1) : matchBrackets(state, pos.to, -1)) && match.matched)
+    newPos = forward ? match.end.to : match.end.from;
+  else
+    newPos = forward ? pos.to : pos.from;
+  return EditorSelection.cursor(newPos, forward ? -1 : 1);
+}
+var cursorSyntaxLeft = (view) => moveSel(view, (range) => moveBySyntax(view.state, range, !ltrAtCursor(view)));
+var cursorSyntaxRight = (view) => moveSel(view, (range) => moveBySyntax(view.state, range, ltrAtCursor(view)));
+function cursorByLine(view, forward) {
+  return moveSel(view, (range) => {
+    if (!range.empty)
+      return rangeEnd(range, forward);
+    let moved = view.moveVertically(range, forward);
+    return moved.head != range.head ? moved : view.moveToLineBoundary(range, forward);
+  });
+}
+var cursorLineUp = (view) => cursorByLine(view, false);
+var cursorLineDown = (view) => cursorByLine(view, true);
+function pageInfo(view) {
+  let selfScroll = view.scrollDOM.clientHeight < view.scrollDOM.scrollHeight - 2;
+  let marginTop = 0, marginBottom = 0, height;
+  if (selfScroll) {
+    for (let source of view.state.facet(EditorView.scrollMargins)) {
+      let margins = source(view);
+      if (margins === null || margins === void 0 ? void 0 : margins.top)
+        marginTop = Math.max(margins === null || margins === void 0 ? void 0 : margins.top, marginTop);
+      if (margins === null || margins === void 0 ? void 0 : margins.bottom)
+        marginBottom = Math.max(margins === null || margins === void 0 ? void 0 : margins.bottom, marginBottom);
+    }
+    height = view.scrollDOM.clientHeight - marginTop - marginBottom;
+  } else {
+    height = (view.dom.ownerDocument.defaultView || window).innerHeight;
+  }
+  return {
+    marginTop,
+    marginBottom,
+    selfScroll,
+    height: Math.max(view.defaultLineHeight, height - 5)
+  };
+}
+function cursorByPage(view, forward) {
+  let page = pageInfo(view);
+  let { state } = view, selection = updateSel(state.selection, (range) => {
+    return range.empty ? view.moveVertically(range, forward, page.height) : rangeEnd(range, forward);
+  });
+  if (selection.eq(state.selection))
+    return false;
+  let effect;
+  if (page.selfScroll) {
+    let startPos = view.coordsAtPos(state.selection.main.head);
+    let scrollRect = view.scrollDOM.getBoundingClientRect();
+    let scrollTop = scrollRect.top + page.marginTop, scrollBottom = scrollRect.bottom - page.marginBottom;
+    if (startPos && startPos.top > scrollTop && startPos.bottom < scrollBottom)
+      effect = EditorView.scrollIntoView(selection.main.head, { y: "start", yMargin: startPos.top - scrollTop });
+  }
+  view.dispatch(setSel(state, selection), { effects: effect });
+  return true;
+}
+var cursorPageUp = (view) => cursorByPage(view, false);
+var cursorPageDown = (view) => cursorByPage(view, true);
+function moveByLineBoundary(view, start, forward) {
+  let line = view.lineBlockAt(start.head), moved = view.moveToLineBoundary(start, forward);
+  if (moved.head == start.head && moved.head != (forward ? line.to : line.from))
+    moved = view.moveToLineBoundary(start, forward, false);
+  if (!forward && moved.head == line.from && line.length) {
+    let space = /^\s*/.exec(view.state.sliceDoc(line.from, Math.min(line.from + 100, line.to)))[0].length;
+    if (space && start.head != line.from + space)
+      moved = EditorSelection.cursor(line.from + space);
+  }
+  return moved;
+}
+var cursorLineBoundaryForward = (view) => moveSel(view, (range) => moveByLineBoundary(view, range, true));
+var cursorLineBoundaryBackward = (view) => moveSel(view, (range) => moveByLineBoundary(view, range, false));
+var cursorLineBoundaryLeft = (view) => moveSel(view, (range) => moveByLineBoundary(view, range, !ltrAtCursor(view)));
+var cursorLineBoundaryRight = (view) => moveSel(view, (range) => moveByLineBoundary(view, range, ltrAtCursor(view)));
+var cursorLineStart = (view) => moveSel(view, (range) => EditorSelection.cursor(view.lineBlockAt(range.head).from, 1));
+var cursorLineEnd = (view) => moveSel(view, (range) => EditorSelection.cursor(view.lineBlockAt(range.head).to, -1));
+function toMatchingBracket(state, dispatch, extend) {
+  let found = false, selection = updateSel(state.selection, (range) => {
+    let matching = matchBrackets(state, range.head, -1) || matchBrackets(state, range.head, 1) || range.head > 0 && matchBrackets(state, range.head - 1, 1) || range.head < state.doc.length && matchBrackets(state, range.head + 1, -1);
+    if (!matching || !matching.end)
+      return range;
+    found = true;
+    let head = matching.start.from == range.head ? matching.end.to : matching.end.from;
+    return extend ? EditorSelection.range(range.anchor, head) : EditorSelection.cursor(head);
+  });
+  if (!found)
+    return false;
+  dispatch(setSel(state, selection));
+  return true;
+}
+var cursorMatchingBracket = ({ state, dispatch }) => toMatchingBracket(state, dispatch, false);
+function extendSel(target, forward, how) {
+  let selection = updateSel(target.state.selection, (range) => {
+    if (range.undirectional && range.head >= range.anchor != forward)
+      range = EditorSelection.range(range.head, range.anchor);
+    let head = how(range);
+    return EditorSelection.range(range.anchor, head.head, head.goalColumn, head.bidiLevel || void 0, head.assoc);
+  });
+  if (selection.eq(target.state.selection))
+    return false;
+  target.dispatch(setSel(target.state, selection));
+  return true;
+}
+function selectByChar(view, forward) {
+  return extendSel(view, forward, (range) => view.moveByChar(range, forward));
+}
+var selectCharLeft = (view) => selectByChar(view, !ltrAtCursor(view));
+var selectCharRight = (view) => selectByChar(view, ltrAtCursor(view));
+function selectByGroup(view, forward) {
+  return extendSel(view, forward, (range) => view.moveByGroup(range, forward));
+}
+var selectGroupLeft = (view) => selectByGroup(view, !ltrAtCursor(view));
+var selectGroupRight = (view) => selectByGroup(view, ltrAtCursor(view));
+var selectSyntaxLeft = (view) => {
+  let forward = !ltrAtCursor(view);
+  return extendSel(view, forward, (range) => moveBySyntax(view.state, range, forward));
+};
+var selectSyntaxRight = (view) => {
+  let forward = ltrAtCursor(view);
+  return extendSel(view, forward, (range) => moveBySyntax(view.state, range, forward));
+};
+function selectByLine(view, forward) {
+  return extendSel(view, forward, (range) => view.moveVertically(range, forward));
+}
+var selectLineUp = (view) => selectByLine(view, false);
+var selectLineDown = (view) => selectByLine(view, true);
+function selectByPage(view, forward) {
+  return extendSel(view, forward, (range) => view.moveVertically(range, forward, pageInfo(view).height));
+}
+var selectPageUp = (view) => selectByPage(view, false);
+var selectPageDown = (view) => selectByPage(view, true);
+var selectLineBoundaryForward = (view) => extendSel(view, true, (range) => moveByLineBoundary(view, range, true));
+var selectLineBoundaryBackward = (view) => extendSel(view, false, (range) => moveByLineBoundary(view, range, false));
+var selectLineBoundaryLeft = (view) => {
+  let forward = !ltrAtCursor(view);
+  return extendSel(view, forward, (range) => moveByLineBoundary(view, range, forward));
+};
+var selectLineBoundaryRight = (view) => {
+  let forward = ltrAtCursor(view);
+  return extendSel(view, forward, (range) => moveByLineBoundary(view, range, forward));
+};
+var selectLineStart = (view) => extendSel(view, false, (range) => EditorSelection.cursor(view.lineBlockAt(range.head).from));
+var selectLineEnd = (view) => extendSel(view, true, (range) => EditorSelection.cursor(view.lineBlockAt(range.head).to));
+var cursorDocStart = ({ state, dispatch }) => {
+  dispatch(setSel(state, { anchor: 0 }));
+  return true;
+};
+var cursorDocEnd = ({ state, dispatch }) => {
+  dispatch(setSel(state, { anchor: state.doc.length }));
+  return true;
+};
+var selectDocStart = ({ state, dispatch }) => {
+  dispatch(setSel(state, { anchor: state.selection.main.anchor, head: 0 }));
+  return true;
+};
+var selectDocEnd = ({ state, dispatch }) => {
+  dispatch(setSel(state, { anchor: state.selection.main.anchor, head: state.doc.length }));
+  return true;
+};
+var selectAll = ({ state, dispatch }) => {
+  dispatch(state.update({ selection: { anchor: 0, head: state.doc.length }, userEvent: "select" }));
+  return true;
+};
+var selectLine = ({ state, dispatch }) => {
+  let ranges = selectedLineBlocks(state).map(({ from, to }) => EditorSelection.range(from, Math.min(to + 1, state.doc.length)));
+  dispatch(state.update({ selection: EditorSelection.create(ranges), userEvent: "select" }));
+  return true;
+};
+var selectParentSyntax = ({ state, dispatch }) => {
+  let selection = updateSel(state.selection, (range) => {
+    let tree = syntaxTree(state), stack = tree.resolveStack(range.from, 1);
+    if (range.empty) {
+      let stackBefore = tree.resolveStack(range.from, -1);
+      if (stackBefore.node.from >= stack.node.from && stackBefore.node.to <= stack.node.to)
+        stack = stackBefore;
+    }
+    for (let cur = stack; cur; cur = cur.next) {
+      let { node } = cur;
+      if ((node.from < range.from && node.to >= range.to || node.to > range.to && node.from <= range.from) && cur.next)
+        return EditorSelection.range(node.to, node.from);
+    }
+    return range;
+  });
+  if (selection.eq(state.selection))
+    return false;
+  dispatch(setSel(state, selection));
+  return true;
+};
+function addCursorVertically(view, forward) {
+  let { state } = view, sel = state.selection, ranges = state.selection.ranges.slice();
+  for (let range of state.selection.ranges) {
+    let line = state.doc.lineAt(range.head);
+    if (forward ? line.to < view.state.doc.length : line.from > 0)
+      for (let cur = range; ; ) {
+        let next = view.moveVertically(cur, forward);
+        if (next.head < line.from || next.head > line.to) {
+          if (!ranges.some((r) => r.head == next.head))
+            ranges.push(next);
+          break;
+        } else if (next.head == cur.head) {
+          break;
+        } else {
+          cur = next;
+        }
+      }
+  }
+  if (ranges.length == sel.ranges.length)
+    return false;
+  view.dispatch(setSel(state, EditorSelection.create(ranges, ranges.length - 1)));
+  return true;
+}
+var addCursorAbove = (view) => addCursorVertically(view, false);
+var addCursorBelow = (view) => addCursorVertically(view, true);
+var simplifySelection = ({ state, dispatch }) => {
+  let cur = state.selection, selection = null;
+  if (cur.ranges.length > 1)
+    selection = EditorSelection.create([cur.main]);
+  else if (!cur.main.empty)
+    selection = EditorSelection.create([EditorSelection.cursor(cur.main.head)]);
+  if (!selection)
+    return false;
+  dispatch(setSel(state, selection));
+  return true;
+};
+function deleteBy(target, by) {
+  if (target.state.readOnly)
+    return false;
+  let event = "delete.selection", { state } = target;
+  let changes = state.changeByRange((range) => {
+    let { from, to } = range;
+    if (from == to) {
+      let towards = by(range);
+      if (towards < from) {
+        event = "delete.backward";
+        towards = skipAtomic(target, towards, false);
+      } else if (towards > from) {
+        event = "delete.forward";
+        towards = skipAtomic(target, towards, true);
+      }
+      from = Math.min(from, towards);
+      to = Math.max(to, towards);
+    } else {
+      from = skipAtomic(target, from, false);
+      to = skipAtomic(target, to, true);
+    }
+    return from == to ? { range } : { changes: { from, to }, range: EditorSelection.cursor(from, from < range.head ? -1 : 1) };
+  });
+  if (changes.changes.empty)
+    return false;
+  target.dispatch(state.update(changes, {
+    scrollIntoView: true,
+    userEvent: event,
+    effects: event == "delete.selection" ? EditorView.announce.of(state.phrase("Selection deleted")) : void 0
+  }));
+  return true;
+}
+function skipAtomic(target, pos, forward) {
+  if (target instanceof EditorView)
+    for (let ranges of target.state.facet(EditorView.atomicRanges).map((f) => f(target)))
+      ranges.between(pos, pos, (from, to) => {
+        if (from < pos && to > pos)
+          pos = forward ? to : from;
+      });
+  return pos;
+}
+var deleteByChar = (target, forward, byIndentUnit) => deleteBy(target, (range) => {
+  let pos = range.from, { state } = target, line = state.doc.lineAt(pos), before, targetPos;
+  if (byIndentUnit && !forward && pos > line.from && pos < line.from + 200 && !/[^ \t]/.test(before = line.text.slice(0, pos - line.from))) {
+    if (before[before.length - 1] == "	")
+      return pos - 1;
+    let col = countColumn(before, state.tabSize), drop = col % getIndentUnit(state) || getIndentUnit(state);
+    for (let i = 0; i < drop && before[before.length - 1 - i] == " "; i++)
+      pos--;
+    targetPos = pos;
+  } else {
+    targetPos = findClusterBreak(line.text, pos - line.from, forward, forward) + line.from;
+    if (targetPos == pos && line.number != (forward ? state.doc.lines : 1))
+      targetPos += forward ? 1 : -1;
+    else if (!forward && /[\ufe00-\ufe0f]/.test(line.text.slice(targetPos - line.from, pos - line.from)))
+      targetPos = findClusterBreak(line.text, targetPos - line.from, false, false) + line.from;
+  }
+  return targetPos;
+});
+var deleteCharBackward = (view) => deleteByChar(view, false, true);
+var deleteCharForward = (view) => deleteByChar(view, true, false);
+var deleteByGroup = (target, forward) => deleteBy(target, (range) => {
+  let pos = range.head, { state } = target, line = state.doc.lineAt(pos);
+  let categorize = state.charCategorizer(pos);
+  for (let cat = null; ; ) {
+    if (pos == (forward ? line.to : line.from)) {
+      if (pos == range.head && line.number != (forward ? state.doc.lines : 1))
+        pos += forward ? 1 : -1;
+      break;
+    }
+    let next = findClusterBreak(line.text, pos - line.from, forward) + line.from;
+    let nextChar = line.text.slice(Math.min(pos, next) - line.from, Math.max(pos, next) - line.from);
+    let nextCat = categorize(nextChar);
+    if (cat != null && nextCat != cat)
+      break;
+    if (nextChar != " " || pos != range.head)
+      cat = nextCat;
+    pos = next;
+  }
+  return pos;
+});
+var deleteGroupBackward = (target) => deleteByGroup(target, false);
+var deleteGroupForward = (target) => deleteByGroup(target, true);
+var deleteToLineEnd = (view) => deleteBy(view, (range) => {
+  let lineEnd = view.lineBlockAt(range.head).to;
+  return range.head < lineEnd ? lineEnd : Math.min(view.state.doc.length, range.head + 1);
+});
+var deleteLineBoundaryBackward = (view) => deleteBy(view, (range) => {
+  let lineStart = view.moveToLineBoundary(range, false).head;
+  return range.head > lineStart ? lineStart : Math.max(0, range.head - 1);
+});
+var deleteLineBoundaryForward = (view) => deleteBy(view, (range) => {
+  let lineStart = view.moveToLineBoundary(range, true).head;
+  return range.head < lineStart ? lineStart : Math.min(view.state.doc.length, range.head + 1);
+});
+var splitLine = ({ state, dispatch }) => {
+  if (state.readOnly)
+    return false;
+  let changes = state.changeByRange((range) => {
+    return {
+      changes: { from: range.from, to: range.to, insert: Text.of(["", ""]) },
+      range: EditorSelection.cursor(range.from)
+    };
+  });
+  dispatch(state.update(changes, { scrollIntoView: true, userEvent: "input" }));
+  return true;
+};
+var transposeChars = ({ state, dispatch }) => {
+  if (state.readOnly)
+    return false;
+  let changes = state.changeByRange((range) => {
+    if (!range.empty || range.from == 0 || range.from == state.doc.length)
+      return { range };
+    let pos = range.from, line = state.doc.lineAt(pos);
+    let from = pos == line.from ? pos - 1 : findClusterBreak(line.text, pos - line.from, false) + line.from;
+    let to = pos == line.to ? pos + 1 : findClusterBreak(line.text, pos - line.from, true) + line.from;
+    return {
+      changes: { from, to, insert: state.doc.slice(pos, to).append(state.doc.slice(from, pos)) },
+      range: EditorSelection.cursor(to)
+    };
+  });
+  if (changes.changes.empty)
+    return false;
+  dispatch(state.update(changes, { scrollIntoView: true, userEvent: "move.character" }));
+  return true;
+};
+function selectedLineBlocks(state) {
+  let blocks = [], upto = -1;
+  for (let range of state.selection.ranges) {
+    let startLine = state.doc.lineAt(range.from), endLine = state.doc.lineAt(range.to);
+    if (!range.empty && range.to == endLine.from)
+      endLine = state.doc.lineAt(range.to - 1);
+    if (upto >= startLine.number) {
+      let prev = blocks[blocks.length - 1];
+      prev.to = endLine.to;
+      prev.ranges.push(range);
+    } else {
+      blocks.push({ from: startLine.from, to: endLine.to, ranges: [range] });
+    }
+    upto = endLine.number + 1;
+  }
+  return blocks;
+}
+function moveLine(state, dispatch, forward) {
+  if (state.readOnly)
+    return false;
+  let changes = [], ranges = [];
+  for (let block of selectedLineBlocks(state)) {
+    if (forward ? block.to == state.doc.length : block.from == 0)
+      continue;
+    let nextLine = state.doc.lineAt(forward ? block.to + 1 : block.from - 1);
+    let size = nextLine.length + 1;
+    if (forward) {
+      changes.push({ from: block.to, to: nextLine.to }, { from: block.from, insert: nextLine.text + state.lineBreak });
+      for (let r of block.ranges)
+        ranges.push(EditorSelection.range(Math.min(state.doc.length, r.anchor + size), Math.min(state.doc.length, r.head + size)));
+    } else {
+      changes.push({ from: nextLine.from, to: block.from }, { from: block.to, insert: state.lineBreak + nextLine.text });
+      for (let r of block.ranges)
+        ranges.push(EditorSelection.range(r.anchor - size, r.head - size));
+    }
+  }
+  if (!changes.length)
+    return false;
+  dispatch(state.update({
+    changes,
+    scrollIntoView: true,
+    selection: EditorSelection.create(ranges, state.selection.mainIndex),
+    userEvent: "move.line"
+  }));
+  return true;
+}
+var moveLineUp = ({ state, dispatch }) => moveLine(state, dispatch, false);
+var moveLineDown = ({ state, dispatch }) => moveLine(state, dispatch, true);
+function copyLine(state, dispatch, forward) {
+  if (state.readOnly)
+    return false;
+  let changes = [];
+  for (let block of selectedLineBlocks(state)) {
+    if (forward)
+      changes.push({ from: block.from, insert: state.doc.slice(block.from, block.to) + state.lineBreak });
+    else
+      changes.push({ from: block.to, insert: state.lineBreak + state.doc.slice(block.from, block.to) });
+  }
+  let changeSet = state.changes(changes);
+  dispatch(state.update({
+    changes: changeSet,
+    selection: state.selection.map(changeSet, forward ? 1 : -1),
+    scrollIntoView: true,
+    userEvent: "input.copyline"
+  }));
+  return true;
+}
+var copyLineUp = ({ state, dispatch }) => copyLine(state, dispatch, false);
+var copyLineDown = ({ state, dispatch }) => copyLine(state, dispatch, true);
+var deleteLine = (view) => {
+  if (view.state.readOnly)
+    return false;
+  let { state } = view, changes = state.changes(selectedLineBlocks(state).map(({ from, to }) => {
+    if (from > 0)
+      from--;
+    else if (to < state.doc.length)
+      to++;
+    return { from, to };
+  }));
+  let selection = updateSel(state.selection, (range) => {
+    let dist = void 0;
+    if (view.lineWrapping) {
+      let block = view.lineBlockAt(range.head), pos = view.coordsAtPos(range.head, range.assoc || 1);
+      if (pos)
+        dist = block.bottom + view.documentTop - pos.bottom + view.defaultLineHeight / 2;
+    }
+    return view.moveVertically(range, true, dist);
+  }).map(changes);
+  view.dispatch({ changes, selection, scrollIntoView: true, userEvent: "delete.line" });
+  return true;
+};
+function isBetweenBrackets(state, pos) {
+  if (/\(\)|\[\]|\{\}/.test(state.sliceDoc(pos - 1, pos + 1)))
+    return { from: pos, to: pos };
+  let context = syntaxTree(state).resolveInner(pos);
+  let before = context.childBefore(pos), after = context.childAfter(pos), closedBy;
+  if (before && after && before.to <= pos && after.from >= pos && (closedBy = before.type.prop(NodeProp.closedBy)) && closedBy.indexOf(after.name) > -1 && state.doc.lineAt(before.to).from == state.doc.lineAt(after.from).from && !/\S/.test(state.sliceDoc(before.to, after.from)))
+    return { from: before.to, to: after.from };
+  return null;
+}
+var insertNewlineAndIndent = /* @__PURE__ */ newlineAndIndent(false);
+var insertBlankLine = /* @__PURE__ */ newlineAndIndent(true);
+function newlineAndIndent(atEof) {
+  return ({ state, dispatch }) => {
+    if (state.readOnly)
+      return false;
+    let changes = state.changeByRange((range) => {
+      let { from, to } = range, line = state.doc.lineAt(from);
+      let explode = !atEof && from == to && isBetweenBrackets(state, from);
+      if (atEof)
+        from = to = (to <= line.to ? line : state.doc.lineAt(to)).to;
+      let cx = new IndentContext(state, { simulateBreak: from, simulateDoubleBreak: !!explode });
+      let indent = getIndentation(cx, from);
+      if (indent == null)
+        indent = countColumn(/^\s*/.exec(state.doc.lineAt(from).text)[0], state.tabSize);
+      while (to < line.to && /\s/.test(line.text[to - line.from]))
+        to++;
+      if (explode)
+        ({ from, to } = explode);
+      else if (from > line.from && from < line.from + 100 && !/\S/.test(line.text.slice(0, from)))
+        from = line.from;
+      let insert = ["", indentString(state, indent)];
+      if (explode)
+        insert.push(indentString(state, cx.lineIndent(line.from, -1)));
+      return {
+        changes: { from, to, insert: Text.of(insert) },
+        range: EditorSelection.cursor(from + 1 + insert[1].length)
+      };
+    });
+    dispatch(state.update(changes, { scrollIntoView: true, userEvent: "input" }));
+    return true;
+  };
+}
+function changeBySelectedLine(state, f) {
+  let atLine = -1;
+  return state.changeByRange((range) => {
+    let changes = [];
+    for (let pos = range.from; pos <= range.to; ) {
+      let line = state.doc.lineAt(pos);
+      if (line.number > atLine && (range.empty || range.to > line.from)) {
+        f(line, changes, range);
+        atLine = line.number;
+      }
+      pos = line.to + 1;
+    }
+    let changeSet = state.changes(changes);
+    return {
+      changes,
+      range: EditorSelection.range(changeSet.mapPos(range.anchor, 1), changeSet.mapPos(range.head, 1))
+    };
+  });
+}
+var indentSelection = ({ state, dispatch }) => {
+  if (state.readOnly)
+    return false;
+  let updated = /* @__PURE__ */ Object.create(null);
+  let context = new IndentContext(state, { overrideIndentation: (start) => {
+    let found = updated[start];
+    return found == null ? -1 : found;
+  } });
+  let changes = changeBySelectedLine(state, (line, changes2, range) => {
+    let indent = getIndentation(context, line.from);
+    if (indent == null)
+      return;
+    if (!/\S/.test(line.text))
+      indent = 0;
+    let cur = /^\s*/.exec(line.text)[0];
+    let norm = indentString(state, indent);
+    if (cur != norm || range.from < line.from + cur.length) {
+      updated[line.from] = indent;
+      changes2.push({ from: line.from, to: line.from + cur.length, insert: norm });
+    }
+  });
+  if (!changes.changes.empty)
+    dispatch(state.update(changes, { userEvent: "indent" }));
+  return true;
+};
+var indentMore = ({ state, dispatch }) => {
+  if (state.readOnly)
+    return false;
+  dispatch(state.update(changeBySelectedLine(state, (line, changes) => {
+    changes.push({ from: line.from, insert: state.facet(indentUnit) });
+  }), { userEvent: "input.indent" }));
+  return true;
+};
+var indentLess = ({ state, dispatch }) => {
+  if (state.readOnly)
+    return false;
+  dispatch(state.update(changeBySelectedLine(state, (line, changes) => {
+    let space = /^\s*/.exec(line.text)[0];
+    if (!space)
+      return;
+    let col = countColumn(space, state.tabSize), keep = 0;
+    let insert = indentString(state, Math.max(0, col - getIndentUnit(state)));
+    while (keep < space.length && keep < insert.length && space.charCodeAt(keep) == insert.charCodeAt(keep))
+      keep++;
+    changes.push({ from: line.from + keep, to: line.from + space.length, insert: insert.slice(keep) });
+  }), { userEvent: "delete.dedent" }));
+  return true;
+};
+var toggleTabFocusMode = (view) => {
+  view.setTabFocusMode();
+  return true;
+};
+var 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 }
+];
+var 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((b) => ({ mac: b.key, run: b.run, shift: b.shift })));
+var 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);
+var indentWithTab = { key: "Tab", run: indentMore, shift: indentLess };
+
+// ../node_modules/.pnpm/@codemirror+language-data@6.5.2/node_modules/@codemirror/language-data/dist/index.js
+function legacy(parser) {
+  return new LanguageSupport(StreamLanguage.define(parser));
+}
+function sql(dialectName) {
+  return import("../dist-UHUU7KLC.js").then((m) => m.sql({ dialect: m[dialectName] }));
+}
+var languages = [
+  // New-style language modes
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "C",
+    extensions: ["c", "h", "ino"],
+    load() {
+      return import("../dist-HHNZE2GE.js").then((m) => m.cpp());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "C++",
+    alias: ["cpp"],
+    extensions: ["cpp", "c++", "cc", "cxx", "hpp", "h++", "hh", "hxx"],
+    load() {
+      return import("../dist-HHNZE2GE.js").then((m) => m.cpp());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "CQL",
+    alias: ["cassandra"],
+    extensions: ["cql"],
+    load() {
+      return sql("Cassandra");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "CSS",
+    extensions: ["css"],
+    load() {
+      return import("../dist-52S6W6Z3.js").then((m) => m.css());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Go",
+    extensions: ["go"],
+    load() {
+      return import("../dist-WJMBFK7W.js").then((m) => m.go());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "HTML",
+    alias: ["xhtml"],
+    extensions: ["html", "htm", "handlebars", "hbs"],
+    load() {
+      return import("../dist-BOGB4NCA.js").then((m) => m.html());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Java",
+    extensions: ["java"],
+    load() {
+      return import("../dist-XJYSXJ7H.js").then((m) => m.java());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "JavaScript",
+    alias: ["ecmascript", "js", "node"],
+    extensions: ["js", "mjs", "cjs"],
+    load() {
+      return import("../dist-HNH74YPL.js").then((m) => m.javascript());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Jinja",
+    extensions: ["j2", "jinja", "jinja2"],
+    load() {
+      return import("../dist-DZ4PW5HP.js").then((m) => m.jinja());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "JSON",
+    alias: ["json5"],
+    extensions: ["json", "map"],
+    load() {
+      return import("../dist-2C6IPJHB.js").then((m) => m.json());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "JSX",
+    extensions: ["jsx"],
+    load() {
+      return import("../dist-HNH74YPL.js").then((m) => m.javascript({ jsx: true }));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "LESS",
+    extensions: ["less"],
+    load() {
+      return import("../dist-2H653DKD.js").then((m) => m.less());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Liquid",
+    extensions: ["liquid"],
+    load() {
+      return import("../dist-5KN6ODPO.js").then((m) => m.liquid());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "MariaDB SQL",
+    load() {
+      return sql("MariaSQL");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Markdown",
+    extensions: ["md", "markdown", "mkd"],
+    load() {
+      return import("../dist-LBQUKRIG.js").then((m) => m.markdown());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "MS SQL",
+    load() {
+      return sql("MSSQL");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "MySQL",
+    load() {
+      return sql("MySQL");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "PHP",
+    extensions: ["php", "php3", "php4", "php5", "php7", "phtml"],
+    load() {
+      return import("../dist-NISFJM3T.js").then((m) => m.php());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "PLSQL",
+    extensions: ["pls"],
+    load() {
+      return sql("PLSQL");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "PostgreSQL",
+    load() {
+      return sql("PostgreSQL");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Python",
+    extensions: ["BUILD", "bzl", "py", "pyw"],
+    filename: /^(BUCK|BUILD)$/,
+    load() {
+      return import("../dist-Q7P6VH6H.js").then((m) => m.python());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Rust",
+    extensions: ["rs"],
+    load() {
+      return import("../dist-YY24ZXZD.js").then((m) => m.rust());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Sass",
+    extensions: ["sass"],
+    load() {
+      return import("../dist-G2KVVLNT.js").then((m) => m.sass({ indented: true }));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SCSS",
+    extensions: ["scss"],
+    load() {
+      return import("../dist-G2KVVLNT.js").then((m) => m.sass());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SQL",
+    extensions: ["sql"],
+    load() {
+      return sql("StandardSQL");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SQLite",
+    load() {
+      return sql("SQLite");
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "TSX",
+    extensions: ["tsx"],
+    load() {
+      return import("../dist-HNH74YPL.js").then((m) => m.javascript({ jsx: true, typescript: true }));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "TypeScript",
+    alias: ["ts"],
+    extensions: ["ts", "mts", "cts"],
+    load() {
+      return import("../dist-HNH74YPL.js").then((m) => m.javascript({ typescript: true }));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "WebAssembly",
+    extensions: ["wat", "wast"],
+    load() {
+      return import("../dist-2UJRV4FH.js").then((m) => m.wast());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "XML",
+    alias: ["rss", "wsdl", "xsd"],
+    extensions: ["xml", "xsl", "xsd", "svg"],
+    load() {
+      return import("../dist-MFKCWPLQ.js").then((m) => m.xml());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "YAML",
+    alias: ["yml"],
+    extensions: ["yaml", "yml"],
+    load() {
+      return import("../dist-RWF5A5GN.js").then((m) => m.yaml());
+    }
+  }),
+  // Legacy modes ported from CodeMirror 5
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "APL",
+    extensions: ["dyalog", "apl"],
+    load() {
+      return import("../apl-QAIM2KBM.js").then((m) => legacy(m.apl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "PGP",
+    alias: ["asciiarmor"],
+    extensions: ["asc", "pgp", "sig"],
+    load() {
+      return import("../asciiarmor-G7UKQURA.js").then((m) => legacy(m.asciiArmor));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "ASN.1",
+    extensions: ["asn", "asn1"],
+    load() {
+      return import("../asn1-JTUXKWKT.js").then((m) => legacy(m.asn1({})));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Asterisk",
+    filename: /^extensions\.conf$/i,
+    load() {
+      return import("../asterisk-NM6JCXOL.js").then((m) => legacy(m.asterisk));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Brainfuck",
+    extensions: ["b", "bf"],
+    load() {
+      return import("../brainfuck-X7FFM55E.js").then((m) => legacy(m.brainfuck));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Cobol",
+    extensions: ["cob", "cpy"],
+    load() {
+      return import("../cobol-HAM4C42S.js").then((m) => legacy(m.cobol));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "C#",
+    alias: ["csharp", "cs"],
+    extensions: ["cs"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.csharp));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Clojure",
+    extensions: ["clj", "cljc", "cljx"],
+    load() {
+      return import("../clojure-PTADSDNF.js").then((m) => legacy(m.clojure));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "ClojureScript",
+    extensions: ["cljs"],
+    load() {
+      return import("../clojure-PTADSDNF.js").then((m) => legacy(m.clojure));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Closure Stylesheets (GSS)",
+    extensions: ["gss"],
+    load() {
+      return import("../css-VQQXA3AY.js").then((m) => legacy(m.gss));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "CMake",
+    extensions: ["cmake", "cmake.in"],
+    filename: /^CMakeLists\.txt$/,
+    load() {
+      return import("../cmake-5HAC7YMH.js").then((m) => legacy(m.cmake));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "CoffeeScript",
+    alias: ["coffee", "coffee-script"],
+    extensions: ["coffee"],
+    load() {
+      return import("../coffeescript-IBRKASSJ.js").then((m) => legacy(m.coffeeScript));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Common Lisp",
+    alias: ["lisp"],
+    extensions: ["cl", "lisp", "el"],
+    load() {
+      return import("../commonlisp-KMRPB5EW.js").then((m) => legacy(m.commonLisp));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Cypher",
+    extensions: ["cyp", "cypher"],
+    load() {
+      return import("../cypher-ZZEGDGDJ.js").then((m) => legacy(m.cypher));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Cython",
+    extensions: ["pyx", "pxd", "pxi"],
+    load() {
+      return import("../python-A6P3XTMX.js").then((m) => legacy(m.cython));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Crystal",
+    extensions: ["cr"],
+    load() {
+      return import("../crystal-2MDF4EKJ.js").then((m) => legacy(m.crystal));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "D",
+    extensions: ["d"],
+    load() {
+      return import("../d-5S6PJOOT.js").then((m) => legacy(m.d));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Dart",
+    extensions: ["dart"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.dart));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "diff",
+    extensions: ["diff", "patch"],
+    load() {
+      return import("../diff-S77XBOWF.js").then((m) => legacy(m.diff));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Dockerfile",
+    filename: /^Dockerfile$/,
+    load() {
+      return import("../dockerfile-JECCOJWP.js").then((m) => legacy(m.dockerFile));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "DTD",
+    extensions: ["dtd"],
+    load() {
+      return import("../dtd-MNDWTW4Z.js").then((m) => legacy(m.dtd));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Dylan",
+    extensions: ["dylan", "dyl", "intr"],
+    load() {
+      return import("../dylan-VQ4IHJDS.js").then((m) => legacy(m.dylan));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "EBNF",
+    load() {
+      return import("../ebnf-IDZBFTCG.js").then((m) => legacy(m.ebnf));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "ECL",
+    extensions: ["ecl"],
+    load() {
+      return import("../ecl-X3ROY7E6.js").then((m) => legacy(m.ecl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "edn",
+    extensions: ["edn"],
+    load() {
+      return import("../clojure-PTADSDNF.js").then((m) => legacy(m.clojure));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Eiffel",
+    extensions: ["e"],
+    load() {
+      return import("../eiffel-WB3M7Y2E.js").then((m) => legacy(m.eiffel));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Elm",
+    extensions: ["elm"],
+    load() {
+      return import("../elm-VHXR6ZA3.js").then((m) => legacy(m.elm));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Erlang",
+    extensions: ["erl"],
+    load() {
+      return import("../erlang-7ZBDDQDV.js").then((m) => legacy(m.erlang));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Esper",
+    load() {
+      return import("../sql-ML2Q43YF.js").then((m) => legacy(m.esper));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Factor",
+    extensions: ["factor"],
+    load() {
+      return import("../factor-IKT2GQE2.js").then((m) => legacy(m.factor));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "FCL",
+    load() {
+      return import("../fcl-CNBUVGUC.js").then((m) => legacy(m.fcl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Forth",
+    extensions: ["forth", "fth", "4th"],
+    load() {
+      return import("../forth-4BTPWSFZ.js").then((m) => legacy(m.forth));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Fortran",
+    extensions: ["f", "for", "f77", "f90", "f95"],
+    load() {
+      return import("../fortran-V6F5DQPK.js").then((m) => legacy(m.fortran));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "F#",
+    alias: ["fsharp"],
+    extensions: ["fs"],
+    load() {
+      return import("../mllike-C2YS6SJI.js").then((m) => legacy(m.fSharp));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Gas",
+    extensions: ["s"],
+    load() {
+      return import("../gas-4DLP6BC4.js").then((m) => legacy(m.gas));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Gherkin",
+    extensions: ["feature"],
+    load() {
+      return import("../gherkin-OSGPX6HI.js").then((m) => legacy(m.gherkin));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Groovy",
+    extensions: ["groovy", "gradle"],
+    filename: /^Jenkinsfile$/,
+    load() {
+      return import("../groovy-R2JW63QF.js").then((m) => legacy(m.groovy));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Haskell",
+    extensions: ["hs"],
+    load() {
+      return import("../haskell-GG7T4J6H.js").then((m) => legacy(m.haskell));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Haxe",
+    extensions: ["hx"],
+    load() {
+      return import("../haxe-ESFUJKSE.js").then((m) => legacy(m.haxe));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "HXML",
+    extensions: ["hxml"],
+    load() {
+      return import("../haxe-ESFUJKSE.js").then((m) => legacy(m.hxml));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "HTTP",
+    load() {
+      return import("../http-SZLSACOW.js").then((m) => legacy(m.http));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "IDL",
+    extensions: ["pro"],
+    load() {
+      return import("../idl-V7UH35RP.js").then((m) => legacy(m.idl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "JSON-LD",
+    alias: ["jsonld"],
+    extensions: ["jsonld"],
+    load() {
+      return import("../javascript-MGRPKFDN.js").then((m) => legacy(m.jsonld));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Julia",
+    extensions: ["jl"],
+    load() {
+      return import("../julia-CWCVZVPG.js").then((m) => legacy(m.julia));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Kotlin",
+    extensions: ["kt", "kts"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.kotlin));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "LiveScript",
+    alias: ["ls"],
+    extensions: ["ls"],
+    load() {
+      return import("../livescript-IGKT2FL7.js").then((m) => legacy(m.liveScript));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Lua",
+    extensions: ["lua"],
+    load() {
+      return import("../lua-GHK7GCTS.js").then((m) => legacy(m.lua));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "mIRC",
+    extensions: ["mrc"],
+    load() {
+      return import("../mirc-WYJEQUBY.js").then((m) => legacy(m.mirc));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Mathematica",
+    extensions: ["m", "nb", "wl", "wls"],
+    load() {
+      return import("../mathematica-W5LMQI3M.js").then((m) => legacy(m.mathematica));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Modelica",
+    extensions: ["mo"],
+    load() {
+      return import("../modelica-BMJSLZS7.js").then((m) => legacy(m.modelica));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "MUMPS",
+    extensions: ["mps"],
+    load() {
+      return import("../mumps-BYE6H7ZX.js").then((m) => legacy(m.mumps));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Mbox",
+    extensions: ["mbox"],
+    load() {
+      return import("../mbox-A7CXJ4HZ.js").then((m) => legacy(m.mbox));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Nginx",
+    filename: /nginx.*\.conf$/i,
+    load() {
+      return import("../nginx-Y54HR7MQ.js").then((m) => legacy(m.nginx));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "NSIS",
+    extensions: ["nsh", "nsi"],
+    load() {
+      return import("../nsis-UZLPE2DL.js").then((m) => legacy(m.nsis));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "NTriples",
+    extensions: ["nt", "nq"],
+    load() {
+      return import("../ntriples-SAI3J2VH.js").then((m) => legacy(m.ntriples));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Objective-C",
+    alias: ["objective-c", "objc"],
+    extensions: ["m"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.objectiveC));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Objective-C++",
+    alias: ["objective-c++", "objc++"],
+    extensions: ["mm"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.objectiveCpp));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "OCaml",
+    extensions: ["ml", "mli", "mll", "mly"],
+    load() {
+      return import("../mllike-C2YS6SJI.js").then((m) => legacy(m.oCaml));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Octave",
+    extensions: ["m"],
+    load() {
+      return import("../octave-TLUBYOUX.js").then((m) => legacy(m.octave));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Oz",
+    extensions: ["oz"],
+    load() {
+      return import("../oz-F6LNIR6Q.js").then((m) => legacy(m.oz));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Pascal",
+    extensions: ["p", "pas"],
+    load() {
+      return import("../pascal-WINE2FE6.js").then((m) => legacy(m.pascal));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Perl",
+    extensions: ["pl", "pm"],
+    load() {
+      return import("../perl-NZG3EIBE.js").then((m) => legacy(m.perl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Pig",
+    extensions: ["pig"],
+    load() {
+      return import("../pig-U7OFLRCV.js").then((m) => legacy(m.pig));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "PowerShell",
+    extensions: ["ps1", "psd1", "psm1"],
+    load() {
+      return import("../powershell-ZSUS7P6D.js").then((m) => legacy(m.powerShell));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Properties files",
+    alias: ["ini", "properties"],
+    extensions: ["properties", "ini", "in"],
+    load() {
+      return import("../properties-IJRU6UJW.js").then((m) => legacy(m.properties));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "ProtoBuf",
+    extensions: ["proto"],
+    load() {
+      return import("../protobuf-2KETQIQ5.js").then((m) => legacy(m.protobuf));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Pug",
+    alias: ["jade"],
+    extensions: ["pug", "jade"],
+    load() {
+      return import("../pug-IQCJJAZU.js").then((m) => legacy(m.pug));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Puppet",
+    extensions: ["pp"],
+    load() {
+      return import("../puppet-YIIDDH6A.js").then((m) => legacy(m.puppet));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Q",
+    extensions: ["q"],
+    load() {
+      return import("../q-2KXN5RX7.js").then((m) => legacy(m.q));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "R",
+    alias: ["rscript"],
+    extensions: ["r", "R"],
+    load() {
+      return import("../r-BB4MIIBH.js").then((m) => legacy(m.r));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "RPM Changes",
+    load() {
+      return import("../rpm-LMR25AQ3.js").then((m) => legacy(m.rpmChanges));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "RPM Spec",
+    extensions: ["spec"],
+    load() {
+      return import("../rpm-LMR25AQ3.js").then((m) => legacy(m.rpmSpec));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Ruby",
+    alias: ["jruby", "macruby", "rake", "rb", "rbx"],
+    extensions: ["rb"],
+    filename: /^(Gemfile|Rakefile)$/,
+    load() {
+      return import("../ruby-TSD6FT73.js").then((m) => legacy(m.ruby));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SAS",
+    extensions: ["sas"],
+    load() {
+      return import("../sas-6X4WWIGV.js").then((m) => legacy(m.sas));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Scala",
+    extensions: ["scala"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.scala));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Scheme",
+    extensions: ["scm", "ss"],
+    load() {
+      return import("../scheme-E3I46HBL.js").then((m) => legacy(m.scheme));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Shell",
+    alias: ["bash", "sh", "zsh"],
+    extensions: ["sh", "ksh", "bash"],
+    filename: /^PKGBUILD$/,
+    load() {
+      return import("../shell-GX3PRI4I.js").then((m) => legacy(m.shell));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Sieve",
+    extensions: ["siv", "sieve"],
+    load() {
+      return import("../sieve-V65ZPL4F.js").then((m) => legacy(m.sieve));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Smalltalk",
+    extensions: ["st"],
+    load() {
+      return import("../smalltalk-OVKP2CVW.js").then((m) => legacy(m.smalltalk));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Solr",
+    load() {
+      return import("../solr-C4DLQJCF.js").then((m) => legacy(m.solr));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SML",
+    extensions: ["sml", "sig", "fun", "smackspec"],
+    load() {
+      return import("../mllike-C2YS6SJI.js").then((m) => legacy(m.sml));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SPARQL",
+    alias: ["sparul"],
+    extensions: ["rq", "sparql"],
+    load() {
+      return import("../sparql-REKUW7B3.js").then((m) => legacy(m.sparql));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Spreadsheet",
+    alias: ["excel", "formula"],
+    load() {
+      return import("../spreadsheet-S7NN2YTQ.js").then((m) => legacy(m.spreadsheet));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Squirrel",
+    extensions: ["nut"],
+    load() {
+      return import("../clike-DOBZTBQN.js").then((m) => legacy(m.squirrel));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Stylus",
+    extensions: ["styl"],
+    load() {
+      return import("../stylus-3ONNYZOM.js").then((m) => legacy(m.stylus));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Swift",
+    extensions: ["swift"],
+    load() {
+      return import("../swift-CNWGZ22Y.js").then((m) => legacy(m.swift));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "sTeX",
+    load() {
+      return import("../stex-TCOGKBT4.js").then((m) => legacy(m.stex));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "LaTeX",
+    alias: ["tex"],
+    extensions: ["text", "ltx", "tex"],
+    load() {
+      return import("../stex-TCOGKBT4.js").then((m) => legacy(m.stex));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "SystemVerilog",
+    extensions: ["v", "sv", "svh"],
+    load() {
+      return import("../verilog-7VEWVDW6.js").then((m) => legacy(m.verilog));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Tcl",
+    extensions: ["tcl"],
+    load() {
+      return import("../tcl-77IMAZYE.js").then((m) => legacy(m.tcl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Textile",
+    extensions: ["textile"],
+    load() {
+      return import("../textile-6IWIIKFM.js").then((m) => legacy(m.textile));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "TiddlyWiki",
+    load() {
+      return import("../tiddlywiki-IJSZMUSA.js").then((m) => legacy(m.tiddlyWiki));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Tiki wiki",
+    load() {
+      return import("../tiki-HG37JJIT.js").then((m) => legacy(m.tiki));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "TOML",
+    extensions: ["toml"],
+    load() {
+      return import("../toml-NINU2IMM.js").then((m) => legacy(m.toml));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Troff",
+    extensions: ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    load() {
+      return import("../troff-AOQJ4Q4C.js").then((m) => legacy(m.troff));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "TTCN",
+    extensions: ["ttcn", "ttcn3", "ttcnpp"],
+    load() {
+      return import("../ttcn-TLOZ3FX3.js").then((m) => legacy(m.ttcn));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "TTCN_CFG",
+    extensions: ["cfg"],
+    load() {
+      return import("../ttcn-cfg-3B6QY7QE.js").then((m) => legacy(m.ttcnCfg));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Turtle",
+    extensions: ["ttl"],
+    load() {
+      return import("../turtle-3N5KCGXP.js").then((m) => legacy(m.turtle));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Web IDL",
+    extensions: ["webidl"],
+    load() {
+      return import("../webidl-SLQFEELK.js").then((m) => legacy(m.webIDL));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "VB.NET",
+    extensions: ["vb"],
+    load() {
+      return import("../vb-I7M5DRLP.js").then((m) => legacy(m.vb));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "VBScript",
+    extensions: ["vbs"],
+    load() {
+      return import("../vbscript-U2ARSJLD.js").then((m) => legacy(m.vbScript));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Velocity",
+    extensions: ["vtl"],
+    load() {
+      return import("../velocity-R3AYP5XJ.js").then((m) => legacy(m.velocity));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Verilog",
+    extensions: ["v"],
+    load() {
+      return import("../verilog-7VEWVDW6.js").then((m) => legacy(m.verilog));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "VHDL",
+    extensions: ["vhd", "vhdl"],
+    load() {
+      return import("../vhdl-JZUPPGBA.js").then((m) => legacy(m.vhdl));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "XQuery",
+    extensions: ["xy", "xquery", "xq", "xqm", "xqy"],
+    load() {
+      return import("../xquery-VXP5KJ6N.js").then((m) => legacy(m.xQuery));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Yacas",
+    extensions: ["ys"],
+    load() {
+      return import("../yacas-JRBC4BEV.js").then((m) => legacy(m.yacas));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Z80",
+    extensions: ["z80"],
+    load() {
+      return import("../z80-AJF6WLUV.js").then((m) => legacy(m.z80));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "MscGen",
+    extensions: ["mscgen", "mscin", "msc"],
+    load() {
+      return import("../mscgen-5BORDYHW.js").then((m) => legacy(m.mscgen));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "X\xF9",
+    extensions: ["xu"],
+    load() {
+      return import("../mscgen-5BORDYHW.js").then((m) => legacy(m.xu));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "MsGenny",
+    extensions: ["msgenny"],
+    load() {
+      return import("../mscgen-5BORDYHW.js").then((m) => legacy(m.msgenny));
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Vue",
+    extensions: ["vue"],
+    load() {
+      return import("../dist-FDBKXKIA.js").then((m) => m.vue());
+    }
+  }),
+  /* @__PURE__ */ LanguageDescription.of({
+    name: "Angular Template",
+    load() {
+      return import("../dist-2O4EI6YQ.js").then((m) => m.angular());
+    }
+  })
+];
+
+// ../node_modules/.pnpm/@codemirror+search@6.7.1/node_modules/@codemirror/search/dist/index.js
+import { showDialog, EditorView as EditorView2, Decoration, ViewPlugin, showPanel, runScopeHandlers, getPanel } from "@codemirror/view";
+import { codePointAt, fromCodePoint, codePointSize, EditorSelection as EditorSelection2, Facet as Facet2, combineConfig as combineConfig2, CharCategory as CharCategory2, StateEffect as StateEffect2, StateField as StateField2, RangeSetBuilder, Prec, EditorState, findClusterBreak as findClusterBreak2 } from "@codemirror/state";
+
+// ../node_modules/.pnpm/crelt@1.0.7/node_modules/crelt/index.js
+function crelt() {
+  var elt = arguments[0];
+  if (typeof elt == "string") elt = document.createElement(elt);
+  var i = 1, next = arguments[1];
+  if (next && typeof next == "object" && next.nodeType == null && !Array.isArray(next)) {
+    for (var name in next) if (Object.prototype.hasOwnProperty.call(next, name)) {
+      var value = next[name];
+      if (typeof value == "string") elt.setAttribute(name, value);
+      else if (value != null) elt[name] = value;
+    }
+    i++;
+  }
+  for (; i < arguments.length; i++) add(elt, arguments[i]);
+  return elt;
+}
+function add(elt, child) {
+  if (typeof child == "string") {
+    elt.appendChild(document.createTextNode(child));
+  } else if (child == null) {
+  } else if (child.nodeType != null) {
+    elt.appendChild(child);
+  } else if (Array.isArray(child)) {
+    for (var i = 0; i < child.length; i++) add(elt, child[i]);
+  } else {
+    throw new RangeError("Unsupported child node: " + child);
+  }
+}
+
+// ../node_modules/.pnpm/@codemirror+search@6.7.1/node_modules/@codemirror/search/dist/index.js
+var basicNormalize = typeof String.prototype.normalize == "function" ? (x) => x.normalize("NFKD") : (x) => x;
+var SearchCursor = class {
+  /**
+  Create a text cursor. The query is the search string, `from` to
+  `to` provides the region to search.
+  
+  When `normalize` is given, it will be called, on both the query
+  string and the content it is matched against, before comparing.
+  You can, for example, create a case-insensitive search by
+  passing `s => s.toLowerCase()`.
+  
+  Text is always normalized with
+  [`.normalize("NFKD")`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)
+  (when supported).
+  */
+  constructor(text, query, from = 0, to = text.length, normalize, test) {
+    this.test = test;
+    this.value = { from: 0, to: 0, precise: false };
+    this.done = false;
+    this.matches = [];
+    this.buffer = "";
+    this.bufferPos = 0;
+    this.iter = text.iterRange(from, to);
+    this.bufferStart = from;
+    this.normalize = normalize ? (x) => normalize(basicNormalize(x)) : basicNormalize;
+    this.query = this.normalize(query);
+  }
+  peek() {
+    if (this.bufferPos == this.buffer.length) {
+      this.bufferStart += this.buffer.length;
+      this.iter.next();
+      if (this.iter.done)
+        return -1;
+      this.bufferPos = 0;
+      this.buffer = this.iter.value;
+    }
+    return codePointAt(this.buffer, this.bufferPos);
+  }
+  /**
+  Look for the next match. Updates the iterator's
+  [`value`](https://codemirror.net/6/docs/ref/#search.SearchCursor.value) and
+  [`done`](https://codemirror.net/6/docs/ref/#search.SearchCursor.done) properties. Should be called
+  at least once before using the cursor.
+  */
+  next() {
+    while (this.matches.length)
+      this.matches.pop();
+    return this.nextOverlapping();
+  }
+  /**
+  The `next` method will ignore matches that partially overlap a
+  previous match. This method behaves like `next`, but includes
+  such matches.
+  */
+  nextOverlapping() {
+    for (; ; ) {
+      let next = this.peek();
+      if (next < 0) {
+        this.done = true;
+        return this;
+      }
+      let str = fromCodePoint(next), start = this.bufferStart + this.bufferPos;
+      this.bufferPos += codePointSize(next);
+      let norm = this.normalize(str);
+      if (norm.length)
+        for (let i = 0, pos = start, posPrecise = true; ; i++) {
+          let code = norm.charCodeAt(i);
+          let match = this.match(code, pos, posPrecise, this.bufferPos + this.bufferStart, i == norm.length - 1);
+          if (match) {
+            this.value = match;
+            return this;
+          }
+          if (i == norm.length - 1)
+            break;
+          if (posPrecise && i < str.length && str.charCodeAt(i) == code)
+            pos++;
+          else
+            posPrecise = false;
+        }
+    }
+  }
+  match(code, pos, posPrecise, end, endPrecise) {
+    let match = null;
+    for (let i = 0; i < this.matches.length; ) {
+      let partial = this.matches[i], keep = false;
+      if (this.query.charCodeAt(partial.index) == code) {
+        if (partial.index == this.query.length - 1) {
+          match = { from: partial.from, to: end, precise: endPrecise && partial.precise };
+        } else {
+          partial.index++;
+          keep = true;
+        }
+      }
+      if (keep)
+        i++;
+      else
+        this.matches.splice(i, 1);
+    }
+    if (this.query.charCodeAt(0) == code) {
+      if (this.query.length == 1)
+        match = { from: pos, to: end, precise: posPrecise && endPrecise };
+      else
+        this.matches.push({ from: pos, index: 1, precise: posPrecise });
+    }
+    if (match && this.test && !this.test(match.from, match.to, this.buffer, this.bufferStart))
+      match = null;
+    return match;
+  }
+};
+if (typeof Symbol != "undefined")
+  SearchCursor.prototype[Symbol.iterator] = function() {
+    return this;
+  };
+var empty = { from: -1, to: -1, match: /* @__PURE__ */ /.*/.exec(""), precise: true };
+var baseFlags = "gm" + (/x/.unicode == null ? "" : "u");
+var RegExpCursor = class {
+  /**
+  Create a cursor that will search the given range in the given
+  document. `query` should be the raw pattern (as you'd pass it to
+  `new RegExp`).
+  */
+  constructor(text, query, options, from = 0, to = text.length) {
+    this.text = text;
+    this.to = to;
+    this.curLine = "";
+    this.done = false;
+    this.value = empty;
+    if (/\\[sWDnr]|\n|\r|\[\^/.test(query))
+      return new MultilineRegExpCursor(text, query, options, from, to);
+    this.re = new RegExp(query, baseFlags + ((options === null || options === void 0 ? void 0 : options.ignoreCase) ? "i" : ""));
+    this.test = options === null || options === void 0 ? void 0 : options.test;
+    this.iter = text.iter();
+    let startLine = text.lineAt(from);
+    this.curLineStart = startLine.from;
+    this.matchPos = toCharEnd(text, from);
+    this.getLine(this.curLineStart);
+  }
+  getLine(skip) {
+    this.iter.next(skip);
+    if (this.iter.lineBreak) {
+      this.curLine = "";
+    } else {
+      this.curLine = this.iter.value;
+      if (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;
+    if (this.curLineStart > this.to)
+      this.curLine = "";
+    else
+      this.getLine(0);
+  }
+  /**
+  Move to the next match, if there is one.
+  */
+  next() {
+    for (let off = this.matchPos - this.curLineStart; ; ) {
+      this.re.lastIndex = off;
+      let match = this.matchPos <= this.to && this.re.exec(this.curLine);
+      if (match) {
+        let from = this.curLineStart + match.index, to = from + match[0].length;
+        this.matchPos = toCharEnd(this.text, to + (from == to ? 1 : 0));
+        if (from == this.curLineStart + this.curLine.length)
+          this.nextLine();
+        if ((from < to || from > this.value.to) && (!this.test || this.test(from, to, match))) {
+          this.value = { from, to, precise: true, match };
+          return this;
+        }
+        off = this.matchPos - this.curLineStart;
+      } else if (this.curLineStart + this.curLine.length < this.to) {
+        this.nextLine();
+        off = 0;
+      } else {
+        this.done = true;
+        return this;
+      }
+    }
+  }
+};
+var flattened = /* @__PURE__ */ new WeakMap();
+var FlattenedDoc = class _FlattenedDoc {
+  constructor(from, text) {
+    this.from = from;
+    this.text = text;
+  }
+  get to() {
+    return this.from + this.text.length;
+  }
+  static get(doc, from, to) {
+    let cached = flattened.get(doc);
+    if (!cached || cached.from >= to || cached.to <= from) {
+      let flat = new _FlattenedDoc(from, doc.sliceString(from, to));
+      flattened.set(doc, flat);
+      return flat;
+    }
+    if (cached.from == from && cached.to == to)
+      return cached;
+    let { text, from: cachedFrom } = cached;
+    if (cachedFrom > from) {
+      text = doc.sliceString(from, cachedFrom) + text;
+      cachedFrom = from;
+    }
+    if (cached.to < to)
+      text += doc.sliceString(cached.to, to);
+    flattened.set(doc, new _FlattenedDoc(cachedFrom, text));
+    return new _FlattenedDoc(from, text.slice(from - cachedFrom, to - cachedFrom));
+  }
+};
+var MultilineRegExpCursor = class {
+  constructor(text, query, options, from, to) {
+    this.text = text;
+    this.to = to;
+    this.done = false;
+    this.value = empty;
+    this.matchPos = toCharEnd(text, from);
+    this.re = new RegExp(query, baseFlags + ((options === null || options === void 0 ? void 0 : options.ignoreCase) ? "i" : ""));
+    this.test = options === null || options === void 0 ? void 0 : options.test;
+    this.flat = FlattenedDoc.get(text, from, this.chunkEnd(
+      from + 5e3
+      /* Chunk.Base */
+    ));
+  }
+  chunkEnd(pos) {
+    return pos >= this.to ? this.to : this.text.lineAt(pos).to;
+  }
+  next() {
+    for (; ; ) {
+      let off = this.re.lastIndex = this.matchPos - this.flat.from;
+      let match = this.re.exec(this.flat.text);
+      if (match && !match[0] && match.index == off) {
+        this.re.lastIndex = off + 1;
+        match = this.re.exec(this.flat.text);
+      }
+      if (match) {
+        let from = this.flat.from + match.index, to = from + match[0].length;
+        if ((this.flat.to >= this.to || match.index + match[0].length <= this.flat.text.length - 10) && (!this.test || this.test(from, to, match))) {
+          this.value = { from, to, precise: true, match };
+          this.matchPos = toCharEnd(this.text, to + (from == to ? 1 : 0));
+          return this;
+        }
+      }
+      if (this.flat.to == this.to) {
+        this.done = true;
+        return this;
+      }
+      this.flat = FlattenedDoc.get(this.text, this.flat.from, this.chunkEnd(this.flat.from + this.flat.text.length * 2));
+    }
+  }
+};
+if (typeof Symbol != "undefined") {
+  RegExpCursor.prototype[Symbol.iterator] = MultilineRegExpCursor.prototype[Symbol.iterator] = function() {
+    return this;
+  };
+}
+function validRegExp(source) {
+  try {
+    new RegExp(source, baseFlags);
+    return true;
+  } catch (_a) {
+    return false;
+  }
+}
+function toCharEnd(text, pos) {
+  if (pos >= text.length)
+    return pos;
+  let line = text.lineAt(pos), next;
+  while (pos < line.to && (next = line.text.charCodeAt(pos - line.from)) >= 56320 && next < 57344)
+    pos++;
+  return pos;
+}
+var gotoLine = (view) => {
+  let { state } = view;
+  let line = String(state.doc.lineAt(view.state.selection.main.head).number);
+  let { close, result } = showDialog(view, {
+    label: state.phrase("Go to line"),
+    input: { type: "text", name: "line", value: line },
+    focus: true,
+    submitLabel: state.phrase("go")
+  });
+  result.then((form) => {
+    let match = form && /^([+-])?(\d+)?(:\d+)?(%)?$/.exec(form.elements["line"].value);
+    if (!match) {
+      view.dispatch({ effects: close });
+      return;
+    }
+    let startLine = state.doc.lineAt(state.selection.main.head);
+    let [, sign, ln, cl, percent] = match;
+    let col = cl ? +cl.slice(1) : 0;
+    let line2 = ln ? +ln : startLine.number;
+    if (ln && percent) {
+      let pc = line2 / 100;
+      if (sign)
+        pc = pc * (sign == "-" ? -1 : 1) + startLine.number / state.doc.lines;
+      line2 = Math.round(state.doc.lines * pc);
+    } else if (ln && sign) {
+      line2 = line2 * (sign == "-" ? -1 : 1) + startLine.number;
+    }
+    let docLine = state.doc.line(Math.max(1, Math.min(state.doc.lines, line2)));
+    let selection = EditorSelection2.cursor(docLine.from + Math.max(0, Math.min(col, docLine.length)));
+    view.dispatch({
+      effects: [close, EditorView2.scrollIntoView(selection.from, { y: "center" })],
+      selection
+    });
+  });
+  return true;
+};
+var selectWord = ({ state, dispatch }) => {
+  let { selection } = state;
+  let newSel = EditorSelection2.create(selection.ranges.map((range) => state.wordAt(range.head) || EditorSelection2.cursor(range.head)), selection.mainIndex);
+  if (newSel.eq(selection))
+    return false;
+  dispatch(state.update({ selection: newSel }));
+  return true;
+};
+function findNextOccurrence(state, query) {
+  let { main, ranges } = state.selection;
+  let word = state.wordAt(main.head), fullWord = word && word.from == main.from && word.to == main.to;
+  for (let cycled = false, cursor = new SearchCursor(state.doc, query, ranges[ranges.length - 1].to); ; ) {
+    cursor.next();
+    if (cursor.done) {
+      if (cycled)
+        return null;
+      cursor = new SearchCursor(state.doc, query, 0, Math.max(0, ranges[ranges.length - 1].from - 1));
+      cycled = true;
+    } else {
+      if (cycled && ranges.some((r) => r.from == cursor.value.from))
+        continue;
+      if (fullWord) {
+        let word2 = state.wordAt(cursor.value.from);
+        if (!word2 || word2.from != cursor.value.from || word2.to != cursor.value.to)
+          continue;
+      }
+      return cursor.value;
+    }
+  }
+}
+var selectNextOccurrence = ({ state, dispatch }) => {
+  let { ranges } = state.selection;
+  if (ranges.some((sel) => sel.from === sel.to))
+    return selectWord({ state, dispatch });
+  let searchedText = state.sliceDoc(ranges[0].from, ranges[0].to);
+  if (state.selection.ranges.some((r) => state.sliceDoc(r.from, r.to) != searchedText))
+    return false;
+  let range = findNextOccurrence(state, searchedText);
+  if (!range)
+    return false;
+  dispatch(state.update({
+    selection: state.selection.addRange(EditorSelection2.range(range.from, range.to), false),
+    effects: EditorView2.scrollIntoView(range.to)
+  }));
+  return true;
+};
+var searchConfigFacet = /* @__PURE__ */ Facet2.define({
+  combine(configs) {
+    return combineConfig2(configs, {
+      top: false,
+      caseSensitive: false,
+      literal: false,
+      regexp: false,
+      wholeWord: false,
+      createPanel: (view) => new SearchPanel(view),
+      scrollToMatch: (range) => EditorView2.scrollIntoView(range)
+    });
+  }
+});
+var SearchQuery = class {
+  /**
+  Create a query object.
+  */
+  constructor(config) {
+    this.search = config.search;
+    this.caseSensitive = !!config.caseSensitive;
+    this.literal = !!config.literal;
+    this.regexp = !!config.regexp;
+    this.replace = config.replace || "";
+    this.valid = !!this.search && (!this.regexp || validRegExp(this.search));
+    this.unquoted = this.unquote(this.search);
+    this.wholeWord = !!config.wholeWord;
+    this.test = config.test;
+  }
+  /**
+  @internal
+  */
+  unquote(text) {
+    return this.literal ? text : text.replace(/\\([nrt\\])/g, (_, ch) => ch == "n" ? "\n" : ch == "r" ? "\r" : ch == "t" ? "	" : "\\");
+  }
+  /**
+  Compare this query to another query.
+  */
+  eq(other) {
+    return this.search == other.search && this.replace == other.replace && this.caseSensitive == other.caseSensitive && this.regexp == other.regexp && this.wholeWord == other.wholeWord && this.test == other.test;
+  }
+  /**
+  @internal
+  */
+  create() {
+    return this.regexp ? new RegExpQuery(this) : new StringQuery(this);
+  }
+  /**
+  Get a search cursor for this query, searching through the given
+  range in the given state.
+  */
+  getCursor(state, from = 0, to) {
+    let st = state.doc ? state : EditorState.create({ doc: state });
+    if (to == null)
+      to = st.doc.length;
+    return this.regexp ? regexpCursor(this, st, from, to) : stringCursor(this, st, from, to);
+  }
+};
+var QueryType = class {
+  constructor(spec) {
+    this.spec = spec;
+  }
+};
+function wrapStringTest(test, state, inner) {
+  return (from, to, buffer, bufferPos) => {
+    if (inner && !inner(from, to, buffer, bufferPos))
+      return false;
+    let match = from >= bufferPos && to <= bufferPos + buffer.length ? buffer.slice(from - bufferPos, to - bufferPos) : state.doc.sliceString(from, to);
+    return test(match, state, from, to);
+  };
+}
+function stringCursor(spec, state, from, to) {
+  let test;
+  if (spec.wholeWord)
+    test = stringWordTest(state.doc, state.charCategorizer(state.selection.main.head));
+  if (spec.test)
+    test = wrapStringTest(spec.test, state, test);
+  return new SearchCursor(state.doc, spec.unquoted, from, to, spec.caseSensitive ? void 0 : (x) => x.toLowerCase(), test);
+}
+function stringWordTest(doc, categorizer) {
+  return (from, to, buf, bufPos) => {
+    if (bufPos > from || bufPos + buf.length < to) {
+      bufPos = Math.max(0, from - 2);
+      buf = doc.sliceString(bufPos, Math.min(doc.length, to + 2));
+    }
+    return (categorizer(charBefore(buf, from - bufPos)) != CharCategory2.Word || categorizer(charAfter(buf, from - bufPos)) != CharCategory2.Word) && (categorizer(charAfter(buf, to - bufPos)) != CharCategory2.Word || categorizer(charBefore(buf, to - bufPos)) != CharCategory2.Word);
+  };
+}
+var StringQuery = class extends QueryType {
+  constructor(spec) {
+    super(spec);
+  }
+  nextMatch(state, curFrom, curTo) {
+    let cursor = stringCursor(this.spec, state, curTo, state.doc.length).nextOverlapping();
+    if (cursor.done) {
+      let end = Math.min(state.doc.length, curFrom + this.spec.unquoted.length);
+      cursor = stringCursor(this.spec, state, 0, end).nextOverlapping();
+    }
+    return cursor.done || cursor.value.from == curFrom && cursor.value.to == curTo ? null : cursor.value;
+  }
+  // Searching in reverse is, rather than implementing an inverted search
+  // cursor, done by scanning chunk after chunk forward.
+  prevMatchInRange(state, from, to) {
+    for (let pos = to; ; ) {
+      let start = Math.max(from, pos - 1e4 - this.spec.unquoted.length);
+      let cursor = stringCursor(this.spec, state, start, pos), range = null;
+      while (!cursor.nextOverlapping().done)
+        range = cursor.value;
+      if (range)
+        return range;
+      if (start == from)
+        return null;
+      pos -= 1e4;
+    }
+  }
+  prevMatch(state, curFrom, curTo) {
+    let found = this.prevMatchInRange(state, 0, curFrom);
+    if (!found)
+      found = this.prevMatchInRange(state, Math.max(0, curTo - this.spec.unquoted.length), state.doc.length);
+    return found && (found.from != curFrom || found.to != curTo) ? found : null;
+  }
+  getReplacement(_result) {
+    return this.spec.unquote(this.spec.replace);
+  }
+  matchAll(state, limit) {
+    let cursor = stringCursor(this.spec, state, 0, state.doc.length), ranges = [];
+    while (!cursor.next().done) {
+      if (ranges.length >= limit)
+        return null;
+      ranges.push(cursor.value);
+    }
+    return ranges;
+  }
+  highlight(state, from, to, add2) {
+    let cursor = stringCursor(this.spec, state, Math.max(0, from - this.spec.unquoted.length), Math.min(to + this.spec.unquoted.length, state.doc.length));
+    while (!cursor.next().done)
+      add2(cursor.value.from, cursor.value.to);
+  }
+};
+function wrapRegexpTest(test, state, inner) {
+  return (from, to, match) => {
+    return (!inner || inner(from, to, match)) && test(match[0], state, from, to);
+  };
+}
+function regexpCursor(spec, state, from, to) {
+  let test;
+  if (spec.wholeWord)
+    test = regexpWordTest(state.charCategorizer(state.selection.main.head));
+  if (spec.test)
+    test = wrapRegexpTest(spec.test, state, test);
+  return new RegExpCursor(state.doc, spec.search, { ignoreCase: !spec.caseSensitive, test }, from, to);
+}
+function charBefore(str, index) {
+  return str.slice(findClusterBreak2(str, index, false), index);
+}
+function charAfter(str, index) {
+  return str.slice(index, findClusterBreak2(str, index));
+}
+function regexpWordTest(categorizer) {
+  return (_from, _to, match) => !match[0].length || (categorizer(charBefore(match.input, match.index)) != CharCategory2.Word || categorizer(charAfter(match.input, match.index)) != CharCategory2.Word) && (categorizer(charAfter(match.input, match.index + match[0].length)) != CharCategory2.Word || categorizer(charBefore(match.input, match.index + match[0].length)) != CharCategory2.Word);
+}
+var RegExpQuery = class extends QueryType {
+  nextMatch(state, curFrom, curTo) {
+    let cursor = regexpCursor(this.spec, state, curTo, state.doc.length).next();
+    if (cursor.done)
+      cursor = regexpCursor(this.spec, state, 0, curFrom).next();
+    return cursor.done ? null : cursor.value;
+  }
+  prevMatchInRange(state, from, to) {
+    for (let size = 1; ; size++) {
+      let start = Math.max(
+        from,
+        to - size * 1e4
+        /* FindPrev.ChunkSize */
+      );
+      let cursor = regexpCursor(this.spec, state, start, to), range = null;
+      while (!cursor.next().done)
+        range = cursor.value;
+      if (range && (start == from || range.from > start + 10))
+        return range;
+      if (start == from)
+        return null;
+    }
+  }
+  prevMatch(state, curFrom, curTo) {
+    return this.prevMatchInRange(state, 0, curFrom) || this.prevMatchInRange(state, curTo, state.doc.length);
+  }
+  getReplacement(result) {
+    return this.spec.unquote(this.spec.replace).replace(/\$([$&]|\d+)/g, (m, i) => {
+      if (i == "&")
+        return result.match[0];
+      if (i == "$")
+        return "$";
+      for (let l = i.length; l > 0; l--) {
+        let n = +i.slice(0, l);
+        if (n > 0 && n < result.match.length)
+          return result.match[n] + i.slice(l);
+      }
+      return m;
+    });
+  }
+  matchAll(state, limit) {
+    let cursor = regexpCursor(this.spec, state, 0, state.doc.length), ranges = [];
+    while (!cursor.next().done) {
+      if (ranges.length >= limit)
+        return null;
+      ranges.push(cursor.value);
+    }
+    return ranges;
+  }
+  highlight(state, from, to, add2) {
+    let cursor = regexpCursor(this.spec, state, Math.max(
+      0,
+      from - 250
+      /* RegExp.HighlightMargin */
+    ), Math.min(to + 250, state.doc.length));
+    while (!cursor.next().done)
+      add2(cursor.value.from, cursor.value.to);
+  }
+};
+var setSearchQuery = /* @__PURE__ */ StateEffect2.define();
+var togglePanel = /* @__PURE__ */ StateEffect2.define();
+var searchState = /* @__PURE__ */ StateField2.define({
+  create(state) {
+    return new SearchState(defaultQuery(state).create(), null);
+  },
+  update(value, tr) {
+    for (let effect of tr.effects) {
+      if (effect.is(setSearchQuery))
+        value = new SearchState(effect.value.create(), value.panel);
+      else if (effect.is(togglePanel))
+        value = new SearchState(value.query, effect.value ? createSearchPanel : null);
+    }
+    return value;
+  },
+  provide: (f) => showPanel.from(f, (val) => val.panel)
+});
+var SearchState = class {
+  constructor(query, panel) {
+    this.query = query;
+    this.panel = panel;
+  }
+};
+var matchMark = /* @__PURE__ */ Decoration.mark({ class: "cm-searchMatch" });
+var selectedMatchMark = /* @__PURE__ */ Decoration.mark({ class: "cm-searchMatch cm-searchMatch-selected" });
+var searchHighlighter = /* @__PURE__ */ ViewPlugin.fromClass(class {
+  constructor(view) {
+    this.view = view;
+    this.decorations = this.highlight(view.state.field(searchState));
+  }
+  update(update) {
+    let state = update.state.field(searchState);
+    if (state != update.startState.field(searchState) || update.docChanged || update.selectionSet || update.viewportChanged)
+      this.decorations = this.highlight(state);
+  }
+  highlight({ query, panel }) {
+    if (!panel || !query.spec.valid)
+      return Decoration.none;
+    let { view } = this;
+    let builder = new RangeSetBuilder();
+    for (let i = 0, ranges = view.visibleRanges, l = ranges.length; i < l; i++) {
+      let { from, to } = ranges[i];
+      while (i < l - 1 && to > ranges[i + 1].from - 2 * 250)
+        to = ranges[++i].to;
+      query.highlight(view.state, from, to, (from2, to2) => {
+        let selected = view.state.selection.ranges.some((r) => r.from == from2 && r.to == to2);
+        builder.add(from2, to2, selected ? selectedMatchMark : matchMark);
+      });
+    }
+    return builder.finish();
+  }
+}, {
+  decorations: (v) => v.decorations
+});
+function searchCommand(f) {
+  return (view) => {
+    let state = view.state.field(searchState, false);
+    return state && state.query.spec.valid ? f(view, state) : openSearchPanel(view);
+  };
+}
+var findNext = /* @__PURE__ */ searchCommand((view, { query }) => {
+  let { to } = view.state.selection.main;
+  let next = query.nextMatch(view.state, to, to);
+  if (!next)
+    return false;
+  let selection = EditorSelection2.single(next.from, next.to);
+  let config = view.state.facet(searchConfigFacet);
+  view.dispatch({
+    selection,
+    effects: [announceMatch(view, next), config.scrollToMatch(selection.main, view)],
+    userEvent: "select.search"
+  });
+  selectSearchInput(view);
+  return true;
+});
+var findPrevious = /* @__PURE__ */ searchCommand((view, { query }) => {
+  let { state } = view, { from } = state.selection.main;
+  let prev = query.prevMatch(state, from, from);
+  if (!prev)
+    return false;
+  let selection = EditorSelection2.single(prev.from, prev.to);
+  let config = view.state.facet(searchConfigFacet);
+  view.dispatch({
+    selection,
+    effects: [announceMatch(view, prev), config.scrollToMatch(selection.main, view)],
+    userEvent: "select.search"
+  });
+  selectSearchInput(view);
+  return true;
+});
+var selectMatches = /* @__PURE__ */ searchCommand((view, { query }) => {
+  let ranges = query.matchAll(view.state, 1e3);
+  if (!ranges || !ranges.length)
+    return false;
+  view.dispatch({
+    selection: EditorSelection2.create(ranges.map((r) => EditorSelection2.range(r.from, r.to))),
+    userEvent: "select.search.matches"
+  });
+  return true;
+});
+var selectSelectionMatches = ({ state, dispatch }) => {
+  let sel = state.selection;
+  if (sel.ranges.length > 1 || sel.main.empty)
+    return false;
+  let { from, to } = sel.main;
+  let ranges = [], main = 0;
+  for (let cur = new SearchCursor(state.doc, state.sliceDoc(from, to)); !cur.next().done; ) {
+    if (ranges.length > 1e3)
+      return false;
+    if (cur.value.from == from)
+      main = ranges.length;
+    ranges.push(EditorSelection2.range(cur.value.from, cur.value.to));
+  }
+  dispatch(state.update({
+    selection: EditorSelection2.create(ranges, main),
+    userEvent: "select.search.matches"
+  }));
+  return true;
+};
+var replaceNext = /* @__PURE__ */ searchCommand((view, { query }) => {
+  let { state } = view, { from, to } = state.selection.main;
+  if (state.readOnly)
+    return false;
+  let match = query.nextMatch(state, from, from);
+  if (!match)
+    return false;
+  let next = match;
+  let changes = [], selection, replacement;
+  let effects = [];
+  if (!next.precise) {
+    next = query.nextMatch(state, next.from, next.to);
+  } else if (next.from == from && next.to == to) {
+    replacement = state.toText(query.getReplacement(next));
+    changes.push({ from: next.from, to: next.to, insert: replacement });
+    next = query.nextMatch(state, next.from, next.to);
+    effects.push(EditorView2.announce.of(state.phrase("replaced match on line $", state.doc.lineAt(from).number) + "."));
+  }
+  let changeSet = view.state.changes(changes);
+  if (next) {
+    selection = EditorSelection2.single(next.from, next.to).map(changeSet);
+    effects.push(announceMatch(view, next));
+    effects.push(state.facet(searchConfigFacet).scrollToMatch(selection.main, view));
+  }
+  view.dispatch({
+    changes: changeSet,
+    selection,
+    effects,
+    userEvent: "input.replace"
+  });
+  return true;
+});
+var replaceAll = /* @__PURE__ */ searchCommand((view, { query }) => {
+  if (view.state.readOnly)
+    return false;
+  let changes = [];
+  for (let match of query.matchAll(view.state, 1e9)) {
+    let { from, to, precise } = match;
+    if (precise)
+      changes.push({ from, to, insert: query.getReplacement(match) });
+  }
+  if (!changes.length)
+    return false;
+  let announceText = view.state.phrase("replaced $ matches", changes.length) + ".";
+  view.dispatch({
+    changes,
+    effects: EditorView2.announce.of(announceText),
+    userEvent: "input.replace.all"
+  });
+  return true;
+});
+function createSearchPanel(view) {
+  return view.state.facet(searchConfigFacet).createPanel(view);
+}
+function defaultQuery(state, fallback) {
+  var _a, _b, _c, _d, _e;
+  let sel = state.selection.main;
+  let selText = sel.empty || sel.to > sel.from + 100 ? "" : state.sliceDoc(sel.from, sel.to);
+  if (fallback && !selText)
+    return fallback;
+  let config = state.facet(searchConfigFacet);
+  return new SearchQuery({
+    search: ((_a = fallback === null || fallback === void 0 ? void 0 : fallback.literal) !== null && _a !== void 0 ? _a : config.literal) ? selText : selText.replace(/\n/g, "\\n"),
+    caseSensitive: (_b = fallback === null || fallback === void 0 ? void 0 : fallback.caseSensitive) !== null && _b !== void 0 ? _b : config.caseSensitive,
+    literal: (_c = fallback === null || fallback === void 0 ? void 0 : fallback.literal) !== null && _c !== void 0 ? _c : config.literal,
+    regexp: (_d = fallback === null || fallback === void 0 ? void 0 : fallback.regexp) !== null && _d !== void 0 ? _d : config.regexp,
+    wholeWord: (_e = fallback === null || fallback === void 0 ? void 0 : fallback.wholeWord) !== null && _e !== void 0 ? _e : config.wholeWord
+  });
+}
+function getSearchInput(view) {
+  let panel = getPanel(view, createSearchPanel);
+  return panel && panel.dom.querySelector("[main-field]");
+}
+function selectSearchInput(view) {
+  let input = getSearchInput(view);
+  if (input && input == view.root.activeElement)
+    input.select();
+}
+var openSearchPanel = (view) => {
+  let state = view.state.field(searchState, false);
+  if (state && state.panel) {
+    let searchInput = getSearchInput(view);
+    if (searchInput && searchInput != view.root.activeElement) {
+      let query = defaultQuery(view.state, state.query.spec);
+      if (query.valid)
+        view.dispatch({ effects: setSearchQuery.of(query) });
+      searchInput.focus();
+      searchInput.select();
+    }
+  } else {
+    view.dispatch({ effects: [
+      togglePanel.of(true),
+      state ? setSearchQuery.of(defaultQuery(view.state, state.query.spec)) : StateEffect2.appendConfig.of(searchExtensions)
+    ] });
+  }
+  return true;
+};
+var closeSearchPanel = (view) => {
+  let state = view.state.field(searchState, false);
+  if (!state || !state.panel)
+    return false;
+  let panel = getPanel(view, createSearchPanel);
+  if (panel && panel.dom.contains(view.root.activeElement))
+    view.focus();
+  view.dispatch({ effects: togglePanel.of(false) });
+  return true;
+};
+var 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 }
+];
+var SearchPanel = class {
+  constructor(view) {
+    this.view = view;
+    let query = this.query = view.state.field(searchState).query.spec;
+    this.commit = this.commit.bind(this);
+    this.searchField = crelt("input", {
+      value: query.search,
+      placeholder: phrase(view, "Find"),
+      "aria-label": phrase(view, "Find"),
+      class: "cm-textfield",
+      name: "search",
+      form: "",
+      "main-field": "true",
+      onchange: this.commit,
+      onkeyup: this.commit
+    });
+    this.replaceField = crelt("input", {
+      value: query.replace,
+      placeholder: phrase(view, "Replace"),
+      "aria-label": phrase(view, "Replace"),
+      class: "cm-textfield",
+      name: "replace",
+      form: "",
+      onchange: this.commit,
+      onkeyup: this.commit
+    });
+    this.caseField = crelt("input", {
+      type: "checkbox",
+      name: "case",
+      form: "",
+      checked: query.caseSensitive,
+      onchange: this.commit
+    });
+    this.reField = crelt("input", {
+      type: "checkbox",
+      name: "re",
+      form: "",
+      checked: query.regexp,
+      onchange: this.commit
+    });
+    this.wordField = crelt("input", {
+      type: "checkbox",
+      name: "word",
+      form: "",
+      checked: query.wholeWord,
+      onchange: this.commit
+    });
+    function button(name, onclick, content) {
+      return crelt("button", { class: "cm-button", name, onclick, type: "button" }, content);
+    }
+    this.dom = crelt("div", { onkeydown: (e) => this.keydown(e), class: "cm-search" }, [
+      this.searchField,
+      button("next", () => findNext(view), [phrase(view, "next")]),
+      button("prev", () => findPrevious(view), [phrase(view, "previous")]),
+      button("select", () => selectMatches(view), [phrase(view, "all")]),
+      crelt("label", null, [this.caseField, phrase(view, "match case")]),
+      crelt("label", null, [this.reField, phrase(view, "regexp")]),
+      crelt("label", null, [this.wordField, phrase(view, "by word")]),
+      ...view.state.readOnly ? [] : [
+        crelt("br"),
+        this.replaceField,
+        button("replace", () => replaceNext(view), [phrase(view, "replace")]),
+        button("replaceAll", () => replaceAll(view), [phrase(view, "replace all")])
+      ],
+      crelt("button", {
+        name: "close",
+        onclick: () => closeSearchPanel(view),
+        "aria-label": phrase(view, "close"),
+        type: "button"
+      }, ["\xD7"])
+    ]);
+  }
+  commit() {
+    let query = new SearchQuery({
+      search: this.searchField.value,
+      caseSensitive: this.caseField.checked,
+      regexp: this.reField.checked,
+      wholeWord: this.wordField.checked,
+      replace: this.replaceField.value
+    });
+    if (!query.eq(this.query)) {
+      this.query = query;
+      this.view.dispatch({ effects: setSearchQuery.of(query) });
+    }
+  }
+  keydown(e) {
+    if (runScopeHandlers(this.view, e, "search-panel")) {
+      e.preventDefault();
+    } else if (e.keyCode == 13 && e.target == this.searchField) {
+      e.preventDefault();
+      (e.shiftKey ? findPrevious : findNext)(this.view);
+    } else if (e.keyCode == 13 && e.target == this.replaceField) {
+      e.preventDefault();
+      replaceNext(this.view);
+    }
+  }
+  update(update) {
+    for (let tr of update.transactions)
+      for (let effect of tr.effects) {
+        if (effect.is(setSearchQuery) && !effect.value.eq(this.query))
+          this.setQuery(effect.value);
+      }
+  }
+  setQuery(query) {
+    this.query = query;
+    this.searchField.value = query.search;
+    this.replaceField.value = query.replace;
+    this.caseField.checked = query.caseSensitive;
+    this.reField.checked = query.regexp;
+    this.wordField.checked = query.wholeWord;
+  }
+  mount() {
+    this.searchField.select();
+  }
+  get pos() {
+    return 80;
+  }
+  get top() {
+    return this.view.state.facet(searchConfigFacet).top;
+  }
+};
+function phrase(view, phrase2) {
+  return view.state.phrase(phrase2);
+}
+var AnnounceMargin = 30;
+var Break = /[\s\.,:;?!]/;
+function announceMatch(view, { from, to }) {
+  let line = view.state.doc.lineAt(from), lineEnd = view.state.doc.lineAt(to).to;
+  let start = Math.max(line.from, from - AnnounceMargin), end = Math.min(lineEnd, to + AnnounceMargin);
+  let text = view.state.sliceDoc(start, end);
+  if (start != line.from) {
+    for (let i = 0; i < AnnounceMargin; i++)
+      if (!Break.test(text[i + 1]) && Break.test(text[i])) {
+        text = text.slice(i);
+        break;
+      }
+  }
+  if (end != lineEnd) {
+    for (let i = text.length - 1; i > text.length - AnnounceMargin; i--)
+      if (!Break.test(text[i - 1]) && Break.test(text[i])) {
+        text = text.slice(0, i);
+        break;
+      }
+  }
+  return EditorView2.announce.of(`${view.state.phrase("current match")}. ${text} ${view.state.phrase("on line")} ${line.number}.`);
+}
+var baseTheme = /* @__PURE__ */ EditorView2.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" }
+});
+var searchExtensions = [
+  searchState,
+  /* @__PURE__ */ Prec.low(searchHighlighter),
+  baseTheme
+];
+
+// src/extensions/markdown.ts
+import { EditorView as EditorView4, keymap } from "@codemirror/view";
+
+// src/themes/markdown.ts
+import { RangeSetBuilder as RangeSetBuilder2 } from "@codemirror/state";
+import {
+  Decoration as Decoration2,
+  EditorView as EditorView3,
+  ViewPlugin as ViewPlugin2,
+  WidgetType
+} from "@codemirror/view";
+var MARKDOWN_STYLES = {
+  "&": {},
+  "&.cm-editor.cm-focused": {
+    outline: "none"
+  },
+  "&.cm-editor": {
+    height: "100%",
+    display: "flex",
+    alignContent: "center",
+    justifyContent: "center",
+    overflow: "auto"
+  },
+  ".cm-scroller": {
+    background: "var(--text-editor-fill)"
+  },
+  ".cm-gutter": {
+    background: "transparent"
+  },
+  ".cm-content": {
+    // Justified text makes it look more like the I&S web essay template,
+    // but doesn't feel right for most documents.
+    // textAlign: "justify",
+    textWrap: "pretty",
+    lineHeight: "1.5rem",
+    color: "var(--text-editor-line)",
+    caretColor: "var(--text-editor-cursor-fill)",
+    background: "var(--text-editor-fill)",
+    marginBlock: "2rem",
+    marginInline: "auto",
+    // lol i guess this is the same as box-sizing: content-box
+    maxWidth: "calc(var(--max-text-line-width, 100ex) - 2rem)",
+    padding: "2rem",
+    boxShadow: "none",
+    marginBottom: "8em",
+    borderRadius: "8px"
+  },
+  ".cm-content li": {
+    marginBottom: 0
+  },
+  ".cm-activeLine": {
+    backgroundColor: "inherit"
+  },
+  ".frontmatter, .frontmatter *": {
+    fontSize: "14px",
+    fontFamily: "var(--studio-family-code, monospace)",
+    color: "var(--syntax-comment, #666)",
+    textDecoration: "none",
+    fontWeight: "normal",
+    lineHeight: "0.8em"
+  },
+  ".cm-gutters": {
+    borderRight: "0",
+    border: "0",
+    background: "var(--text-editor-gutter-fill)"
+  },
+  ".cm-comment-gutter": {
+    width: "20px"
+  },
+  ".cm-folded-range-gutter-line-number": {
+    display: "none"
+  },
+  ".cm-folded-range-gutter": {
+    background: "var(--text-editor-fill)",
+    borderRight: "0px",
+    width: "40px"
+  },
+  ".cm-folded-line-widget": {
+    background: "var(--text-editor-fill)",
+    border: "0px"
+  },
+  ".cm-folded-range": {
+    background: "var(--text-editor-fill)"
+  },
+  ".codeblock": {
+    background: "orange"
+  }
+};
+var baseHeadingStyles = {
+  fontFamily: '"Merriweather Sans", sans-serif',
+  fontWeight: 400,
+  textDecoration: "none"
+};
+var baseCodeStyles = {
+  fontFamily: "var(--studio-family-code, monospace)",
+  fontSize: "1em"
+};
+var markdownSyntaxHighlighting = (style) => HighlightStyle.define([
+  // this is how you ensure that codeblocks are still monospace
+  {
+    tag: tags.content,
+    fontFamily: style == "serif" ? '"Merriweather", serif' : '"Merriweather Sans", sans-serif'
+  },
+  {
+    tag: tags.heading1,
+    ...baseHeadingStyles,
+    fontSize: "1.5rem",
+    lineHeight: "2rem",
+    marginBottom: "1rem",
+    marginTop: "2rem"
+  },
+  {
+    tag: tags.heading2,
+    ...baseHeadingStyles,
+    fontSize: "1.5rem",
+    lineHeight: "2rem",
+    marginBottom: "1rem",
+    marginTop: "2rem"
+  },
+  {
+    tag: tags.heading3,
+    ...baseHeadingStyles,
+    fontSize: "1.25rem",
+    lineHeight: "1.75rem",
+    marginBottom: "1rem",
+    marginTop: "2rem"
+  },
+  {
+    tag: tags.heading4,
+    ...baseHeadingStyles,
+    fontSize: "1.1rem",
+    marginBottom: "1rem",
+    marginTop: "2rem"
+  },
+  {
+    tag: tags.comment,
+    color: "var(--syntax-comment, #555)",
+    fontFamily: "var(--studio-family-code, monospace)"
+  },
+  { tag: tags.quote, fontStyle: "var(--syntax-style-quote, italic)" },
+  {
+    tag: tags.strong,
+    fontWeight: "var(--syntax-weight-strong, bold)"
+  },
+  {
+    tag: tags.emphasis,
+    fontStyle: "var(--syntax-style-emphasis, italic)"
+  },
+  {
+    tag: tags.strikethrough,
+    textDecoration: "line-through"
+  },
+  {
+    tag: [tags.meta],
+    fontWeight: 300,
+    color: "var(--syntax-meta, #999)",
+    fontFamily: '"Merriweather Sans", sans-serif'
+  },
+  { tag: tags.keyword, ...baseCodeStyles, color: "var(--syntax-keyword, #708)" },
+  {
+    tag: [
+      tags.atom,
+      tags.bool,
+      tags.url,
+      tags.contentSeparator,
+      tags.labelName
+    ],
+    ...baseCodeStyles,
+    color: "var(--syntax-atom, var(--studio-secondary))"
+  },
+  { tag: [tags.literal, tags.inserted], ...baseCodeStyles, color: "var(--syntax-inserted, #164)" },
+  { tag: [tags.string, tags.deleted], ...baseCodeStyles, color: "var(--syntax-string, #5f67b5)" },
+  {
+    tag: [tags.regexp, tags.escape, tags.special(tags.string)],
+    ...baseCodeStyles,
+    color: "var(--syntax-regexp, #e40)"
+  },
+  {
+    tag: tags.definition(tags.variableName),
+    ...baseCodeStyles,
+    color: "var(--syntax-definition--variable-name, #00f)"
+  },
+  { tag: tags.local(tags.variableName), ...baseCodeStyles, color: "var(--syntax-variable-name, #30a)" },
+  { tag: [tags.typeName, tags.namespace], ...baseCodeStyles, color: "var(--syntax-type-name, #085)" },
+  { tag: tags.className, ...baseCodeStyles, color: "var(--syntax-class-name, #167)" },
+  {
+    tag: [tags.special(tags.variableName), tags.macroName],
+    ...baseCodeStyles,
+    color: "var(--syntax-special--variable-name, #256)"
+  },
+  {
+    tag: tags.definition(tags.propertyName),
+    ...baseCodeStyles,
+    color: "var(--syntax-function--property-name, #00c)"
+  },
+  { tag: tags.monospace, ...baseCodeStyles }
+]);
+var theme = (style) => [
+  EditorView3.theme(MARKDOWN_STYLES),
+  syntaxHighlighting(markdownSyntaxHighlighting(style)),
+  bullets,
+  codeblocks
+];
+var bullets = ViewPlugin2.fromClass(
+  class {
+    decorations;
+    view;
+    constructor(view) {
+      this.view = view;
+      this.decorations = this.build();
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        this.decorations = this.build();
+      }
+    }
+    build() {
+      const builder = new RangeSetBuilder2();
+      const doc = this.view.state.doc;
+      syntaxTree(this.view.state).iterate({
+        enter: ({ type, from }) => {
+          if (type.name === "ListMark") {
+            const char = doc.sliceString(from, from + 1);
+            if (["-", "+", "*"].includes(char)) {
+              builder.add(
+                from,
+                from + 1,
+                Decoration2.replace({ widget: new BulletWidget() })
+              );
+            }
+          }
+        }
+      });
+      return builder.finish();
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);
+var BulletWidget = class extends WidgetType {
+  toDOM() {
+    const span = document.createElement("span");
+    span.textContent = "\u2022";
+    span.className = "cm-bullet";
+    return span;
+  }
+};
+var codeblocks = ViewPlugin2.fromClass(
+  class BlockquotePlugin {
+    decorations = Decoration2.none;
+    constructor(view) {
+      this.buildDeco(view);
+    }
+    update(update) {
+      this.buildDeco(update.view);
+    }
+    buildDeco(view) {
+      const builder = new RangeSetBuilder2();
+      view.viewportLineBlocks.forEach((line) => {
+        const lineObj = view.state.doc.lineAt(line.from);
+        const match = /^>.*/g.exec(lineObj.text);
+        if (match && match[0]) {
+          builder.add(
+            line.from,
+            line.from,
+            Decoration2.line({ class: "codeblock" })
+          );
+        }
+      });
+      this.decorations = builder.finish();
+    }
+  }
+);
+
+// src/extensions/markdown.ts
+function markdownExtensions() {
+  return [
+    ...theme("sans"),
+    history(),
+    indentOnInput(),
+    keymap.of([
+      ...defaultKeymap,
+      ...searchKeymap,
+      ...historyKeymap,
+      ...foldKeymap,
+      ...completionKeymap,
+      indentWithTab
+    ]),
+    EditorView4.lineWrapping,
+    markdown({ codeLanguages: languages }),
+    indentUnit.of("    ")
+  ];
+}
+export {
+  markdownExtensions
+};
+//# sourceMappingURL=markdown.js.map