@prosemark/core 0.0.0

package/dist/main.mjs

@@ -0,0 +1,4209 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { EditorView, getPanel, showPanel, ViewPlugin, Decoration, runScopeHandlers, keymap, showTooltip, logException, getTooltip, Direction, hoverTooltip, WidgetType, dropCursor } from "@codemirror/view";
+import { StateField, StateEffect, Prec, EditorSelection, Facet, combineConfig, codePointAt, fromCodePoint, codePointSize, EditorState, RangeSetBuilder, CharCategory, findClusterBreak, RangeValue, RangeSet, MapMode, Annotation } from "@codemirror/state";
+import { syntaxTree, syntaxHighlighting, HighlightStyle, indentOnInput, bracketMatching, foldGutter, foldKeymap } from "@codemirror/language";
+import { Tag, styleTags, tags } from "@lezer/highlight";
+import * as emoji from "node-emoji";
+import { history, defaultKeymap, historyKeymap, indentWithTab } from "@codemirror/commands";
+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);
+  }
+}
+const basicNormalize = typeof String.prototype.normalize == "function" ? (x) => x.normalize("NFKD") : (x) => x;
+class SearchCursor {
+  /**
+  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 };
+    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; ; i++) {
+          let code = norm.charCodeAt(i);
+          let match = this.match(code, pos, this.bufferPos + this.bufferStart);
+          if (i == norm.length - 1) {
+            if (match) {
+              this.value = match;
+              return this;
+            }
+            break;
+          }
+          if (pos == start && i < str.length && str.charCodeAt(i) == code)
+            pos++;
+        }
+    }
+  }
+  match(code, pos, end) {
+    let match = null;
+    for (let i = 0; i < this.matches.length; i += 2) {
+      let index = this.matches[i], keep = false;
+      if (this.query.charCodeAt(index) == code) {
+        if (index == this.query.length - 1) {
+          match = { from: this.matches[i + 1], to: end };
+        } else {
+          this.matches[i]++;
+          keep = true;
+        }
+      }
+      if (!keep) {
+        this.matches.splice(i, 2);
+        i -= 2;
+      }
+    }
+    if (this.query.charCodeAt(0) == code) {
+      if (this.query.length == 1)
+        match = { from: pos, to: end };
+      else
+        this.matches.push(1, pos);
+    }
+    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;
+  };
+const empty = { from: -1, to: -1, match: /* @__PURE__ */ /.*/.exec("") };
+const baseFlags = "gm" + (/x/.unicode == null ? "" : "u");
+class RegExpCursor {
+  /**
+  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, 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;
+      }
+    }
+  }
+}
+const flattened = /* @__PURE__ */ new WeakMap();
+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));
+  }
+}
+class MultilineRegExpCursor {
+  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, 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;
+}
+function createLineDialog(view) {
+  let line = String(view.state.doc.lineAt(view.state.selection.main.head).number);
+  let input = crelt("input", { class: "cm-textfield", name: "line", value: line });
+  let dom = crelt("form", {
+    class: "cm-gotoLine",
+    onkeydown: (event) => {
+      if (event.keyCode == 27) {
+        event.preventDefault();
+        view.dispatch({ effects: dialogEffect.of(false) });
+        view.focus();
+      } else if (event.keyCode == 13) {
+        event.preventDefault();
+        go();
+      }
+    },
+    onsubmit: (event) => {
+      event.preventDefault();
+      go();
+    }
+  }, crelt("label", view.state.phrase("Go to line"), ": ", input), " ", crelt("button", { class: "cm-button", type: "submit" }, view.state.phrase("go")), crelt("button", {
+    name: "close",
+    onclick: () => {
+      view.dispatch({ effects: dialogEffect.of(false) });
+      view.focus();
+    },
+    "aria-label": view.state.phrase("close"),
+    type: "button"
+  }, ["×"]));
+  function go() {
+    let match = /^([+-])?(\d+)?(:\d+)?(%)?$/.exec(input.value);
+    if (!match)
+      return;
+    let { state } = view, 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 = EditorSelection.cursor(docLine.from + Math.max(0, Math.min(col, docLine.length)));
+    view.dispatch({
+      effects: [dialogEffect.of(false), EditorView.scrollIntoView(selection.from, { y: "center" })],
+      selection
+    });
+    view.focus();
+  }
+  return { dom };
+}
+const dialogEffect = /* @__PURE__ */ StateEffect.define();
+const dialogField = /* @__PURE__ */ StateField.define({
+  create() {
+    return true;
+  },
+  update(value, tr) {
+    for (let e of tr.effects)
+      if (e.is(dialogEffect))
+        value = e.value;
+    return value;
+  },
+  provide: (f) => showPanel.from(f, (val) => val ? createLineDialog : null)
+});
+const gotoLine = (view) => {
+  let panel = getPanel(view, createLineDialog);
+  if (!panel) {
+    let effects = [dialogEffect.of(true)];
+    if (view.state.field(dialogField, false) == null)
+      effects.push(StateEffect.appendConfig.of([dialogField, baseTheme$1$1]));
+    view.dispatch({ effects });
+    panel = getPanel(view, createLineDialog);
+  }
+  if (panel)
+    panel.dom.querySelector("input").select();
+  return true;
+};
+const baseTheme$1$1 = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-panel.cm-gotoLine": {
+    padding: "2px 6px 4px",
+    position: "relative",
+    "& label": { fontSize: "80%" },
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      bottom: "0",
+      right: "4px",
+      backgroundColor: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: "0"
+    }
+  }
+});
+const selectWord = ({ state, dispatch }) => {
+  let { selection } = state;
+  let newSel = EditorSelection.create(selection.ranges.map((range) => state.wordAt(range.head) || EditorSelection.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;
+    }
+  }
+}
+const 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(EditorSelection.range(range.from, range.to), false),
+    effects: EditorView.scrollIntoView(range.to)
+  }));
+  return true;
+};
+const searchConfigFacet = /* @__PURE__ */ Facet.define({
+  combine(configs) {
+    return combineConfig(configs, {
+      top: false,
+      caseSensitive: false,
+      literal: false,
+      regexp: false,
+      wholeWord: false,
+      createPanel: (view) => new SearchPanel(view),
+      scrollToMatch: (range) => EditorView.scrollIntoView(range)
+    });
+  }
+});
+class SearchQuery {
+  /**
+  Create a query object.
+  */
+  constructor(config2) {
+    this.search = config2.search;
+    this.caseSensitive = !!config2.caseSensitive;
+    this.literal = !!config2.literal;
+    this.regexp = !!config2.regexp;
+    this.replace = config2.replace || "";
+    this.valid = !!this.search && (!this.regexp || validRegExp(this.search));
+    this.unquoted = this.unquote(this.search);
+    this.wholeWord = !!config2.wholeWord;
+  }
+  /**
+  @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;
+  }
+  /**
+  @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);
+  }
+}
+class QueryType {
+  constructor(spec) {
+    this.spec = spec;
+  }
+}
+function stringCursor(spec, state, from, to) {
+  return new SearchCursor(state.doc, spec.unquoted, from, to, spec.caseSensitive ? void 0 : (x) => x.toLowerCase(), spec.wholeWord ? stringWordTest(state.doc, state.charCategorizer(state.selection.main.head)) : void 0);
+}
+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)) != CharCategory.Word || categorizer(charAfter(buf, from - bufPos)) != CharCategory.Word) && (categorizer(charAfter(buf, to - bufPos)) != CharCategory.Word || categorizer(charBefore(buf, to - bufPos)) != CharCategory.Word);
+  };
+}
+class StringQuery 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 regexpCursor(spec, state, from, to) {
+  return new RegExpCursor(state.doc, spec.search, {
+    ignoreCase: !spec.caseSensitive,
+    test: spec.wholeWord ? regexpWordTest(state.charCategorizer(state.selection.main.head)) : void 0
+  }, from, to);
+}
+function charBefore(str, index) {
+  return str.slice(findClusterBreak(str, index, false), index);
+}
+function charAfter(str, index) {
+  return str.slice(index, findClusterBreak(str, index));
+}
+function regexpWordTest(categorizer) {
+  return (_from, _to, match) => !match[0].length || (categorizer(charBefore(match.input, match.index)) != CharCategory.Word || categorizer(charAfter(match.input, match.index)) != CharCategory.Word) && (categorizer(charAfter(match.input, match.index + match[0].length)) != CharCategory.Word || categorizer(charBefore(match.input, match.index + match[0].length)) != CharCategory.Word);
+}
+class RegExpQuery 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);
+  }
+}
+const setSearchQuery = /* @__PURE__ */ StateEffect.define();
+const togglePanel$1 = /* @__PURE__ */ StateEffect.define();
+const searchState = /* @__PURE__ */ StateField.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$1))
+        value = new SearchState(value.query, effect.value ? createSearchPanel : null);
+    }
+    return value;
+  },
+  provide: (f) => showPanel.from(f, (val) => val.panel)
+});
+class SearchState {
+  constructor(query, panel) {
+    this.query = query;
+    this.panel = panel;
+  }
+}
+const matchMark = /* @__PURE__ */ Decoration.mark({ class: "cm-searchMatch" }), selectedMatchMark = /* @__PURE__ */ Decoration.mark({ class: "cm-searchMatch cm-searchMatch-selected" });
+const 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);
+  };
+}
+const 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 = EditorSelection.single(next.from, next.to);
+  let config2 = view.state.facet(searchConfigFacet);
+  view.dispatch({
+    selection,
+    effects: [announceMatch(view, next), config2.scrollToMatch(selection.main, view)],
+    userEvent: "select.search"
+  });
+  selectSearchInput(view);
+  return true;
+});
+const 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 = EditorSelection.single(prev.from, prev.to);
+  let config2 = view.state.facet(searchConfigFacet);
+  view.dispatch({
+    selection,
+    effects: [announceMatch(view, prev), config2.scrollToMatch(selection.main, view)],
+    userEvent: "select.search"
+  });
+  selectSearchInput(view);
+  return true;
+});
+const selectMatches = /* @__PURE__ */ searchCommand((view, { query }) => {
+  let ranges = query.matchAll(view.state, 1e3);
+  if (!ranges || !ranges.length)
+    return false;
+  view.dispatch({
+    selection: EditorSelection.create(ranges.map((r) => EditorSelection.range(r.from, r.to))),
+    userEvent: "select.search.matches"
+  });
+  return true;
+});
+const 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 cur2 = new SearchCursor(state.doc, state.sliceDoc(from, to)); !cur2.next().done; ) {
+    if (ranges.length > 1e3)
+      return false;
+    if (cur2.value.from == from)
+      main = ranges.length;
+    ranges.push(EditorSelection.range(cur2.value.from, cur2.value.to));
+  }
+  dispatch(state.update({
+    selection: EditorSelection.create(ranges, main),
+    userEvent: "select.search.matches"
+  }));
+  return true;
+};
+const 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.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(EditorView.announce.of(state.phrase("replaced match on line $", state.doc.lineAt(from).number) + "."));
+  }
+  let changeSet = view.state.changes(changes);
+  if (next) {
+    selection = EditorSelection.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;
+});
+const replaceAll = /* @__PURE__ */ searchCommand((view, { query }) => {
+  if (view.state.readOnly)
+    return false;
+  let changes = query.matchAll(view.state, 1e9).map((match) => {
+    let { from, to } = match;
+    return { from, to, insert: query.getReplacement(match) };
+  });
+  if (!changes.length)
+    return false;
+  let announceText = view.state.phrase("replaced $ matches", changes.length) + ".";
+  view.dispatch({
+    changes,
+    effects: EditorView.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 config2 = state.facet(searchConfigFacet);
+  return new SearchQuery({
+    search: ((_a = fallback === null || fallback === void 0 ? void 0 : fallback.literal) !== null && _a !== void 0 ? _a : config2.literal) ? selText : selText.replace(/\n/g, "\\n"),
+    caseSensitive: (_b = fallback === null || fallback === void 0 ? void 0 : fallback.caseSensitive) !== null && _b !== void 0 ? _b : config2.caseSensitive,
+    literal: (_c = fallback === null || fallback === void 0 ? void 0 : fallback.literal) !== null && _c !== void 0 ? _c : config2.literal,
+    regexp: (_d = fallback === null || fallback === void 0 ? void 0 : fallback.regexp) !== null && _d !== void 0 ? _d : config2.regexp,
+    wholeWord: (_e = fallback === null || fallback === void 0 ? void 0 : fallback.wholeWord) !== null && _e !== void 0 ? _e : config2.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();
+}
+const 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$1.of(true),
+      state ? setSearchQuery.of(defaultQuery(view.state, state.query.spec)) : StateEffect.appendConfig.of(searchExtensions)
+    ] });
+  }
+  return true;
+};
+const 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$1.of(false) });
+  return true;
+};
+const 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 }
+];
+class SearchPanel {
+  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"
+      }, ["×"])
+    ]);
+  }
+  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);
+}
+const AnnounceMargin = 30;
+const 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 EditorView.announce.of(`${view.state.phrase("current match")}. ${text} ${view.state.phrase("on line")} ${line.number}.`);
+}
+const baseTheme$3 = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-panel.cm-search": {
+    padding: "2px 6px 4px",
+    position: "relative",
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      right: "4px",
+      backgroundColor: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: 0,
+      margin: 0
+    },
+    "& input, & button, & label": {
+      margin: ".2em .6em .2em 0"
+    },
+    "& input[type=checkbox]": {
+      marginRight: ".2em"
+    },
+    "& label": {
+      fontSize: "80%",
+      whiteSpace: "pre"
+    }
+  },
+  "&light .cm-searchMatch": { backgroundColor: "#ffff0054" },
+  "&dark .cm-searchMatch": { backgroundColor: "#00ffff8a" },
+  "&light .cm-searchMatch-selected": { backgroundColor: "#ff6a0054" },
+  "&dark .cm-searchMatch-selected": { backgroundColor: "#ff00ff8a" }
+});
+const searchExtensions = [
+  searchState,
+  /* @__PURE__ */ Prec.low(searchHighlighter),
+  baseTheme$3
+];
+class CompletionContext {
+  /**
+  Create a new completion context. (Mostly useful for testing
+  completion sources—in the editor, the extension will create
+  these for you.)
+  */
+  constructor(state, pos, explicit, view) {
+    this.state = state;
+    this.pos = pos;
+    this.explicit = explicit;
+    this.view = view;
+    this.abortListeners = [];
+    this.abortOnDocChange = false;
+  }
+  /**
+  Get the extent, content, and (if there is a token) type of the
+  token before `this.pos`.
+  */
+  tokenBefore(types) {
+    let token = syntaxTree(this.state).resolveInner(this.pos, -1);
+    while (token && types.indexOf(token.name) < 0)
+      token = token.parent;
+    return token ? {
+      from: token.from,
+      to: this.pos,
+      text: this.state.sliceDoc(token.from, this.pos),
+      type: token.type
+    } : null;
+  }
+  /**
+  Get the match of the given expression directly before the
+  cursor.
+  */
+  matchBefore(expr) {
+    let line = this.state.doc.lineAt(this.pos);
+    let start = Math.max(line.from, this.pos - 250);
+    let str = line.text.slice(start - line.from, this.pos - line.from);
+    let found = str.search(ensureAnchor(expr, false));
+    return found < 0 ? null : { from: start + found, to: this.pos, text: str.slice(found) };
+  }
+  /**
+  Yields true when the query has been aborted. Can be useful in
+  asynchronous queries to avoid doing work that will be ignored.
+  */
+  get aborted() {
+    return this.abortListeners == null;
+  }
+  /**
+  Allows you to register abort handlers, which will be called when
+  the query is
+  [aborted](https://codemirror.net/6/docs/ref/#autocomplete.CompletionContext.aborted).
+  
+  By default, running queries will not be aborted for regular
+  typing or backspacing, on the assumption that they are likely to
+  return a result with a
+  [`validFor`](https://codemirror.net/6/docs/ref/#autocomplete.CompletionResult.validFor) field that
+  allows the result to be used after all. Passing `onDocChange:
+  true` will cause this query to be aborted for any document
+  change.
+  */
+  addEventListener(type, listener, options) {
+    if (type == "abort" && this.abortListeners) {
+      this.abortListeners.push(listener);
+      if (options && options.onDocChange)
+        this.abortOnDocChange = true;
+    }
+  }
+}
+function toSet(chars) {
+  let flat = Object.keys(chars).join("");
+  let words = /\w/.test(flat);
+  if (words)
+    flat = flat.replace(/\w/g, "");
+  return `[${words ? "\\w" : ""}${flat.replace(/[^\w\s]/g, "\\$&")}]`;
+}
+function prefixMatch(options) {
+  let first = /* @__PURE__ */ Object.create(null), rest = /* @__PURE__ */ Object.create(null);
+  for (let { label } of options) {
+    first[label[0]] = true;
+    for (let i = 1; i < label.length; i++)
+      rest[label[i]] = true;
+  }
+  let source = toSet(first) + toSet(rest) + "*$";
+  return [new RegExp("^" + source), new RegExp(source)];
+}
+function completeFromList(list) {
+  let options = list.map((o) => typeof o == "string" ? { label: o } : o);
+  let [validFor, match] = options.every((o) => /^\w+$/.test(o.label)) ? [/\w*$/, /\w+$/] : prefixMatch(options);
+  return (context) => {
+    let token = context.matchBefore(match);
+    return token || context.explicit ? { from: token ? token.from : context.pos, options, validFor } : null;
+  };
+}
+class Option {
+  constructor(completion, source, match, score2) {
+    this.completion = completion;
+    this.source = source;
+    this.match = match;
+    this.score = score2;
+  }
+}
+function cur(state) {
+  return state.selection.main.from;
+}
+function ensureAnchor(expr, start) {
+  var _a;
+  let { source } = expr;
+  let addStart = start && source[0] != "^", addEnd = source[source.length - 1] != "$";
+  if (!addStart && !addEnd)
+    return expr;
+  return new RegExp(`${addStart ? "^" : ""}(?:${source})${addEnd ? "$" : ""}`, (_a = expr.flags) !== null && _a !== void 0 ? _a : expr.ignoreCase ? "i" : "");
+}
+const pickedCompletion = /* @__PURE__ */ Annotation.define();
+function insertCompletionText(state, text, from, to) {
+  let { main } = state.selection, fromOff = from - main.from, toOff = to - main.from;
+  return Object.assign(Object.assign({}, state.changeByRange((range) => {
+    if (range != main && from != to && state.sliceDoc(range.from + fromOff, range.from + toOff) != state.sliceDoc(from, to))
+      return { range };
+    let lines = state.toText(text);
+    return {
+      changes: { from: range.from + fromOff, to: to == main.from ? range.to : range.from + toOff, insert: lines },
+      range: EditorSelection.cursor(range.from + fromOff + lines.length)
+    };
+  })), { scrollIntoView: true, userEvent: "input.complete" });
+}
+const SourceCache = /* @__PURE__ */ new WeakMap();
+function asSource(source) {
+  if (!Array.isArray(source))
+    return source;
+  let known = SourceCache.get(source);
+  if (!known)
+    SourceCache.set(source, known = completeFromList(source));
+  return known;
+}
+const startCompletionEffect = /* @__PURE__ */ StateEffect.define();
+const closeCompletionEffect = /* @__PURE__ */ StateEffect.define();
+class FuzzyMatcher {
+  constructor(pattern) {
+    this.pattern = pattern;
+    this.chars = [];
+    this.folded = [];
+    this.any = [];
+    this.precise = [];
+    this.byWord = [];
+    this.score = 0;
+    this.matched = [];
+    for (let p = 0; p < pattern.length; ) {
+      let char = codePointAt(pattern, p), size = codePointSize(char);
+      this.chars.push(char);
+      let part = pattern.slice(p, p + size), upper = part.toUpperCase();
+      this.folded.push(codePointAt(upper == part ? part.toLowerCase() : upper, 0));
+      p += size;
+    }
+    this.astral = pattern.length != this.chars.length;
+  }
+  ret(score2, matched) {
+    this.score = score2;
+    this.matched = matched;
+    return this;
+  }
+  // Matches a given word (completion) against the pattern (input).
+  // Will return a boolean indicating whether there was a match and,
+  // on success, set `this.score` to the score, `this.matched` to an
+  // array of `from, to` pairs indicating the matched parts of `word`.
+  //
+  // The score is a number that is more negative the worse the match
+  // is. See `Penalty` above.
+  match(word) {
+    if (this.pattern.length == 0)
+      return this.ret(-100, []);
+    if (word.length < this.pattern.length)
+      return null;
+    let { chars, folded, any, precise, byWord } = this;
+    if (chars.length == 1) {
+      let first = codePointAt(word, 0), firstSize = codePointSize(first);
+      let score2 = firstSize == word.length ? 0 : -100;
+      if (first == chars[0]) ;
+      else if (first == folded[0])
+        score2 += -200;
+      else
+        return null;
+      return this.ret(score2, [0, firstSize]);
+    }
+    let direct = word.indexOf(this.pattern);
+    if (direct == 0)
+      return this.ret(word.length == this.pattern.length ? 0 : -100, [0, this.pattern.length]);
+    let len = chars.length, anyTo = 0;
+    if (direct < 0) {
+      for (let i = 0, e = Math.min(word.length, 200); i < e && anyTo < len; ) {
+        let next = codePointAt(word, i);
+        if (next == chars[anyTo] || next == folded[anyTo])
+          any[anyTo++] = i;
+        i += codePointSize(next);
+      }
+      if (anyTo < len)
+        return null;
+    }
+    let preciseTo = 0;
+    let byWordTo = 0, byWordFolded = false;
+    let adjacentTo = 0, adjacentStart = -1, adjacentEnd = -1;
+    let hasLower = /[a-z]/.test(word), wordAdjacent = true;
+    for (let i = 0, e = Math.min(word.length, 200), prevType = 0; i < e && byWordTo < len; ) {
+      let next = codePointAt(word, i);
+      if (direct < 0) {
+        if (preciseTo < len && next == chars[preciseTo])
+          precise[preciseTo++] = i;
+        if (adjacentTo < len) {
+          if (next == chars[adjacentTo] || next == folded[adjacentTo]) {
+            if (adjacentTo == 0)
+              adjacentStart = i;
+            adjacentEnd = i + 1;
+            adjacentTo++;
+          } else {
+            adjacentTo = 0;
+          }
+        }
+      }
+      let ch, type = next < 255 ? next >= 48 && next <= 57 || next >= 97 && next <= 122 ? 2 : next >= 65 && next <= 90 ? 1 : 0 : (ch = fromCodePoint(next)) != ch.toLowerCase() ? 1 : ch != ch.toUpperCase() ? 2 : 0;
+      if (!i || type == 1 && hasLower || prevType == 0 && type != 0) {
+        if (chars[byWordTo] == next || folded[byWordTo] == next && (byWordFolded = true))
+          byWord[byWordTo++] = i;
+        else if (byWord.length)
+          wordAdjacent = false;
+      }
+      prevType = type;
+      i += codePointSize(next);
+    }
+    if (byWordTo == len && byWord[0] == 0 && wordAdjacent)
+      return this.result(-100 + (byWordFolded ? -200 : 0), byWord, word);
+    if (adjacentTo == len && adjacentStart == 0)
+      return this.ret(-200 - word.length + (adjacentEnd == word.length ? 0 : -100), [0, adjacentEnd]);
+    if (direct > -1)
+      return this.ret(-700 - word.length, [direct, direct + this.pattern.length]);
+    if (adjacentTo == len)
+      return this.ret(-200 + -700 - word.length, [adjacentStart, adjacentEnd]);
+    if (byWordTo == len)
+      return this.result(-100 + (byWordFolded ? -200 : 0) + -700 + (wordAdjacent ? 0 : -1100), byWord, word);
+    return chars.length == 2 ? null : this.result((any[0] ? -700 : 0) + -200 + -1100, any, word);
+  }
+  result(score2, positions, word) {
+    let result = [], i = 0;
+    for (let pos of positions) {
+      let to = pos + (this.astral ? codePointSize(codePointAt(word, pos)) : 1);
+      if (i && result[i - 1] == pos)
+        result[i - 1] = to;
+      else {
+        result[i++] = pos;
+        result[i++] = to;
+      }
+    }
+    return this.ret(score2 - word.length, result);
+  }
+}
+class StrictMatcher {
+  constructor(pattern) {
+    this.pattern = pattern;
+    this.matched = [];
+    this.score = 0;
+    this.folded = pattern.toLowerCase();
+  }
+  match(word) {
+    if (word.length < this.pattern.length)
+      return null;
+    let start = word.slice(0, this.pattern.length);
+    let match = start == this.pattern ? 0 : start.toLowerCase() == this.folded ? -200 : null;
+    if (match == null)
+      return null;
+    this.matched = [0, start.length];
+    this.score = match + (word.length == this.pattern.length ? 0 : -100);
+    return this;
+  }
+}
+const completionConfig = /* @__PURE__ */ Facet.define({
+  combine(configs) {
+    return combineConfig(configs, {
+      activateOnTyping: true,
+      activateOnCompletion: () => false,
+      activateOnTypingDelay: 100,
+      selectOnOpen: true,
+      override: null,
+      closeOnBlur: true,
+      maxRenderedOptions: 100,
+      defaultKeymap: true,
+      tooltipClass: () => "",
+      optionClass: () => "",
+      aboveCursor: false,
+      icons: true,
+      addToOptions: [],
+      positionInfo: defaultPositionInfo,
+      filterStrict: false,
+      compareCompletions: (a, b) => a.label.localeCompare(b.label),
+      interactionDelay: 75,
+      updateSyncTime: 100
+    }, {
+      defaultKeymap: (a, b) => a && b,
+      closeOnBlur: (a, b) => a && b,
+      icons: (a, b) => a && b,
+      tooltipClass: (a, b) => (c) => joinClass(a(c), b(c)),
+      optionClass: (a, b) => (c) => joinClass(a(c), b(c)),
+      addToOptions: (a, b) => a.concat(b),
+      filterStrict: (a, b) => a || b
+    });
+  }
+});
+function joinClass(a, b) {
+  return a ? b ? a + " " + b : a : b;
+}
+function defaultPositionInfo(view, list, option, info, space, tooltip) {
+  let rtl = view.textDirection == Direction.RTL, left = rtl, narrow = false;
+  let side = "top", offset, maxWidth;
+  let spaceLeft = list.left - space.left, spaceRight = space.right - list.right;
+  let infoWidth = info.right - info.left, infoHeight = info.bottom - info.top;
+  if (left && spaceLeft < Math.min(infoWidth, spaceRight))
+    left = false;
+  else if (!left && spaceRight < Math.min(infoWidth, spaceLeft))
+    left = true;
+  if (infoWidth <= (left ? spaceLeft : spaceRight)) {
+    offset = Math.max(space.top, Math.min(option.top, space.bottom - infoHeight)) - list.top;
+    maxWidth = Math.min(400, left ? spaceLeft : spaceRight);
+  } else {
+    narrow = true;
+    maxWidth = Math.min(
+      400,
+      (rtl ? list.right : space.right - list.left) - 30
+      /* Info.Margin */
+    );
+    let spaceBelow = space.bottom - list.bottom;
+    if (spaceBelow >= infoHeight || spaceBelow > list.top) {
+      offset = option.bottom - list.top;
+    } else {
+      side = "bottom";
+      offset = list.bottom - option.top;
+    }
+  }
+  let scaleY = (list.bottom - list.top) / tooltip.offsetHeight;
+  let scaleX = (list.right - list.left) / tooltip.offsetWidth;
+  return {
+    style: `${side}: ${offset / scaleY}px; max-width: ${maxWidth / scaleX}px`,
+    class: "cm-completionInfo-" + (narrow ? rtl ? "left-narrow" : "right-narrow" : left ? "left" : "right")
+  };
+}
+function optionContent(config2) {
+  let content = config2.addToOptions.slice();
+  if (config2.icons)
+    content.push({
+      render(completion) {
+        let icon = document.createElement("div");
+        icon.classList.add("cm-completionIcon");
+        if (completion.type)
+          icon.classList.add(...completion.type.split(/\s+/g).map((cls) => "cm-completionIcon-" + cls));
+        icon.setAttribute("aria-hidden", "true");
+        return icon;
+      },
+      position: 20
+    });
+  content.push({
+    render(completion, _s, _v, match) {
+      let labelElt = document.createElement("span");
+      labelElt.className = "cm-completionLabel";
+      let label = completion.displayLabel || completion.label, off = 0;
+      for (let j = 0; j < match.length; ) {
+        let from = match[j++], to = match[j++];
+        if (from > off)
+          labelElt.appendChild(document.createTextNode(label.slice(off, from)));
+        let span = labelElt.appendChild(document.createElement("span"));
+        span.appendChild(document.createTextNode(label.slice(from, to)));
+        span.className = "cm-completionMatchedText";
+        off = to;
+      }
+      if (off < label.length)
+        labelElt.appendChild(document.createTextNode(label.slice(off)));
+      return labelElt;
+    },
+    position: 50
+  }, {
+    render(completion) {
+      if (!completion.detail)
+        return null;
+      let detailElt = document.createElement("span");
+      detailElt.className = "cm-completionDetail";
+      detailElt.textContent = completion.detail;
+      return detailElt;
+    },
+    position: 80
+  });
+  return content.sort((a, b) => a.position - b.position).map((a) => a.render);
+}
+function rangeAroundSelected(total, selected, max) {
+  if (total <= max)
+    return { from: 0, to: total };
+  if (selected < 0)
+    selected = 0;
+  if (selected <= total >> 1) {
+    let off2 = Math.floor(selected / max);
+    return { from: off2 * max, to: (off2 + 1) * max };
+  }
+  let off = Math.floor((total - selected) / max);
+  return { from: total - (off + 1) * max, to: total - off * max };
+}
+class CompletionTooltip {
+  constructor(view, stateField, applyCompletion2) {
+    this.view = view;
+    this.stateField = stateField;
+    this.applyCompletion = applyCompletion2;
+    this.info = null;
+    this.infoDestroy = null;
+    this.placeInfoReq = {
+      read: () => this.measureInfo(),
+      write: (pos) => this.placeInfo(pos),
+      key: this
+    };
+    this.space = null;
+    this.currentClass = "";
+    let cState = view.state.field(stateField);
+    let { options, selected } = cState.open;
+    let config2 = view.state.facet(completionConfig);
+    this.optionContent = optionContent(config2);
+    this.optionClass = config2.optionClass;
+    this.tooltipClass = config2.tooltipClass;
+    this.range = rangeAroundSelected(options.length, selected, config2.maxRenderedOptions);
+    this.dom = document.createElement("div");
+    this.dom.className = "cm-tooltip-autocomplete";
+    this.updateTooltipClass(view.state);
+    this.dom.addEventListener("mousedown", (e) => {
+      let { options: options2 } = view.state.field(stateField).open;
+      for (let dom = e.target, match; dom && dom != this.dom; dom = dom.parentNode) {
+        if (dom.nodeName == "LI" && (match = /-(\d+)$/.exec(dom.id)) && +match[1] < options2.length) {
+          this.applyCompletion(view, options2[+match[1]]);
+          e.preventDefault();
+          return;
+        }
+      }
+    });
+    this.dom.addEventListener("focusout", (e) => {
+      let state = view.state.field(this.stateField, false);
+      if (state && state.tooltip && view.state.facet(completionConfig).closeOnBlur && e.relatedTarget != view.contentDOM)
+        view.dispatch({ effects: closeCompletionEffect.of(null) });
+    });
+    this.showOptions(options, cState.id);
+  }
+  mount() {
+    this.updateSel();
+  }
+  showOptions(options, id) {
+    if (this.list)
+      this.list.remove();
+    this.list = this.dom.appendChild(this.createListBox(options, id, this.range));
+    this.list.addEventListener("scroll", () => {
+      if (this.info)
+        this.view.requestMeasure(this.placeInfoReq);
+    });
+  }
+  update(update) {
+    var _a;
+    let cState = update.state.field(this.stateField);
+    let prevState = update.startState.field(this.stateField);
+    this.updateTooltipClass(update.state);
+    if (cState != prevState) {
+      let { options, selected, disabled } = cState.open;
+      if (!prevState.open || prevState.open.options != options) {
+        this.range = rangeAroundSelected(options.length, selected, update.state.facet(completionConfig).maxRenderedOptions);
+        this.showOptions(options, cState.id);
+      }
+      this.updateSel();
+      if (disabled != ((_a = prevState.open) === null || _a === void 0 ? void 0 : _a.disabled))
+        this.dom.classList.toggle("cm-tooltip-autocomplete-disabled", !!disabled);
+    }
+  }
+  updateTooltipClass(state) {
+    let cls = this.tooltipClass(state);
+    if (cls != this.currentClass) {
+      for (let c of this.currentClass.split(" "))
+        if (c)
+          this.dom.classList.remove(c);
+      for (let c of cls.split(" "))
+        if (c)
+          this.dom.classList.add(c);
+      this.currentClass = cls;
+    }
+  }
+  positioned(space) {
+    this.space = space;
+    if (this.info)
+      this.view.requestMeasure(this.placeInfoReq);
+  }
+  updateSel() {
+    let cState = this.view.state.field(this.stateField), open = cState.open;
+    if (open.selected > -1 && open.selected < this.range.from || open.selected >= this.range.to) {
+      this.range = rangeAroundSelected(open.options.length, open.selected, this.view.state.facet(completionConfig).maxRenderedOptions);
+      this.showOptions(open.options, cState.id);
+    }
+    if (this.updateSelectedOption(open.selected)) {
+      this.destroyInfo();
+      let { completion } = open.options[open.selected];
+      let { info } = completion;
+      if (!info)
+        return;
+      let infoResult = typeof info === "string" ? document.createTextNode(info) : info(completion);
+      if (!infoResult)
+        return;
+      if ("then" in infoResult) {
+        infoResult.then((obj) => {
+          if (obj && this.view.state.field(this.stateField, false) == cState)
+            this.addInfoPane(obj, completion);
+        }).catch((e) => logException(this.view.state, e, "completion info"));
+      } else {
+        this.addInfoPane(infoResult, completion);
+      }
+    }
+  }
+  addInfoPane(content, completion) {
+    this.destroyInfo();
+    let wrap = this.info = document.createElement("div");
+    wrap.className = "cm-tooltip cm-completionInfo";
+    if (content.nodeType != null) {
+      wrap.appendChild(content);
+      this.infoDestroy = null;
+    } else {
+      let { dom, destroy } = content;
+      wrap.appendChild(dom);
+      this.infoDestroy = destroy || null;
+    }
+    this.dom.appendChild(wrap);
+    this.view.requestMeasure(this.placeInfoReq);
+  }
+  updateSelectedOption(selected) {
+    let set = null;
+    for (let opt = this.list.firstChild, i = this.range.from; opt; opt = opt.nextSibling, i++) {
+      if (opt.nodeName != "LI" || !opt.id) {
+        i--;
+      } else if (i == selected) {
+        if (!opt.hasAttribute("aria-selected")) {
+          opt.setAttribute("aria-selected", "true");
+          set = opt;
+        }
+      } else {
+        if (opt.hasAttribute("aria-selected"))
+          opt.removeAttribute("aria-selected");
+      }
+    }
+    if (set)
+      scrollIntoView(this.list, set);
+    return set;
+  }
+  measureInfo() {
+    let sel = this.dom.querySelector("[aria-selected]");
+    if (!sel || !this.info)
+      return null;
+    let listRect = this.dom.getBoundingClientRect();
+    let infoRect = this.info.getBoundingClientRect();
+    let selRect = sel.getBoundingClientRect();
+    let space = this.space;
+    if (!space) {
+      let docElt = this.dom.ownerDocument.documentElement;
+      space = { left: 0, top: 0, right: docElt.clientWidth, bottom: docElt.clientHeight };
+    }
+    if (selRect.top > Math.min(space.bottom, listRect.bottom) - 10 || selRect.bottom < Math.max(space.top, listRect.top) + 10)
+      return null;
+    return this.view.state.facet(completionConfig).positionInfo(this.view, listRect, selRect, infoRect, space, this.dom);
+  }
+  placeInfo(pos) {
+    if (this.info) {
+      if (pos) {
+        if (pos.style)
+          this.info.style.cssText = pos.style;
+        this.info.className = "cm-tooltip cm-completionInfo " + (pos.class || "");
+      } else {
+        this.info.style.cssText = "top: -1e6px";
+      }
+    }
+  }
+  createListBox(options, id, range) {
+    const ul = document.createElement("ul");
+    ul.id = id;
+    ul.setAttribute("role", "listbox");
+    ul.setAttribute("aria-expanded", "true");
+    ul.setAttribute("aria-label", this.view.state.phrase("Completions"));
+    ul.addEventListener("mousedown", (e) => {
+      if (e.target == ul)
+        e.preventDefault();
+    });
+    let curSection = null;
+    for (let i = range.from; i < range.to; i++) {
+      let { completion, match } = options[i], { section } = completion;
+      if (section) {
+        let name = typeof section == "string" ? section : section.name;
+        if (name != curSection && (i > range.from || range.from == 0)) {
+          curSection = name;
+          if (typeof section != "string" && section.header) {
+            ul.appendChild(section.header(section));
+          } else {
+            let header = ul.appendChild(document.createElement("completion-section"));
+            header.textContent = name;
+          }
+        }
+      }
+      const li = ul.appendChild(document.createElement("li"));
+      li.id = id + "-" + i;
+      li.setAttribute("role", "option");
+      let cls = this.optionClass(completion);
+      if (cls)
+        li.className = cls;
+      for (let source of this.optionContent) {
+        let node = source(completion, this.view.state, this.view, match);
+        if (node)
+          li.appendChild(node);
+      }
+    }
+    if (range.from)
+      ul.classList.add("cm-completionListIncompleteTop");
+    if (range.to < options.length)
+      ul.classList.add("cm-completionListIncompleteBottom");
+    return ul;
+  }
+  destroyInfo() {
+    if (this.info) {
+      if (this.infoDestroy)
+        this.infoDestroy();
+      this.info.remove();
+      this.info = null;
+    }
+  }
+  destroy() {
+    this.destroyInfo();
+  }
+}
+function completionTooltip(stateField, applyCompletion2) {
+  return (view) => new CompletionTooltip(view, stateField, applyCompletion2);
+}
+function scrollIntoView(container, element) {
+  let parent = container.getBoundingClientRect();
+  let self = element.getBoundingClientRect();
+  let scaleY = parent.height / container.offsetHeight;
+  if (self.top < parent.top)
+    container.scrollTop -= (parent.top - self.top) / scaleY;
+  else if (self.bottom > parent.bottom)
+    container.scrollTop += (self.bottom - parent.bottom) / scaleY;
+}
+function score(option) {
+  return (option.boost || 0) * 100 + (option.apply ? 10 : 0) + (option.info ? 5 : 0) + (option.type ? 1 : 0);
+}
+function sortOptions(active, state) {
+  let options = [];
+  let sections = null;
+  let addOption = (option) => {
+    options.push(option);
+    let { section } = option.completion;
+    if (section) {
+      if (!sections)
+        sections = [];
+      let name = typeof section == "string" ? section : section.name;
+      if (!sections.some((s) => s.name == name))
+        sections.push(typeof section == "string" ? { name } : section);
+    }
+  };
+  let conf = state.facet(completionConfig);
+  for (let a of active)
+    if (a.hasResult()) {
+      let getMatch = a.result.getMatch;
+      if (a.result.filter === false) {
+        for (let option of a.result.options) {
+          addOption(new Option(option, a.source, getMatch ? getMatch(option) : [], 1e9 - options.length));
+        }
+      } else {
+        let pattern = state.sliceDoc(a.from, a.to), match;
+        let matcher = conf.filterStrict ? new StrictMatcher(pattern) : new FuzzyMatcher(pattern);
+        for (let option of a.result.options)
+          if (match = matcher.match(option.label)) {
+            let matched = !option.displayLabel ? match.matched : getMatch ? getMatch(option, match.matched) : [];
+            addOption(new Option(option, a.source, matched, match.score + (option.boost || 0)));
+          }
+      }
+    }
+  if (sections) {
+    let sectionOrder = /* @__PURE__ */ Object.create(null), pos = 0;
+    let cmp = (a, b) => {
+      var _a, _b;
+      return ((_a = a.rank) !== null && _a !== void 0 ? _a : 1e9) - ((_b = b.rank) !== null && _b !== void 0 ? _b : 1e9) || (a.name < b.name ? -1 : 1);
+    };
+    for (let s of sections.sort(cmp)) {
+      pos -= 1e5;
+      sectionOrder[s.name] = pos;
+    }
+    for (let option of options) {
+      let { section } = option.completion;
+      if (section)
+        option.score += sectionOrder[typeof section == "string" ? section : section.name];
+    }
+  }
+  let result = [], prev = null;
+  let compare = conf.compareCompletions;
+  for (let opt of options.sort((a, b) => b.score - a.score || compare(a.completion, b.completion))) {
+    let cur2 = opt.completion;
+    if (!prev || prev.label != cur2.label || prev.detail != cur2.detail || prev.type != null && cur2.type != null && prev.type != cur2.type || prev.apply != cur2.apply || prev.boost != cur2.boost)
+      result.push(opt);
+    else if (score(opt.completion) > score(prev))
+      result[result.length - 1] = opt;
+    prev = opt.completion;
+  }
+  return result;
+}
+class CompletionDialog {
+  constructor(options, attrs, tooltip, timestamp, selected, disabled) {
+    this.options = options;
+    this.attrs = attrs;
+    this.tooltip = tooltip;
+    this.timestamp = timestamp;
+    this.selected = selected;
+    this.disabled = disabled;
+  }
+  setSelected(selected, id) {
+    return selected == this.selected || selected >= this.options.length ? this : new CompletionDialog(this.options, makeAttrs(id, selected), this.tooltip, this.timestamp, selected, this.disabled);
+  }
+  static build(active, state, id, prev, conf, didSetActive) {
+    if (prev && !didSetActive && active.some((s) => s.isPending))
+      return prev.setDisabled();
+    let options = sortOptions(active, state);
+    if (!options.length)
+      return prev && active.some((a) => a.isPending) ? prev.setDisabled() : null;
+    let selected = state.facet(completionConfig).selectOnOpen ? 0 : -1;
+    if (prev && prev.selected != selected && prev.selected != -1) {
+      let selectedValue = prev.options[prev.selected].completion;
+      for (let i = 0; i < options.length; i++)
+        if (options[i].completion == selectedValue) {
+          selected = i;
+          break;
+        }
+    }
+    return new CompletionDialog(options, makeAttrs(id, selected), {
+      pos: active.reduce((a, b) => b.hasResult() ? Math.min(a, b.from) : a, 1e8),
+      create: createTooltip,
+      above: conf.aboveCursor
+    }, prev ? prev.timestamp : Date.now(), selected, false);
+  }
+  map(changes) {
+    return new CompletionDialog(this.options, this.attrs, Object.assign(Object.assign({}, this.tooltip), { pos: changes.mapPos(this.tooltip.pos) }), this.timestamp, this.selected, this.disabled);
+  }
+  setDisabled() {
+    return new CompletionDialog(this.options, this.attrs, this.tooltip, this.timestamp, this.selected, true);
+  }
+}
+class CompletionState {
+  constructor(active, id, open) {
+    this.active = active;
+    this.id = id;
+    this.open = open;
+  }
+  static start() {
+    return new CompletionState(none, "cm-ac-" + Math.floor(Math.random() * 2e6).toString(36), null);
+  }
+  update(tr) {
+    let { state } = tr, conf = state.facet(completionConfig);
+    let sources = conf.override || state.languageDataAt("autocomplete", cur(state)).map(asSource);
+    let active = sources.map((source) => {
+      let value = this.active.find((s) => s.source == source) || new ActiveSource(
+        source,
+        this.active.some(
+          (a) => a.state != 0
+          /* State.Inactive */
+        ) ? 1 : 0
+        /* State.Inactive */
+      );
+      return value.update(tr, conf);
+    });
+    if (active.length == this.active.length && active.every((a, i) => a == this.active[i]))
+      active = this.active;
+    let open = this.open, didSet = tr.effects.some((e) => e.is(setActiveEffect));
+    if (open && tr.docChanged)
+      open = open.map(tr.changes);
+    if (tr.selection || active.some((a) => a.hasResult() && tr.changes.touchesRange(a.from, a.to)) || !sameResults(active, this.active) || didSet)
+      open = CompletionDialog.build(active, state, this.id, open, conf, didSet);
+    else if (open && open.disabled && !active.some((a) => a.isPending))
+      open = null;
+    if (!open && active.every((a) => !a.isPending) && active.some((a) => a.hasResult()))
+      active = active.map((a) => a.hasResult() ? new ActiveSource(
+        a.source,
+        0
+        /* State.Inactive */
+      ) : a);
+    for (let effect of tr.effects)
+      if (effect.is(setSelectedEffect))
+        open = open && open.setSelected(effect.value, this.id);
+    return active == this.active && open == this.open ? this : new CompletionState(active, this.id, open);
+  }
+  get tooltip() {
+    return this.open ? this.open.tooltip : null;
+  }
+  get attrs() {
+    return this.open ? this.open.attrs : this.active.length ? baseAttrs : noAttrs;
+  }
+}
+function sameResults(a, b) {
+  if (a == b)
+    return true;
+  for (let iA = 0, iB = 0; ; ) {
+    while (iA < a.length && !a[iA].hasResult())
+      iA++;
+    while (iB < b.length && !b[iB].hasResult())
+      iB++;
+    let endA = iA == a.length, endB = iB == b.length;
+    if (endA || endB)
+      return endA == endB;
+    if (a[iA++].result != b[iB++].result)
+      return false;
+  }
+}
+const baseAttrs = {
+  "aria-autocomplete": "list"
+};
+const noAttrs = {};
+function makeAttrs(id, selected) {
+  let result = {
+    "aria-autocomplete": "list",
+    "aria-haspopup": "listbox",
+    "aria-controls": id
+  };
+  if (selected > -1)
+    result["aria-activedescendant"] = id + "-" + selected;
+  return result;
+}
+const none = [];
+function getUpdateType(tr, conf) {
+  if (tr.isUserEvent("input.complete")) {
+    let completion = tr.annotation(pickedCompletion);
+    if (completion && conf.activateOnCompletion(completion))
+      return 4 | 8;
+  }
+  let typing = tr.isUserEvent("input.type");
+  return typing && conf.activateOnTyping ? 4 | 1 : typing ? 1 : tr.isUserEvent("delete.backward") ? 2 : tr.selection ? 8 : tr.docChanged ? 16 : 0;
+}
+class ActiveSource {
+  constructor(source, state, explicit = false) {
+    this.source = source;
+    this.state = state;
+    this.explicit = explicit;
+  }
+  hasResult() {
+    return false;
+  }
+  get isPending() {
+    return this.state == 1;
+  }
+  update(tr, conf) {
+    let type = getUpdateType(tr, conf), value = this;
+    if (type & 8 || type & 16 && this.touches(tr))
+      value = new ActiveSource(
+        value.source,
+        0
+        /* State.Inactive */
+      );
+    if (type & 4 && value.state == 0)
+      value = new ActiveSource(
+        this.source,
+        1
+        /* State.Pending */
+      );
+    value = value.updateFor(tr, type);
+    for (let effect of tr.effects) {
+      if (effect.is(startCompletionEffect))
+        value = new ActiveSource(value.source, 1, effect.value);
+      else if (effect.is(closeCompletionEffect))
+        value = new ActiveSource(
+          value.source,
+          0
+          /* State.Inactive */
+        );
+      else if (effect.is(setActiveEffect)) {
+        for (let active of effect.value)
+          if (active.source == value.source)
+            value = active;
+      }
+    }
+    return value;
+  }
+  updateFor(tr, type) {
+    return this.map(tr.changes);
+  }
+  map(changes) {
+    return this;
+  }
+  touches(tr) {
+    return tr.changes.touchesRange(cur(tr.state));
+  }
+}
+class ActiveResult extends ActiveSource {
+  constructor(source, explicit, limit, result, from, to) {
+    super(source, 3, explicit);
+    this.limit = limit;
+    this.result = result;
+    this.from = from;
+    this.to = to;
+  }
+  hasResult() {
+    return true;
+  }
+  updateFor(tr, type) {
+    var _a;
+    if (!(type & 3))
+      return this.map(tr.changes);
+    let result = this.result;
+    if (result.map && !tr.changes.empty)
+      result = result.map(result, tr.changes);
+    let from = tr.changes.mapPos(this.from), to = tr.changes.mapPos(this.to, 1);
+    let pos = cur(tr.state);
+    if (pos > to || !result || type & 2 && (cur(tr.startState) == this.from || pos < this.limit))
+      return new ActiveSource(
+        this.source,
+        type & 4 ? 1 : 0
+        /* State.Inactive */
+      );
+    let limit = tr.changes.mapPos(this.limit);
+    if (checkValid(result.validFor, tr.state, from, to))
+      return new ActiveResult(this.source, this.explicit, limit, result, from, to);
+    if (result.update && (result = result.update(result, from, to, new CompletionContext(tr.state, pos, false))))
+      return new ActiveResult(this.source, this.explicit, limit, result, result.from, (_a = result.to) !== null && _a !== void 0 ? _a : cur(tr.state));
+    return new ActiveSource(this.source, 1, this.explicit);
+  }
+  map(mapping) {
+    if (mapping.empty)
+      return this;
+    let result = this.result.map ? this.result.map(this.result, mapping) : this.result;
+    if (!result)
+      return new ActiveSource(
+        this.source,
+        0
+        /* State.Inactive */
+      );
+    return new ActiveResult(this.source, this.explicit, mapping.mapPos(this.limit), this.result, mapping.mapPos(this.from), mapping.mapPos(this.to, 1));
+  }
+  touches(tr) {
+    return tr.changes.touchesRange(this.from, this.to);
+  }
+}
+function checkValid(validFor, state, from, to) {
+  if (!validFor)
+    return false;
+  let text = state.sliceDoc(from, to);
+  return typeof validFor == "function" ? validFor(text, from, to, state) : ensureAnchor(validFor, true).test(text);
+}
+const setActiveEffect = /* @__PURE__ */ StateEffect.define({
+  map(sources, mapping) {
+    return sources.map((s) => s.map(mapping));
+  }
+});
+const setSelectedEffect = /* @__PURE__ */ StateEffect.define();
+const completionState = /* @__PURE__ */ StateField.define({
+  create() {
+    return CompletionState.start();
+  },
+  update(value, tr) {
+    return value.update(tr);
+  },
+  provide: (f) => [
+    showTooltip.from(f, (val) => val.tooltip),
+    EditorView.contentAttributes.from(f, (state) => state.attrs)
+  ]
+});
+function applyCompletion(view, option) {
+  const apply = option.completion.apply || option.completion.label;
+  let result = view.state.field(completionState).active.find((a) => a.source == option.source);
+  if (!(result instanceof ActiveResult))
+    return false;
+  if (typeof apply == "string")
+    view.dispatch(Object.assign(Object.assign({}, insertCompletionText(view.state, apply, result.from, result.to)), { annotations: pickedCompletion.of(option.completion) }));
+  else
+    apply(view, option.completion, result.from, result.to);
+  return true;
+}
+const createTooltip = /* @__PURE__ */ completionTooltip(completionState, applyCompletion);
+function moveCompletionSelection(forward, by = "option") {
+  return (view) => {
+    let cState = view.state.field(completionState, false);
+    if (!cState || !cState.open || cState.open.disabled || Date.now() - cState.open.timestamp < view.state.facet(completionConfig).interactionDelay)
+      return false;
+    let step = 1, tooltip;
+    if (by == "page" && (tooltip = getTooltip(view, cState.open.tooltip)))
+      step = Math.max(2, Math.floor(tooltip.dom.offsetHeight / tooltip.dom.querySelector("li").offsetHeight) - 1);
+    let { length } = cState.open.options;
+    let selected = cState.open.selected > -1 ? cState.open.selected + step * (forward ? 1 : -1) : forward ? 0 : length - 1;
+    if (selected < 0)
+      selected = by == "page" ? 0 : length - 1;
+    else if (selected >= length)
+      selected = by == "page" ? length - 1 : 0;
+    view.dispatch({ effects: setSelectedEffect.of(selected) });
+    return true;
+  };
+}
+const acceptCompletion = (view) => {
+  let cState = view.state.field(completionState, false);
+  if (view.state.readOnly || !cState || !cState.open || cState.open.selected < 0 || cState.open.disabled || Date.now() - cState.open.timestamp < view.state.facet(completionConfig).interactionDelay)
+    return false;
+  return applyCompletion(view, cState.open.options[cState.open.selected]);
+};
+const startCompletion = (view) => {
+  let cState = view.state.field(completionState, false);
+  if (!cState)
+    return false;
+  view.dispatch({ effects: startCompletionEffect.of(true) });
+  return true;
+};
+const closeCompletion = (view) => {
+  let cState = view.state.field(completionState, false);
+  if (!cState || !cState.active.some(
+    (a) => a.state != 0
+    /* State.Inactive */
+  ))
+    return false;
+  view.dispatch({ effects: closeCompletionEffect.of(null) });
+  return true;
+};
+class RunningQuery {
+  constructor(active, context) {
+    this.active = active;
+    this.context = context;
+    this.time = Date.now();
+    this.updates = [];
+    this.done = void 0;
+  }
+}
+const MaxUpdateCount = 50, MinAbortTime = 1e3;
+const completionPlugin = /* @__PURE__ */ ViewPlugin.fromClass(class {
+  constructor(view) {
+    this.view = view;
+    this.debounceUpdate = -1;
+    this.running = [];
+    this.debounceAccept = -1;
+    this.pendingStart = false;
+    this.composing = 0;
+    for (let active of view.state.field(completionState).active)
+      if (active.isPending)
+        this.startQuery(active);
+  }
+  update(update) {
+    let cState = update.state.field(completionState);
+    let conf = update.state.facet(completionConfig);
+    if (!update.selectionSet && !update.docChanged && update.startState.field(completionState) == cState)
+      return;
+    let doesReset = update.transactions.some((tr) => {
+      let type = getUpdateType(tr, conf);
+      return type & 8 || (tr.selection || tr.docChanged) && !(type & 3);
+    });
+    for (let i = 0; i < this.running.length; i++) {
+      let query = this.running[i];
+      if (doesReset || query.context.abortOnDocChange && update.docChanged || query.updates.length + update.transactions.length > MaxUpdateCount && Date.now() - query.time > MinAbortTime) {
+        for (let handler of query.context.abortListeners) {
+          try {
+            handler();
+          } catch (e) {
+            logException(this.view.state, e);
+          }
+        }
+        query.context.abortListeners = null;
+        this.running.splice(i--, 1);
+      } else {
+        query.updates.push(...update.transactions);
+      }
+    }
+    if (this.debounceUpdate > -1)
+      clearTimeout(this.debounceUpdate);
+    if (update.transactions.some((tr) => tr.effects.some((e) => e.is(startCompletionEffect))))
+      this.pendingStart = true;
+    let delay = this.pendingStart ? 50 : conf.activateOnTypingDelay;
+    this.debounceUpdate = cState.active.some((a) => a.isPending && !this.running.some((q) => q.active.source == a.source)) ? setTimeout(() => this.startUpdate(), delay) : -1;
+    if (this.composing != 0)
+      for (let tr of update.transactions) {
+        if (tr.isUserEvent("input.type"))
+          this.composing = 2;
+        else if (this.composing == 2 && tr.selection)
+          this.composing = 3;
+      }
+  }
+  startUpdate() {
+    this.debounceUpdate = -1;
+    this.pendingStart = false;
+    let { state } = this.view, cState = state.field(completionState);
+    for (let active of cState.active) {
+      if (active.isPending && !this.running.some((r) => r.active.source == active.source))
+        this.startQuery(active);
+    }
+    if (this.running.length && cState.open && cState.open.disabled)
+      this.debounceAccept = setTimeout(() => this.accept(), this.view.state.facet(completionConfig).updateSyncTime);
+  }
+  startQuery(active) {
+    let { state } = this.view, pos = cur(state);
+    let context = new CompletionContext(state, pos, active.explicit, this.view);
+    let pending = new RunningQuery(active, context);
+    this.running.push(pending);
+    Promise.resolve(active.source(context)).then((result) => {
+      if (!pending.context.aborted) {
+        pending.done = result || null;
+        this.scheduleAccept();
+      }
+    }, (err) => {
+      this.view.dispatch({ effects: closeCompletionEffect.of(null) });
+      logException(this.view.state, err);
+    });
+  }
+  scheduleAccept() {
+    if (this.running.every((q) => q.done !== void 0))
+      this.accept();
+    else if (this.debounceAccept < 0)
+      this.debounceAccept = setTimeout(() => this.accept(), this.view.state.facet(completionConfig).updateSyncTime);
+  }
+  // For each finished query in this.running, try to create a result
+  // or, if appropriate, restart the query.
+  accept() {
+    var _a;
+    if (this.debounceAccept > -1)
+      clearTimeout(this.debounceAccept);
+    this.debounceAccept = -1;
+    let updated = [];
+    let conf = this.view.state.facet(completionConfig), cState = this.view.state.field(completionState);
+    for (let i = 0; i < this.running.length; i++) {
+      let query = this.running[i];
+      if (query.done === void 0)
+        continue;
+      this.running.splice(i--, 1);
+      if (query.done) {
+        let pos = cur(query.updates.length ? query.updates[0].startState : this.view.state);
+        let limit = Math.min(pos, query.done.from + (query.active.explicit ? 0 : 1));
+        let active = new ActiveResult(query.active.source, query.active.explicit, limit, query.done, query.done.from, (_a = query.done.to) !== null && _a !== void 0 ? _a : pos);
+        for (let tr of query.updates)
+          active = active.update(tr, conf);
+        if (active.hasResult()) {
+          updated.push(active);
+          continue;
+        }
+      }
+      let current = cState.active.find((a) => a.source == query.active.source);
+      if (current && current.isPending) {
+        if (query.done == null) {
+          let active = new ActiveSource(
+            query.active.source,
+            0
+            /* State.Inactive */
+          );
+          for (let tr of query.updates)
+            active = active.update(tr, conf);
+          if (!active.isPending)
+            updated.push(active);
+        } else {
+          this.startQuery(current);
+        }
+      }
+    }
+    if (updated.length || cState.open && cState.open.disabled)
+      this.view.dispatch({ effects: setActiveEffect.of(updated) });
+  }
+}, {
+  eventHandlers: {
+    blur(event) {
+      let state = this.view.state.field(completionState, false);
+      if (state && state.tooltip && this.view.state.facet(completionConfig).closeOnBlur) {
+        let dialog = state.open && getTooltip(this.view, state.open.tooltip);
+        if (!dialog || !dialog.dom.contains(event.relatedTarget))
+          setTimeout(() => this.view.dispatch({ effects: closeCompletionEffect.of(null) }), 10);
+      }
+    },
+    compositionstart() {
+      this.composing = 1;
+    },
+    compositionend() {
+      if (this.composing == 3) {
+        setTimeout(() => this.view.dispatch({ effects: startCompletionEffect.of(false) }), 20);
+      }
+      this.composing = 0;
+    }
+  }
+});
+const windows = typeof navigator == "object" && /* @__PURE__ */ /Win/.test(navigator.platform);
+const commitCharacters = /* @__PURE__ */ Prec.highest(/* @__PURE__ */ EditorView.domEventHandlers({
+  keydown(event, view) {
+    let field = view.state.field(completionState, false);
+    if (!field || !field.open || field.open.disabled || field.open.selected < 0 || event.key.length > 1 || event.ctrlKey && !(windows && event.altKey) || event.metaKey)
+      return false;
+    let option = field.open.options[field.open.selected];
+    let result = field.active.find((a) => a.source == option.source);
+    let commitChars = option.completion.commitCharacters || result.result.commitCharacters;
+    if (commitChars && commitChars.indexOf(event.key) > -1)
+      applyCompletion(view, option);
+    return false;
+  }
+}));
+const baseTheme$2 = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-tooltip.cm-tooltip-autocomplete": {
+    "& > ul": {
+      fontFamily: "monospace",
+      whiteSpace: "nowrap",
+      overflow: "hidden auto",
+      maxWidth_fallback: "700px",
+      maxWidth: "min(700px, 95vw)",
+      minWidth: "250px",
+      maxHeight: "10em",
+      height: "100%",
+      listStyle: "none",
+      margin: 0,
+      padding: 0,
+      "& > li, & > completion-section": {
+        padding: "1px 3px",
+        lineHeight: 1.2
+      },
+      "& > li": {
+        overflowX: "hidden",
+        textOverflow: "ellipsis",
+        cursor: "pointer"
+      },
+      "& > completion-section": {
+        display: "list-item",
+        borderBottom: "1px solid silver",
+        paddingLeft: "0.5em",
+        opacity: 0.7
+      }
+    }
+  },
+  "&light .cm-tooltip-autocomplete ul li[aria-selected]": {
+    background: "#17c",
+    color: "white"
+  },
+  "&light .cm-tooltip-autocomplete-disabled ul li[aria-selected]": {
+    background: "#777"
+  },
+  "&dark .cm-tooltip-autocomplete ul li[aria-selected]": {
+    background: "#347",
+    color: "white"
+  },
+  "&dark .cm-tooltip-autocomplete-disabled ul li[aria-selected]": {
+    background: "#444"
+  },
+  ".cm-completionListIncompleteTop:before, .cm-completionListIncompleteBottom:after": {
+    content: '"···"',
+    opacity: 0.5,
+    display: "block",
+    textAlign: "center"
+  },
+  ".cm-tooltip.cm-completionInfo": {
+    position: "absolute",
+    padding: "3px 9px",
+    width: "max-content",
+    maxWidth: `${400}px`,
+    boxSizing: "border-box",
+    whiteSpace: "pre-line"
+  },
+  ".cm-completionInfo.cm-completionInfo-left": { right: "100%" },
+  ".cm-completionInfo.cm-completionInfo-right": { left: "100%" },
+  ".cm-completionInfo.cm-completionInfo-left-narrow": { right: `${30}px` },
+  ".cm-completionInfo.cm-completionInfo-right-narrow": { left: `${30}px` },
+  "&light .cm-snippetField": { backgroundColor: "#00000022" },
+  "&dark .cm-snippetField": { backgroundColor: "#ffffff22" },
+  ".cm-snippetFieldPosition": {
+    verticalAlign: "text-top",
+    width: 0,
+    height: "1.15em",
+    display: "inline-block",
+    margin: "0 -0.7px -.7em",
+    borderLeft: "1.4px dotted #888"
+  },
+  ".cm-completionMatchedText": {
+    textDecoration: "underline"
+  },
+  ".cm-completionDetail": {
+    marginLeft: "0.5em",
+    fontStyle: "italic"
+  },
+  ".cm-completionIcon": {
+    fontSize: "90%",
+    width: ".8em",
+    display: "inline-block",
+    textAlign: "center",
+    paddingRight: ".6em",
+    opacity: "0.6",
+    boxSizing: "content-box"
+  },
+  ".cm-completionIcon-function, .cm-completionIcon-method": {
+    "&:after": { content: "'ƒ'" }
+  },
+  ".cm-completionIcon-class": {
+    "&:after": { content: "'○'" }
+  },
+  ".cm-completionIcon-interface": {
+    "&:after": { content: "'◌'" }
+  },
+  ".cm-completionIcon-variable": {
+    "&:after": { content: "'𝑥'" }
+  },
+  ".cm-completionIcon-constant": {
+    "&:after": { content: "'𝐶'" }
+  },
+  ".cm-completionIcon-type": {
+    "&:after": { content: "'𝑡'" }
+  },
+  ".cm-completionIcon-enum": {
+    "&:after": { content: "'∪'" }
+  },
+  ".cm-completionIcon-property": {
+    "&:after": { content: "'□'" }
+  },
+  ".cm-completionIcon-keyword": {
+    "&:after": { content: "'🔑︎'" }
+    // Disable emoji rendering
+  },
+  ".cm-completionIcon-namespace": {
+    "&:after": { content: "'▢'" }
+  },
+  ".cm-completionIcon-text": {
+    "&:after": { content: "'abc'", fontSize: "50%", verticalAlign: "middle" }
+  }
+});
+const defaults = {
+  brackets: ["(", "[", "{", "'", '"'],
+  before: ")]}:;>",
+  stringPrefixes: []
+};
+const closeBracketEffect = /* @__PURE__ */ StateEffect.define({
+  map(value, mapping) {
+    let mapped = mapping.mapPos(value, -1, MapMode.TrackAfter);
+    return mapped == null ? void 0 : mapped;
+  }
+});
+const closedBracket = /* @__PURE__ */ new class extends RangeValue {
+}();
+closedBracket.startSide = 1;
+closedBracket.endSide = -1;
+const bracketState = /* @__PURE__ */ StateField.define({
+  create() {
+    return RangeSet.empty;
+  },
+  update(value, tr) {
+    value = value.map(tr.changes);
+    if (tr.selection) {
+      let line = tr.state.doc.lineAt(tr.selection.main.head);
+      value = value.update({ filter: (from) => from >= line.from && from <= line.to });
+    }
+    for (let effect of tr.effects)
+      if (effect.is(closeBracketEffect))
+        value = value.update({ add: [closedBracket.range(effect.value, effect.value + 1)] });
+    return value;
+  }
+});
+function closeBrackets() {
+  return [inputHandler, bracketState];
+}
+const definedClosing = "()[]{}<>«»»«［］｛｝";
+function closing(ch) {
+  for (let i = 0; i < definedClosing.length; i += 2)
+    if (definedClosing.charCodeAt(i) == ch)
+      return definedClosing.charAt(i + 1);
+  return fromCodePoint(ch < 128 ? ch : ch + 1);
+}
+function config(state, pos) {
+  return state.languageDataAt("closeBrackets", pos)[0] || defaults;
+}
+const android = typeof navigator == "object" && /* @__PURE__ */ /Android\b/.test(navigator.userAgent);
+const inputHandler = /* @__PURE__ */ EditorView.inputHandler.of((view, from, to, insert) => {
+  if ((android ? view.composing : view.compositionStarted) || view.state.readOnly)
+    return false;
+  let sel = view.state.selection.main;
+  if (insert.length > 2 || insert.length == 2 && codePointSize(codePointAt(insert, 0)) == 1 || from != sel.from || to != sel.to)
+    return false;
+  let tr = insertBracket(view.state, insert);
+  if (!tr)
+    return false;
+  view.dispatch(tr);
+  return true;
+});
+const deleteBracketPair = ({ state, dispatch }) => {
+  if (state.readOnly)
+    return false;
+  let conf = config(state, state.selection.main.head);
+  let tokens = conf.brackets || defaults.brackets;
+  let dont = null, changes = state.changeByRange((range) => {
+    if (range.empty) {
+      let before = prevChar(state.doc, range.head);
+      for (let token of tokens) {
+        if (token == before && nextChar(state.doc, range.head) == closing(codePointAt(token, 0)))
+          return {
+            changes: { from: range.head - token.length, to: range.head + token.length },
+            range: EditorSelection.cursor(range.head - token.length)
+          };
+      }
+    }
+    return { range: dont = range };
+  });
+  if (!dont)
+    dispatch(state.update(changes, { scrollIntoView: true, userEvent: "delete.backward" }));
+  return !dont;
+};
+const closeBracketsKeymap = [
+  { key: "Backspace", run: deleteBracketPair }
+];
+function insertBracket(state, bracket) {
+  let conf = config(state, state.selection.main.head);
+  let tokens = conf.brackets || defaults.brackets;
+  for (let tok of tokens) {
+    let closed = closing(codePointAt(tok, 0));
+    if (bracket == tok)
+      return closed == tok ? handleSame(state, tok, tokens.indexOf(tok + tok + tok) > -1, conf) : handleOpen(state, tok, closed, conf.before || defaults.before);
+    if (bracket == closed && closedBracketAt(state, state.selection.main.from))
+      return handleClose(state, tok, closed);
+  }
+  return null;
+}
+function closedBracketAt(state, pos) {
+  let found = false;
+  state.field(bracketState).between(0, state.doc.length, (from) => {
+    if (from == pos)
+      found = true;
+  });
+  return found;
+}
+function nextChar(doc, pos) {
+  let next = doc.sliceString(pos, pos + 2);
+  return next.slice(0, codePointSize(codePointAt(next, 0)));
+}
+function prevChar(doc, pos) {
+  let prev = doc.sliceString(pos - 2, pos);
+  return codePointSize(codePointAt(prev, 0)) == prev.length ? prev : prev.slice(1);
+}
+function handleOpen(state, open, close, closeBefore) {
+  let dont = null, changes = state.changeByRange((range) => {
+    if (!range.empty)
+      return {
+        changes: [{ insert: open, from: range.from }, { insert: close, from: range.to }],
+        effects: closeBracketEffect.of(range.to + open.length),
+        range: EditorSelection.range(range.anchor + open.length, range.head + open.length)
+      };
+    let next = nextChar(state.doc, range.head);
+    if (!next || /\s/.test(next) || closeBefore.indexOf(next) > -1)
+      return {
+        changes: { insert: open + close, from: range.head },
+        effects: closeBracketEffect.of(range.head + open.length),
+        range: EditorSelection.cursor(range.head + open.length)
+      };
+    return { range: dont = range };
+  });
+  return dont ? null : state.update(changes, {
+    scrollIntoView: true,
+    userEvent: "input.type"
+  });
+}
+function handleClose(state, _open, close) {
+  let dont = null, changes = state.changeByRange((range) => {
+    if (range.empty && nextChar(state.doc, range.head) == close)
+      return {
+        changes: { from: range.head, to: range.head + close.length, insert: close },
+        range: EditorSelection.cursor(range.head + close.length)
+      };
+    return dont = { range };
+  });
+  return dont ? null : state.update(changes, {
+    scrollIntoView: true,
+    userEvent: "input.type"
+  });
+}
+function handleSame(state, token, allowTriple, config2) {
+  let stringPrefixes = config2.stringPrefixes || defaults.stringPrefixes;
+  let dont = null, changes = state.changeByRange((range) => {
+    if (!range.empty)
+      return {
+        changes: [{ insert: token, from: range.from }, { insert: token, from: range.to }],
+        effects: closeBracketEffect.of(range.to + token.length),
+        range: EditorSelection.range(range.anchor + token.length, range.head + token.length)
+      };
+    let pos = range.head, next = nextChar(state.doc, pos), start;
+    if (next == token) {
+      if (nodeStart(state, pos)) {
+        return {
+          changes: { insert: token + token, from: pos },
+          effects: closeBracketEffect.of(pos + token.length),
+          range: EditorSelection.cursor(pos + token.length)
+        };
+      } else if (closedBracketAt(state, pos)) {
+        let isTriple = allowTriple && state.sliceDoc(pos, pos + token.length * 3) == token + token + token;
+        let content = isTriple ? token + token + token : token;
+        return {
+          changes: { from: pos, to: pos + content.length, insert: content },
+          range: EditorSelection.cursor(pos + content.length)
+        };
+      }
+    } else if (allowTriple && state.sliceDoc(pos - 2 * token.length, pos) == token + token && (start = canStartStringAt(state, pos - 2 * token.length, stringPrefixes)) > -1 && nodeStart(state, start)) {
+      return {
+        changes: { insert: token + token + token + token, from: pos },
+        effects: closeBracketEffect.of(pos + token.length),
+        range: EditorSelection.cursor(pos + token.length)
+      };
+    } else if (state.charCategorizer(pos)(next) != CharCategory.Word) {
+      if (canStartStringAt(state, pos, stringPrefixes) > -1 && !probablyInString(state, pos, token, stringPrefixes))
+        return {
+          changes: { insert: token + token, from: pos },
+          effects: closeBracketEffect.of(pos + token.length),
+          range: EditorSelection.cursor(pos + token.length)
+        };
+    }
+    return { range: dont = range };
+  });
+  return dont ? null : state.update(changes, {
+    scrollIntoView: true,
+    userEvent: "input.type"
+  });
+}
+function nodeStart(state, pos) {
+  let tree = syntaxTree(state).resolveInner(pos + 1);
+  return tree.parent && tree.from == pos;
+}
+function probablyInString(state, pos, quoteToken, prefixes) {
+  let node = syntaxTree(state).resolveInner(pos, -1);
+  let maxPrefix = prefixes.reduce((m, p) => Math.max(m, p.length), 0);
+  for (let i = 0; i < 5; i++) {
+    let start = state.sliceDoc(node.from, Math.min(node.to, node.from + quoteToken.length + maxPrefix));
+    let quotePos = start.indexOf(quoteToken);
+    if (!quotePos || quotePos > -1 && prefixes.indexOf(start.slice(0, quotePos)) > -1) {
+      let first = node.firstChild;
+      while (first && first.from == node.from && first.to - first.from > quoteToken.length + quotePos) {
+        if (state.sliceDoc(first.to - quoteToken.length, first.to) == quoteToken)
+          return false;
+        first = first.firstChild;
+      }
+      return true;
+    }
+    let parent = node.to == pos && node.parent;
+    if (!parent)
+      break;
+    node = parent;
+  }
+  return false;
+}
+function canStartStringAt(state, pos, prefixes) {
+  let charCat = state.charCategorizer(pos);
+  if (charCat(state.sliceDoc(pos - 1, pos)) != CharCategory.Word)
+    return pos;
+  for (let prefix of prefixes) {
+    let start = pos - prefix.length;
+    if (state.sliceDoc(start, pos) == prefix && charCat(state.sliceDoc(start - 1, start)) != CharCategory.Word)
+      return start;
+  }
+  return -1;
+}
+function autocompletion(config2 = {}) {
+  return [
+    commitCharacters,
+    completionState,
+    completionConfig.of(config2),
+    completionPlugin,
+    completionKeymapExt,
+    baseTheme$2
+  ];
+}
+const completionKeymap = [
+  { key: "Ctrl-Space", run: startCompletion },
+  { mac: "Alt-`", run: startCompletion },
+  { key: "Escape", run: closeCompletion },
+  { key: "ArrowDown", run: /* @__PURE__ */ moveCompletionSelection(true) },
+  { key: "ArrowUp", run: /* @__PURE__ */ moveCompletionSelection(false) },
+  { key: "PageDown", run: /* @__PURE__ */ moveCompletionSelection(true, "page") },
+  { key: "PageUp", run: /* @__PURE__ */ moveCompletionSelection(false, "page") },
+  { key: "Enter", run: acceptCompletion }
+];
+const completionKeymapExt = /* @__PURE__ */ Prec.highest(/* @__PURE__ */ keymap.computeN([completionConfig], (state) => state.facet(completionConfig).defaultKeymap ? [completionKeymap] : []));
+class SelectedDiagnostic {
+  constructor(from, to, diagnostic) {
+    this.from = from;
+    this.to = to;
+    this.diagnostic = diagnostic;
+  }
+}
+class LintState {
+  constructor(diagnostics, panel, selected) {
+    this.diagnostics = diagnostics;
+    this.panel = panel;
+    this.selected = selected;
+  }
+  static init(diagnostics, panel, state) {
+    let diagnosticFilter = state.facet(lintConfig).markerFilter;
+    if (diagnosticFilter)
+      diagnostics = diagnosticFilter(diagnostics, state);
+    let sorted = diagnostics.slice().sort((a, b) => a.from - b.from || a.to - b.to);
+    let deco = new RangeSetBuilder(), active = [], pos = 0;
+    for (let i = 0; ; ) {
+      let next = i == sorted.length ? null : sorted[i];
+      if (!next && !active.length)
+        break;
+      let from, to;
+      if (active.length) {
+        from = pos;
+        to = active.reduce((p, d) => Math.min(p, d.to), next && next.from > from ? next.from : 1e8);
+      } else {
+        from = next.from;
+        to = next.to;
+        active.push(next);
+        i++;
+      }
+      while (i < sorted.length) {
+        let next2 = sorted[i];
+        if (next2.from == from && (next2.to > next2.from || next2.to == from)) {
+          active.push(next2);
+          i++;
+          to = Math.min(next2.to, to);
+        } else {
+          to = Math.min(next2.from, to);
+          break;
+        }
+      }
+      let sev = maxSeverity(active);
+      if (active.some((d) => d.from == d.to || d.from == d.to - 1 && state.doc.lineAt(d.from).to == d.from)) {
+        deco.add(from, from, Decoration.widget({
+          widget: new DiagnosticWidget(sev),
+          diagnostics: active.slice()
+        }));
+      } else {
+        let markClass = active.reduce((c, d) => d.markClass ? c + " " + d.markClass : c, "");
+        deco.add(from, to, Decoration.mark({
+          class: "cm-lintRange cm-lintRange-" + sev + markClass,
+          diagnostics: active.slice(),
+          inclusiveEnd: active.some((a) => a.to > to)
+        }));
+      }
+      pos = to;
+      for (let i2 = 0; i2 < active.length; i2++)
+        if (active[i2].to <= pos)
+          active.splice(i2--, 1);
+    }
+    let set = deco.finish();
+    return new LintState(set, panel, findDiagnostic(set));
+  }
+}
+function findDiagnostic(diagnostics, diagnostic = null, after = 0) {
+  let found = null;
+  diagnostics.between(after, 1e9, (from, to, { spec }) => {
+    if (diagnostic && spec.diagnostics.indexOf(diagnostic) < 0)
+      return;
+    if (!found)
+      found = new SelectedDiagnostic(from, to, diagnostic || spec.diagnostics[0]);
+    else if (spec.diagnostics.indexOf(found.diagnostic) < 0)
+      return false;
+    else
+      found = new SelectedDiagnostic(found.from, to, found.diagnostic);
+  });
+  return found;
+}
+function hideTooltip(tr, tooltip) {
+  let from = tooltip.pos, to = tooltip.end || from;
+  let result = tr.state.facet(lintConfig).hideOn(tr, from, to);
+  if (result != null)
+    return result;
+  let line = tr.startState.doc.lineAt(tooltip.pos);
+  return !!(tr.effects.some((e) => e.is(setDiagnosticsEffect)) || tr.changes.touchesRange(line.from, Math.max(line.to, to)));
+}
+function maybeEnableLint(state, effects) {
+  return state.field(lintState, false) ? effects : effects.concat(StateEffect.appendConfig.of(lintExtensions));
+}
+const setDiagnosticsEffect = /* @__PURE__ */ StateEffect.define();
+const togglePanel = /* @__PURE__ */ StateEffect.define();
+const movePanelSelection = /* @__PURE__ */ StateEffect.define();
+const lintState = /* @__PURE__ */ StateField.define({
+  create() {
+    return new LintState(Decoration.none, null, null);
+  },
+  update(value, tr) {
+    if (tr.docChanged && value.diagnostics.size) {
+      let mapped = value.diagnostics.map(tr.changes), selected = null, panel = value.panel;
+      if (value.selected) {
+        let selPos = tr.changes.mapPos(value.selected.from, 1);
+        selected = findDiagnostic(mapped, value.selected.diagnostic, selPos) || findDiagnostic(mapped, null, selPos);
+      }
+      if (!mapped.size && panel && tr.state.facet(lintConfig).autoPanel)
+        panel = null;
+      value = new LintState(mapped, panel, selected);
+    }
+    for (let effect of tr.effects) {
+      if (effect.is(setDiagnosticsEffect)) {
+        let panel = !tr.state.facet(lintConfig).autoPanel ? value.panel : effect.value.length ? LintPanel.open : null;
+        value = LintState.init(effect.value, panel, tr.state);
+      } else if (effect.is(togglePanel)) {
+        value = new LintState(value.diagnostics, effect.value ? LintPanel.open : null, value.selected);
+      } else if (effect.is(movePanelSelection)) {
+        value = new LintState(value.diagnostics, value.panel, effect.value);
+      }
+    }
+    return value;
+  },
+  provide: (f) => [
+    showPanel.from(f, (val) => val.panel),
+    EditorView.decorations.from(f, (s) => s.diagnostics)
+  ]
+});
+const activeMark = /* @__PURE__ */ Decoration.mark({ class: "cm-lintRange cm-lintRange-active" });
+function lintTooltip(view, pos, side) {
+  let { diagnostics } = view.state.field(lintState);
+  let found, start = -1, end = -1;
+  diagnostics.between(pos - (side < 0 ? 1 : 0), pos + (side > 0 ? 1 : 0), (from, to, { spec }) => {
+    if (pos >= from && pos <= to && (from == to || (pos > from || side > 0) && (pos < to || side < 0))) {
+      found = spec.diagnostics;
+      start = from;
+      end = to;
+      return false;
+    }
+  });
+  let diagnosticFilter = view.state.facet(lintConfig).tooltipFilter;
+  if (found && diagnosticFilter)
+    found = diagnosticFilter(found, view.state);
+  if (!found)
+    return null;
+  return {
+    pos: start,
+    end,
+    above: view.state.doc.lineAt(start).to < end,
+    create() {
+      return { dom: diagnosticsTooltip(view, found) };
+    }
+  };
+}
+function diagnosticsTooltip(view, diagnostics) {
+  return crelt("ul", { class: "cm-tooltip-lint" }, diagnostics.map((d) => renderDiagnostic(view, d, false)));
+}
+const openLintPanel = (view) => {
+  let field = view.state.field(lintState, false);
+  if (!field || !field.panel)
+    view.dispatch({ effects: maybeEnableLint(view.state, [togglePanel.of(true)]) });
+  let panel = getPanel(view, LintPanel.open);
+  if (panel)
+    panel.dom.querySelector(".cm-panel-lint ul").focus();
+  return true;
+};
+const closeLintPanel = (view) => {
+  let field = view.state.field(lintState, false);
+  if (!field || !field.panel)
+    return false;
+  view.dispatch({ effects: togglePanel.of(false) });
+  return true;
+};
+const nextDiagnostic = (view) => {
+  let field = view.state.field(lintState, false);
+  if (!field)
+    return false;
+  let sel = view.state.selection.main, next = field.diagnostics.iter(sel.to + 1);
+  if (!next.value) {
+    next = field.diagnostics.iter(0);
+    if (!next.value || next.from == sel.from && next.to == sel.to)
+      return false;
+  }
+  view.dispatch({ selection: { anchor: next.from, head: next.to }, scrollIntoView: true });
+  return true;
+};
+const lintKeymap = [
+  { key: "Mod-Shift-m", run: openLintPanel, preventDefault: true },
+  { key: "F8", run: nextDiagnostic }
+];
+const lintConfig = /* @__PURE__ */ Facet.define({
+  combine(input) {
+    return Object.assign({ sources: input.map((i) => i.source).filter((x) => x != null) }, combineConfig(input.map((i) => i.config), {
+      delay: 750,
+      markerFilter: null,
+      tooltipFilter: null,
+      needsRefresh: null,
+      hideOn: () => null
+    }, {
+      needsRefresh: (a, b) => !a ? b : !b ? a : (u) => a(u) || b(u)
+    }));
+  }
+});
+function assignKeys(actions) {
+  let assigned = [];
+  if (actions)
+    actions: for (let { name } of actions) {
+      for (let i = 0; i < name.length; i++) {
+        let ch = name[i];
+        if (/[a-zA-Z]/.test(ch) && !assigned.some((c) => c.toLowerCase() == ch.toLowerCase())) {
+          assigned.push(ch);
+          continue actions;
+        }
+      }
+      assigned.push("");
+    }
+  return assigned;
+}
+function renderDiagnostic(view, diagnostic, inPanel) {
+  var _a;
+  let keys = inPanel ? assignKeys(diagnostic.actions) : [];
+  return crelt("li", { class: "cm-diagnostic cm-diagnostic-" + diagnostic.severity }, crelt("span", { class: "cm-diagnosticText" }, diagnostic.renderMessage ? diagnostic.renderMessage(view) : diagnostic.message), (_a = diagnostic.actions) === null || _a === void 0 ? void 0 : _a.map((action, i) => {
+    let fired = false, click = (e) => {
+      e.preventDefault();
+      if (fired)
+        return;
+      fired = true;
+      let found = findDiagnostic(view.state.field(lintState).diagnostics, diagnostic);
+      if (found)
+        action.apply(view, found.from, found.to);
+    };
+    let { name } = action, keyIndex = keys[i] ? name.indexOf(keys[i]) : -1;
+    let nameElt = keyIndex < 0 ? name : [
+      name.slice(0, keyIndex),
+      crelt("u", name.slice(keyIndex, keyIndex + 1)),
+      name.slice(keyIndex + 1)
+    ];
+    return crelt("button", {
+      type: "button",
+      class: "cm-diagnosticAction",
+      onclick: click,
+      onmousedown: click,
+      "aria-label": ` Action: ${name}${keyIndex < 0 ? "" : ` (access key "${keys[i]})"`}.`
+    }, nameElt);
+  }), diagnostic.source && crelt("div", { class: "cm-diagnosticSource" }, diagnostic.source));
+}
+class DiagnosticWidget extends WidgetType {
+  constructor(sev) {
+    super();
+    this.sev = sev;
+  }
+  eq(other) {
+    return other.sev == this.sev;
+  }
+  toDOM() {
+    return crelt("span", { class: "cm-lintPoint cm-lintPoint-" + this.sev });
+  }
+}
+class PanelItem {
+  constructor(view, diagnostic) {
+    this.diagnostic = diagnostic;
+    this.id = "item_" + Math.floor(Math.random() * 4294967295).toString(16);
+    this.dom = renderDiagnostic(view, diagnostic, true);
+    this.dom.id = this.id;
+    this.dom.setAttribute("role", "option");
+  }
+}
+class LintPanel {
+  constructor(view) {
+    this.view = view;
+    this.items = [];
+    let onkeydown = (event) => {
+      if (event.keyCode == 27) {
+        closeLintPanel(this.view);
+        this.view.focus();
+      } else if (event.keyCode == 38 || event.keyCode == 33) {
+        this.moveSelection((this.selectedIndex - 1 + this.items.length) % this.items.length);
+      } else if (event.keyCode == 40 || event.keyCode == 34) {
+        this.moveSelection((this.selectedIndex + 1) % this.items.length);
+      } else if (event.keyCode == 36) {
+        this.moveSelection(0);
+      } else if (event.keyCode == 35) {
+        this.moveSelection(this.items.length - 1);
+      } else if (event.keyCode == 13) {
+        this.view.focus();
+      } else if (event.keyCode >= 65 && event.keyCode <= 90 && this.selectedIndex >= 0) {
+        let { diagnostic } = this.items[this.selectedIndex], keys = assignKeys(diagnostic.actions);
+        for (let i = 0; i < keys.length; i++)
+          if (keys[i].toUpperCase().charCodeAt(0) == event.keyCode) {
+            let found = findDiagnostic(this.view.state.field(lintState).diagnostics, diagnostic);
+            if (found)
+              diagnostic.actions[i].apply(view, found.from, found.to);
+          }
+      } else {
+        return;
+      }
+      event.preventDefault();
+    };
+    let onclick = (event) => {
+      for (let i = 0; i < this.items.length; i++) {
+        if (this.items[i].dom.contains(event.target))
+          this.moveSelection(i);
+      }
+    };
+    this.list = crelt("ul", {
+      tabIndex: 0,
+      role: "listbox",
+      "aria-label": this.view.state.phrase("Diagnostics"),
+      onkeydown,
+      onclick
+    });
+    this.dom = crelt("div", { class: "cm-panel-lint" }, this.list, crelt("button", {
+      type: "button",
+      name: "close",
+      "aria-label": this.view.state.phrase("close"),
+      onclick: () => closeLintPanel(this.view)
+    }, "×"));
+    this.update();
+  }
+  get selectedIndex() {
+    let selected = this.view.state.field(lintState).selected;
+    if (!selected)
+      return -1;
+    for (let i = 0; i < this.items.length; i++)
+      if (this.items[i].diagnostic == selected.diagnostic)
+        return i;
+    return -1;
+  }
+  update() {
+    let { diagnostics, selected } = this.view.state.field(lintState);
+    let i = 0, needsSync = false, newSelectedItem = null;
+    let seen = /* @__PURE__ */ new Set();
+    diagnostics.between(0, this.view.state.doc.length, (_start, _end, { spec }) => {
+      for (let diagnostic of spec.diagnostics) {
+        if (seen.has(diagnostic))
+          continue;
+        seen.add(diagnostic);
+        let found = -1, item;
+        for (let j = i; j < this.items.length; j++)
+          if (this.items[j].diagnostic == diagnostic) {
+            found = j;
+            break;
+          }
+        if (found < 0) {
+          item = new PanelItem(this.view, diagnostic);
+          this.items.splice(i, 0, item);
+          needsSync = true;
+        } else {
+          item = this.items[found];
+          if (found > i) {
+            this.items.splice(i, found - i);
+            needsSync = true;
+          }
+        }
+        if (selected && item.diagnostic == selected.diagnostic) {
+          if (!item.dom.hasAttribute("aria-selected")) {
+            item.dom.setAttribute("aria-selected", "true");
+            newSelectedItem = item;
+          }
+        } else if (item.dom.hasAttribute("aria-selected")) {
+          item.dom.removeAttribute("aria-selected");
+        }
+        i++;
+      }
+    });
+    while (i < this.items.length && !(this.items.length == 1 && this.items[0].diagnostic.from < 0)) {
+      needsSync = true;
+      this.items.pop();
+    }
+    if (this.items.length == 0) {
+      this.items.push(new PanelItem(this.view, {
+        from: -1,
+        to: -1,
+        severity: "info",
+        message: this.view.state.phrase("No diagnostics")
+      }));
+      needsSync = true;
+    }
+    if (newSelectedItem) {
+      this.list.setAttribute("aria-activedescendant", newSelectedItem.id);
+      this.view.requestMeasure({
+        key: this,
+        read: () => ({ sel: newSelectedItem.dom.getBoundingClientRect(), panel: this.list.getBoundingClientRect() }),
+        write: ({ sel, panel }) => {
+          let scaleY = panel.height / this.list.offsetHeight;
+          if (sel.top < panel.top)
+            this.list.scrollTop -= (panel.top - sel.top) / scaleY;
+          else if (sel.bottom > panel.bottom)
+            this.list.scrollTop += (sel.bottom - panel.bottom) / scaleY;
+        }
+      });
+    } else if (this.selectedIndex < 0) {
+      this.list.removeAttribute("aria-activedescendant");
+    }
+    if (needsSync)
+      this.sync();
+  }
+  sync() {
+    let domPos = this.list.firstChild;
+    function rm() {
+      let prev = domPos;
+      domPos = prev.nextSibling;
+      prev.remove();
+    }
+    for (let item of this.items) {
+      if (item.dom.parentNode == this.list) {
+        while (domPos != item.dom)
+          rm();
+        domPos = item.dom.nextSibling;
+      } else {
+        this.list.insertBefore(item.dom, domPos);
+      }
+    }
+    while (domPos)
+      rm();
+  }
+  moveSelection(selectedIndex) {
+    if (this.selectedIndex < 0)
+      return;
+    let field = this.view.state.field(lintState);
+    let selection = findDiagnostic(field.diagnostics, this.items[selectedIndex].diagnostic);
+    if (!selection)
+      return;
+    this.view.dispatch({
+      selection: { anchor: selection.from, head: selection.to },
+      scrollIntoView: true,
+      effects: movePanelSelection.of(selection)
+    });
+  }
+  static open(view) {
+    return new LintPanel(view);
+  }
+}
+function svg(content, attrs = `viewBox="0 0 40 40"`) {
+  return `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" ${attrs}>${encodeURIComponent(content)}</svg>')`;
+}
+function underline(color) {
+  return svg(`<path d="m0 2.5 l2 -1.5 l1 0 l2 1.5 l1 0" stroke="${color}" fill="none" stroke-width=".7"/>`, `width="6" height="3"`);
+}
+const baseTheme$1 = /* @__PURE__ */ EditorView.baseTheme({
+  ".cm-diagnostic": {
+    padding: "3px 6px 3px 8px",
+    marginLeft: "-1px",
+    display: "block",
+    whiteSpace: "pre-wrap"
+  },
+  ".cm-diagnostic-error": { borderLeft: "5px solid #d11" },
+  ".cm-diagnostic-warning": { borderLeft: "5px solid orange" },
+  ".cm-diagnostic-info": { borderLeft: "5px solid #999" },
+  ".cm-diagnostic-hint": { borderLeft: "5px solid #66d" },
+  ".cm-diagnosticAction": {
+    font: "inherit",
+    border: "none",
+    padding: "2px 4px",
+    backgroundColor: "#444",
+    color: "white",
+    borderRadius: "3px",
+    marginLeft: "8px",
+    cursor: "pointer"
+  },
+  ".cm-diagnosticSource": {
+    fontSize: "70%",
+    opacity: 0.7
+  },
+  ".cm-lintRange": {
+    backgroundPosition: "left bottom",
+    backgroundRepeat: "repeat-x",
+    paddingBottom: "0.7px"
+  },
+  ".cm-lintRange-error": { backgroundImage: /* @__PURE__ */ underline("#d11") },
+  ".cm-lintRange-warning": { backgroundImage: /* @__PURE__ */ underline("orange") },
+  ".cm-lintRange-info": { backgroundImage: /* @__PURE__ */ underline("#999") },
+  ".cm-lintRange-hint": { backgroundImage: /* @__PURE__ */ underline("#66d") },
+  ".cm-lintRange-active": { backgroundColor: "#ffdd9980" },
+  ".cm-tooltip-lint": {
+    padding: 0,
+    margin: 0
+  },
+  ".cm-lintPoint": {
+    position: "relative",
+    "&:after": {
+      content: '""',
+      position: "absolute",
+      bottom: 0,
+      left: "-2px",
+      borderLeft: "3px solid transparent",
+      borderRight: "3px solid transparent",
+      borderBottom: "4px solid #d11"
+    }
+  },
+  ".cm-lintPoint-warning": {
+    "&:after": { borderBottomColor: "orange" }
+  },
+  ".cm-lintPoint-info": {
+    "&:after": { borderBottomColor: "#999" }
+  },
+  ".cm-lintPoint-hint": {
+    "&:after": { borderBottomColor: "#66d" }
+  },
+  ".cm-panel.cm-panel-lint": {
+    position: "relative",
+    "& ul": {
+      maxHeight: "100px",
+      overflowY: "auto",
+      "& [aria-selected]": {
+        backgroundColor: "#ddd",
+        "& u": { textDecoration: "underline" }
+      },
+      "&:focus [aria-selected]": {
+        background_fallback: "#bdf",
+        backgroundColor: "Highlight",
+        color_fallback: "white",
+        color: "HighlightText"
+      },
+      "& u": { textDecoration: "none" },
+      padding: 0,
+      margin: 0
+    },
+    "& [name=close]": {
+      position: "absolute",
+      top: "0",
+      right: "2px",
+      background: "inherit",
+      border: "none",
+      font: "inherit",
+      padding: 0,
+      margin: 0
+    }
+  }
+});
+function severityWeight(sev) {
+  return sev == "error" ? 4 : sev == "warning" ? 3 : sev == "info" ? 2 : 1;
+}
+function maxSeverity(diagnostics) {
+  let sev = "hint", weight = 1;
+  for (let d of diagnostics) {
+    let w = severityWeight(d.severity);
+    if (w > weight) {
+      weight = w;
+      sev = d.severity;
+    }
+  }
+  return sev;
+}
+const lintExtensions = [
+  lintState,
+  /* @__PURE__ */ EditorView.decorations.compute([lintState], (state) => {
+    let { selected, panel } = state.field(lintState);
+    return !selected || !panel || selected.from == selected.to ? Decoration.none : Decoration.set([
+      activeMark.range(selected.from, selected.to)
+    ]);
+  }),
+  /* @__PURE__ */ hoverTooltip(lintTooltip, { hideOn: hideTooltip }),
+  baseTheme$1
+];
+function stateWORDAt(state, pos) {
+  const { text, from, length } = state.doc.lineAt(pos);
+  const cat = state.charCategorizer(pos);
+  let start = pos - from, end = pos - from;
+  while (start > 0) {
+    const prev = findClusterBreak(text, start, false);
+    if (cat(text.slice(prev, start)) === CharCategory.Space) break;
+    start = prev;
+  }
+  while (end < length) {
+    const next = findClusterBreak(text, end);
+    if (cat(text.slice(end, next)) === CharCategory.Space) break;
+    end = next;
+  }
+  return start == end ? null : EditorSelection.range(start + from, end + from);
+}
+function rangeTouchesRange(a, b) {
+  return a.from <= b.to && b.from <= a.to;
+}
+function selectionTouchesRange(selection, b) {
+  return selection.some((range) => rangeTouchesRange(range, b));
+}
+function iterChildren(cursor, enter) {
+  if (!cursor.firstChild()) return;
+  do {
+    if (enter(cursor)) break;
+  } while (cursor.nextSibling());
+  console.assert(cursor.parent());
+}
+function eventHandlersWithClass(handlers) {
+  return Object.fromEntries(
+    Object.entries(handlers).filter(([_event, handlers2]) => !!handlers2).map(([event, handlers2]) => [
+      event,
+      function(ev, view) {
+        var _a;
+        const res = [];
+        for (const className in handlers2) {
+          if (ev.composedPath().some((el) => {
+            if (!(el instanceof Element)) return false;
+            return el.classList.contains(className);
+          })) {
+            res.push((_a = handlers2[className]) == null ? void 0 : _a.call(this, ev, view));
+          }
+        }
+        return res.some((res2) => !!res2);
+      }
+    ])
+  );
+}
+const hideTheme = EditorView.theme({
+  ".cm-hidden-token": {
+    fontSize: "0px"
+  }
+});
+const hideInlineDecoration = Decoration.mark({
+  class: "cm-hidden-token"
+});
+const hideBlockDecoration = Decoration.replace({
+  block: true
+});
+const buildDecorations$1 = (state) => {
+  const decorations = [];
+  const specs = state.facet(hidableNodeFacet);
+  syntaxTree(state).iterate({
+    enter: (node) => {
+      if (state.selection.ranges.some((range) => rangeTouchesRange(node, range))) {
+        return;
+      }
+      for (const spec of specs) {
+        if (spec.nodeName instanceof Function) {
+          if (!spec.nodeName(node.type.name)) {
+            continue;
+          }
+        } else if (spec.nodeName instanceof Array) {
+          if (!spec.nodeName.includes(node.type.name)) {
+            continue;
+          }
+        } else if (node.type.name !== spec.nodeName) {
+          continue;
+        }
+        if (spec.unhideZone) {
+          const res = spec.unhideZone(state, node);
+          if (state.selection.ranges.some(
+            (range) => rangeTouchesRange(res, range)
+          )) {
+            return;
+          }
+        }
+        if (spec.onHide) {
+          const res = spec.onHide(state, node);
+          if (res instanceof Array) {
+            decorations.push(...res);
+          } else if (res) {
+            decorations.push(res);
+          }
+        }
+        if (spec.subNodeNameToHide) {
+          let names;
+          if (!Array.isArray(spec.subNodeNameToHide)) {
+            names = [spec.subNodeNameToHide];
+          } else {
+            names = spec.subNodeNameToHide;
+          }
+          const cursor = node.node.cursor();
+          console.assert(cursor.firstChild(), "A hide node must have children");
+          cursor.iterate((node2) => {
+            if (names.includes(node2.type.name)) {
+              decorations.push(
+                (spec.block ? hideBlockDecoration : hideInlineDecoration).range(
+                  node2.from,
+                  node2.to
+                )
+              );
+            }
+          });
+        }
+      }
+    }
+  });
+  return Decoration.set(decorations, true);
+};
+const hideExtension = StateField.define({
+  create(state) {
+    return buildDecorations$1(state);
+  },
+  update(deco, tr) {
+    if (tr.docChanged || tr.selection) {
+      return buildDecorations$1(tr.state);
+    }
+    return deco.map(tr.changes);
+  },
+  provide: (f) => [EditorView.decorations.from(f), hideTheme]
+});
+const hidableNodeFacet = Facet.define({
+  combine(value) {
+    return [...value];
+  },
+  enables: hideExtension
+});
+const markdownTags = {
+  headerMark: Tag.define(),
+  inlineCode: Tag.define(),
+  fencedCode: Tag.define(),
+  linkURL: Tag.define(),
+  escapeMark: Tag.define(),
+  emoji: Tag.define(),
+  emojiMark: Tag.define(),
+  listMark: Tag.define()
+};
+const renderedLinkDecoration = Decoration.mark({
+  class: "cm-rendered-link"
+});
+const defaultHidableSpecs = [
+  {
+    nodeName: (name) => name.startsWith("ATXHeading"),
+    onHide: (_view, node) => {
+      const headerMark = node.node.firstChild;
+      return hideInlineDecoration.range(
+        headerMark.from,
+        Math.min(headerMark.to + 1, node.to)
+      );
+    }
+  },
+  {
+    nodeName: (name) => name.startsWith("SetextHeading"),
+    subNodeNameToHide: "HeaderMark",
+    block: true
+  },
+  {
+    nodeName: ["StrongEmphasis", "Emphasis"],
+    subNodeNameToHide: "EmphasisMark"
+  },
+  {
+    nodeName: "InlineCode",
+    subNodeNameToHide: "CodeMark"
+  },
+  {
+    nodeName: "Link",
+    subNodeNameToHide: ["LinkMark", "URL"],
+    onHide: (_state, node) => {
+      return renderedLinkDecoration.range(node.from, node.to);
+    }
+  },
+  {
+    nodeName: "Strikethrough",
+    subNodeNameToHide: "StrikethroughMark"
+  },
+  {
+    nodeName: "Escape",
+    subNodeNameToHide: "EscapeMark",
+    unhideZone: (state, node) => {
+      const WORDAt = stateWORDAt(state, node.from);
+      if (WORDAt && WORDAt.to > node.from + 1) return WORDAt;
+      return state.doc.lineAt(node.from);
+    }
+  },
+  {
+    nodeName: "FencedCode",
+    subNodeNameToHide: ["CodeMark", "CodeInfo"]
+  },
+  {
+    nodeName: "Blockquote",
+    subNodeNameToHide: "QuoteMark"
+  }
+];
+const defaultHideExtensions = defaultHidableSpecs.map(
+  (spec) => hidableNodeFacet.of(spec)
+);
+const escapeMarkdownSyntaxExtension = {
+  defineNodes: [
+    {
+      name: "EscapeMark",
+      style: markdownTags.escapeMark
+    }
+  ],
+  parseInline: [
+    {
+      name: "EscapeMark",
+      parse: (cx, next, pos) => {
+        if (next !== 92) return -1;
+        return cx.addElement(
+          cx.elt("Escape", pos, pos + 2, [cx.elt("EscapeMark", pos, pos + 1)])
+        );
+      },
+      before: "Escape"
+    }
+  ]
+};
+const buildDecorations = (state) => {
+  const decorations = [];
+  const specs = state.facet(foldableSyntaxFacet);
+  syntaxTree(state).iterate({
+    enter: (node) => {
+      if (selectionTouchesRange(state.selection.ranges, node)) return;
+      for (const spec of specs) {
+        const lineage = [];
+        let node_ = node;
+        while (node_) {
+          lineage.push(node_.name);
+          node_ = node_.node.parent;
+        }
+        const path = lineage.reverse().join("/");
+        if (spec.nodePath instanceof Function) {
+          if (!spec.nodePath(path)) {
+            continue;
+          }
+        } else if (spec.nodePath instanceof Array) {
+          if (!spec.nodePath.some((testPath) => path.endsWith(testPath))) {
+            continue;
+          }
+        } else if (!path.endsWith(spec.nodePath)) {
+          continue;
+        }
+        if (spec.unfoldZone) {
+          if (selectionTouchesRange(
+            state.selection.ranges,
+            spec.unfoldZone(state, node)
+          )) {
+            return;
+          }
+        }
+        if (spec.onFold) {
+          const res = spec.onFold(state, node);
+          if (res instanceof Array) {
+            decorations.push(...res);
+          } else if (res) {
+            decorations.push(res);
+          }
+        }
+      }
+    }
+  });
+  return Decoration.set(decorations, true);
+};
+const foldDecorationExtension = StateField.define({
+  create(state) {
+    return buildDecorations(state);
+  },
+  update(deco, tr) {
+    if (tr.docChanged || tr.selection) {
+      return buildDecorations(tr.state);
+    }
+    return deco.map(tr.changes);
+  },
+  provide: (f) => [EditorView.decorations.from(f)]
+});
+const foldExtension = [foldDecorationExtension];
+const foldableSyntaxFacet = Facet.define({
+  combine(value) {
+    return [...value];
+  },
+  enables: foldExtension
+});
+const selectAllDecorationsOnSelectExtension = (widgetClass) => EditorView.domEventHandlers(
+  eventHandlersWithClass({
+    mousedown: {
+      [widgetClass]: (e, view) => {
+        var _a, _b;
+        const ranges = view.state.selection.ranges;
+        if (ranges.length === 0 || ((_a = ranges[0]) == null ? void 0 : _a.anchor) !== ((_b = ranges[0]) == null ? void 0 : _b.head))
+          return;
+        const target = e.target;
+        const pos = view.posAtDOM(target);
+        const decorations = view.state.field(foldDecorationExtension);
+        decorations.between(pos, pos, (from, to) => {
+          setTimeout(() => {
+            view.dispatch({
+              selection: EditorSelection.single(to, from)
+            });
+          }, 0);
+          return false;
+        });
+      }
+    }
+  })
+);
+class BulletPoint extends WidgetType {
+  toDOM() {
+    const span = document.createElement("span");
+    span.className = "cm-rendered-list-mark";
+    span.innerHTML = "•";
+    return span;
+  }
+  ignoreEvent(_event) {
+    return false;
+  }
+}
+const bulletListExtension = foldableSyntaxFacet.of({
+  nodePath: "BulletList/ListItem/ListMark",
+  onFold: (_state, node) => {
+    const cursor = node.node.cursor();
+    if (cursor.nextSibling() && cursor.name === "Task") return;
+    return Decoration.replace({ widget: new BulletPoint() }).range(
+      node.from,
+      node.to
+    );
+  }
+});
+const emojiDelimiter = { resolve: "Emoji", mark: "EmojiMark" };
+const emojiMarkdownSyntaxExtension = {
+  defineNodes: [
+    {
+      name: "Emoji",
+      style: markdownTags.emoji
+    },
+    {
+      name: "EmojiMark",
+      style: markdownTags.emojiMark
+    }
+  ],
+  parseInline: [
+    {
+      name: "Emoji",
+      parse: (cx, next, pos) => {
+        if (next !== 58) return -1;
+        const open = /^\w+:/.test(cx.slice(pos + 1, cx.end));
+        const close = /:\w+$/.test(cx.slice(cx.offset, pos));
+        if (!open && !close) {
+          return -1;
+        }
+        return cx.addDelimiter(emojiDelimiter, pos, pos + 1, open, close);
+      },
+      before: "Emphasis"
+    }
+  ]
+};
+class EmojiWidget extends WidgetType {
+  constructor(emoji2) {
+    super();
+    this.emoji = emoji2;
+  }
+  toDOM() {
+    const span = document.createElement("span");
+    span.className = "cm-emoji";
+    span.innerHTML = this.emoji;
+    return span;
+  }
+}
+const emojiExtension = foldableSyntaxFacet.of({
+  nodePath: "Emoji",
+  onFold: (state, node) => {
+    const emojiName = state.doc.sliceString(node.from + 1, node.to - 1);
+    const emoji_ = emoji.get(emojiName);
+    if (!emoji_) {
+      return;
+    }
+    return Decoration.replace({
+      widget: new EmojiWidget(emoji_)
+    }).range(node.from, node.to);
+  }
+});
+class HorizontalRuleWidget extends WidgetType {
+  toDOM() {
+    const div = document.createElement("div");
+    div.className = "cm-horizontal-rule-container";
+    const hr = document.createElement("hr");
+    div.appendChild(hr);
+    return div;
+  }
+  // allows clicks to pass through to the editor
+  ignoreEvent(_event) {
+    return false;
+  }
+  destroy(dom) {
+    dom.remove();
+  }
+}
+const horizontalRuleTheme = EditorView.theme({
+  ".cm-horizontal-rule-container": {
+    height: "1.4em",
+    display: "flow-root",
+    "align-items": "center",
+    padding: "0 2px 0 6px"
+  }
+});
+const horizonalRuleExtension = [
+  foldableSyntaxFacet.of({
+    nodePath: "HorizontalRule",
+    onFold: (_state, node) => {
+      return Decoration.replace({
+        widget: new HorizontalRuleWidget(),
+        block: true,
+        inclusiveStart: true
+      }).range(node.from, node.to);
+    }
+  }),
+  horizontalRuleTheme,
+  selectAllDecorationsOnSelectExtension("cm-horizontal-rule-container")
+];
+class ImageWidget extends WidgetType {
+  constructor(url) {
+    super();
+    this.url = url;
+  }
+  toDOM() {
+    const span = document.createElement("span");
+    span.className = "cm-image";
+    if (this.url) {
+      span.innerHTML = `<img src="${this.url}" />`;
+    }
+    return span;
+  }
+  // allows clicks to pass through to the editor
+  ignoreEvent(_event) {
+    return false;
+  }
+}
+const imageExtension = [
+  foldableSyntaxFacet.of({
+    nodePath: "Image",
+    onFold: (state, node) => {
+      let imageUrl;
+      iterChildren(node.node.cursor(), (node2) => {
+        if (node2.name === "URL") {
+          imageUrl = state.doc.sliceString(node2.from, node2.to);
+        }
+        return void 0;
+      });
+      if (imageUrl) {
+        return Decoration.replace({
+          widget: new ImageWidget(imageUrl)
+        }).range(node.from, node.to);
+      }
+    }
+  }),
+  selectAllDecorationsOnSelectExtension("cm-image")
+];
+class Checkbox extends WidgetType {
+  constructor(value) {
+    super();
+    __publicField(this, "value");
+    this.value = value;
+  }
+  toDOM() {
+    const el = document.createElement("input");
+    el.type = "checkbox";
+    el.className = "cm-checkbox";
+    el.checked = this.value;
+    return el;
+  }
+  ignoreEvent(_event) {
+    return false;
+  }
+}
+const taskExtension = [
+  foldableSyntaxFacet.of({
+    nodePath: "BulletList/ListItem/Task/TaskMarker",
+    onFold: (state, node) => {
+      const value = state.doc.sliceString(node.from + 1, node.to - 1).toLowerCase() === "x";
+      return Decoration.replace({
+        widget: new Checkbox(value)
+      }).range(node.from - 2, node.to);
+    },
+    unfoldZone: (_state, node) => ({
+      from: node.from - 2,
+      to: node.to
+    })
+  }),
+  EditorView.domEventHandlers(
+    eventHandlersWithClass({
+      mousedown: {
+        "cm-checkbox": (ev, view) => {
+          const pos = view.posAtDOM(ev.target);
+          const change = {
+            from: pos + 3,
+            to: pos + 4,
+            insert: ev.target.checked ? " " : "x"
+            // this value is old, so the text is swap
+          };
+          view.dispatch({
+            changes: change
+          });
+          return true;
+        }
+      }
+    })
+  )
+];
+class BlockQuoteVerticalLine extends WidgetType {
+  toDOM() {
+    const span = document.createElement("span");
+    span.className = "cm-blockquote-vertical-line";
+    return span;
+  }
+  ignoreEvent(_event) {
+    return false;
+  }
+}
+const blockQuoteExtension = foldableSyntaxFacet.of({
+  nodePath: (nodePath) => nodePath.endsWith("Blockquote/QuoteMark") || nodePath.endsWith("Blockquote/Paragraph/QuoteMark"),
+  onFold: (_state, node) => {
+    return Decoration.replace({ widget: new BlockQuoteVerticalLine() }).range(
+      node.from,
+      node.to
+    );
+  }
+});
+const additionalMarkdownSyntaxTags = {
+  // Define new nodes with tags here
+  defineNodes: [],
+  props: [
+    // Override tags here
+    styleTags({
+      HeaderMark: markdownTags.headerMark,
+      FencedCode: markdownTags.fencedCode,
+      InlineCode: markdownTags.inlineCode,
+      URL: markdownTags.linkURL,
+      ListMark: markdownTags.listMark
+    })
+  ]
+};
+const headingTagStyles = (fontSizes) => fontSizes.map((fontSize, i) => ({
+  tag: tags[`heading${(i + 1).toString()}`],
+  fontSize,
+  fontWeight: "bold"
+}));
+const baseSyntaxHighlights = syntaxHighlighting(
+  HighlightStyle.define([
+    ...headingTagStyles(["1.6em", "1.4em", "1.2em", null, null, null]),
+    {
+      tag: markdownTags.headerMark,
+      color: "var(--pm-header-mark-color)"
+    },
+    {
+      tag: tags.strong,
+      fontWeight: "bold"
+    },
+    {
+      tag: tags.emphasis,
+      fontStyle: "italic"
+    },
+    {
+      tag: tags.strikethrough,
+      textDecoration: "line-through"
+    },
+    {
+      tag: tags.meta,
+      color: "var(--pm-muted-color)"
+    },
+    {
+      tag: tags.comment,
+      color: "var(--pm-muted-color)"
+    },
+    {
+      tag: markdownTags.listMark,
+      color: "var(--pm-muted-color)"
+    },
+    {
+      tag: markdownTags.escapeMark,
+      color: "var(--pm-muted-color)"
+    },
+    {
+      tag: markdownTags.inlineCode,
+      fontFamily: "monospace",
+      padding: "0.2rem",
+      borderRadius: "0.4rem",
+      fontSize: "0.8rem",
+      backgroundColor: "var(--pm-code-background-color)"
+    },
+    {
+      tag: markdownTags.linkURL,
+      color: "var(--pm-link-color)",
+      textDecoration: "underline",
+      cursor: "pointer"
+    }
+  ])
+);
+const baseTheme = EditorView.theme({
+  ".cm-content": {
+    fontFamily: "var(--font)",
+    fontSize: "0.9rem",
+    caretColor: "var(--pm-cursor-color)"
+  },
+  ".cm-editor .cm-cursor, .cm-editor .cm-dropCursor": {
+    borderLeftColor: "var(--pm-cursor-color)"
+  },
+  "&.cm-focused": {
+    outline: "none"
+  },
+  ".cm-gutters": {
+    backgroundColor: "transparent",
+    border: "none"
+  },
+  ".cm-rendered-link": {
+    textDecoration: "underline",
+    cursor: "pointer",
+    color: "var(--pm-link-color)"
+  },
+  ".cm-rendered-list-mark": {
+    color: "var(--pm-muted-color)",
+    margin: "0 0.2em"
+  },
+  ".cm-blockquote-vertical-line": {
+    display: "inline-block",
+    width: "4px",
+    marginRight: "4px",
+    marginLeft: "4px",
+    height: "1.4em",
+    verticalAlign: "bottom",
+    backgroundColor: "var(--pm-blockquote-vertical-line-background-color)"
+  }
+});
+const generalSyntaxHighlights = syntaxHighlighting(
+  HighlightStyle.define([
+    {
+      tag: tags.link,
+      color: "var(--pm-syntax-link)"
+    },
+    {
+      tag: tags.keyword,
+      color: "var(--pm-syntax-keyword)"
+    },
+    {
+      tag: [
+        tags.atom,
+        tags.bool,
+        tags.url,
+        tags.contentSeparator,
+        tags.labelName
+      ],
+      color: "var(--pm-syntax-atom)"
+    },
+    {
+      tag: [tags.literal, tags.inserted],
+      color: "var(--pm-syntax-literal)"
+    },
+    {
+      tag: [tags.string, tags.deleted],
+      color: "var(--pm-syntax-string)"
+    },
+    {
+      tag: [tags.regexp, tags.escape, tags.special(tags.string)],
+      color: "var(--pm-syntax-regexp)"
+    },
+    {
+      tag: tags.definition(tags.variableName),
+      color: "var(--pm-syntax-definition-variable)"
+    },
+    {
+      tag: tags.local(tags.variableName),
+      color: "var(--pm-syntax-local-variable)"
+    },
+    {
+      tag: [tags.typeName, tags.namespace],
+      color: "var(--pm-syntax-type-namespace)"
+    },
+    {
+      tag: tags.className,
+      color: "var(--pm-syntax-class-name)"
+    },
+    {
+      tag: [tags.special(tags.variableName), tags.macroName],
+      color: "var(--pm-syntax-special-variable-macro)"
+    },
+    {
+      tag: tags.definition(tags.propertyName),
+      color: "var(--pm-syntax-definition-property)"
+    },
+    {
+      tag: tags.comment,
+      color: "var(--pm-syntax-comment)"
+    },
+    {
+      tag: tags.invalid,
+      color: "var(--pm-syntax-invalid)"
+    }
+  ])
+);
+const lightTheme = EditorView.theme({
+  ".cm-content": {
+    "--pm-cursor-color": "black",
+    "--pm-header-mark-color": "oklch(82.8% 0.111 230.318)",
+    "--pm-link-color": "oklch(58.8% 0.158 241.966)",
+    "--pm-muted-color": "oklch(37.2% 0.044 257.287)",
+    "--pm-code-background-color": "oklch(92.9% 0.013 255.508)",
+    "--pm-code-btn-background-color": "oklch(86.9% 0.022 252.894)",
+    "--pm-code-btn-hover-background-color": "oklch(70.4% 0.04 256.788)",
+    "--pm-blockquote-vertical-line-background-color": "oklch(70.4% 0.04 256.788)",
+    "--pm-syntax-link": "oklch(62.75% 0.188 259.38)",
+    "--pm-syntax-keyword": "oklch(58.13% 0.248 297.57)",
+    "--pm-syntax-atom": "oklch(51.29% 0.219 260.63)",
+    "--pm-syntax-literal": "oklch(57.38% 0.111 170.31)",
+    "--pm-syntax-string": "oklch(54.86% 0.184 25.53)",
+    "--pm-syntax-regexp": "oklch(65.88% 0.184 43.8)",
+    "--pm-syntax-definition-variable": "oklch(45.32% 0.171 260.3)",
+    "--pm-syntax-local-variable": "oklch(64.13% 0.09 184.42)",
+    "--pm-syntax-type-namespace": "oklch(49.1% 0.091 165.52)",
+    "--pm-syntax-class-name": "oklch(64.42% 0.11 168.83)",
+    "--pm-syntax-special-variable-macro": "oklch(52.58% 0.212 282.71)",
+    "--pm-syntax-definition-property": "oklch(42.1% 0.142 260.08)",
+    "--pm-syntax-comment": "oklch(62.79% 0.022 252.89)",
+    "--pm-syntax-invalid": "oklch(64.62% 0.203 29.2)"
+  }
+});
+function getUrlFromLink(view, pos) {
+  const tree = syntaxTree(view.state);
+  let url;
+  tree.iterate({
+    to: pos,
+    from: pos,
+    enter(node) {
+      if (node.name !== "Link") return;
+      iterChildren(node.node.cursor(), (cursor) => {
+        if (cursor.name === "URL") {
+          url = view.state.doc.sliceString(cursor.from, cursor.to);
+          return true;
+        }
+      });
+      return true;
+    }
+  });
+  return url;
+}
+const clickFullLinkExtension = EditorView.domEventHandlers(
+  eventHandlersWithClass({
+    mousedown: {
+      "cm-rendered-link": (e, view) => {
+        const pos = view.posAtCoords(e);
+        if (pos === null) {
+          return;
+        }
+        const url = getUrlFromLink(view, pos);
+        if (!url) {
+          return;
+        }
+        window.open(url, "_blank");
+      }
+    }
+  })
+);
+const getRawUrl = (view, pos) => {
+  const tree = syntaxTree(view.state);
+  let url;
+  tree.iterate({
+    to: pos,
+    from: pos,
+    enter(node) {
+      var _a;
+      if (node.name !== "URL") return;
+      if (((_a = node.node.parent) == null ? void 0 : _a.name) === "Link") return;
+      url = view.state.doc.sliceString(node.from, node.to);
+      return true;
+    }
+  });
+  return url;
+};
+const addClassToUrl = syntaxHighlighting(
+  HighlightStyle.define([
+    {
+      tag: markdownTags.linkURL,
+      class: "cm-url"
+      // needed for click event
+    }
+  ])
+);
+const clickRawUrlExtension = EditorView.domEventHandlers(
+  eventHandlersWithClass({
+    mousedown: {
+      "cm-url": (e, view) => {
+        const pos = view.posAtCoords(e);
+        if (pos === null) {
+          return;
+        }
+        const url = getRawUrl(view, pos);
+        if (!url) {
+          return;
+        }
+        window.open(url, "_blank");
+      }
+    }
+  })
+);
+const clickLinkExtension = [
+  clickFullLinkExtension,
+  addClassToUrl,
+  clickRawUrlExtension
+];
+const codeBlockDecorations = (view) => {
+  const builder = new RangeSetBuilder();
+  const visited = /* @__PURE__ */ new Set();
+  for (const { from, to } of view.visibleRanges) {
+    syntaxTree(view.state).iterate({
+      from,
+      to,
+      enter: (node) => {
+        if (node.name === "FencedCode") {
+          const key = JSON.stringify([node.from, node.to]);
+          if (visited.has(key)) return;
+          visited.add(key);
+          let lang = "";
+          const codeInfoNode = node.node.getChild("CodeInfo");
+          if (codeInfoNode) {
+            lang = view.state.doc.sliceString(codeInfoNode.from, codeInfoNode.to).toUpperCase();
+          }
+          for (let pos = node.from; pos <= node.to; ) {
+            const line = view.state.doc.lineAt(pos);
+            const isFirstLine = pos === node.from;
+            const isLastLine = line.to >= node.to;
+            builder.add(
+              line.from,
+              line.from,
+              Decoration.line({
+                class: `cm-fenced-code-line ${isFirstLine ? "cm-fenced-code-line-first" : ""} ${isLastLine ? "cm-fenced-code-line-last" : ""}`
+              })
+            );
+            if (isFirstLine) {
+              builder.add(
+                line.from,
+                line.from,
+                Decoration.widget({
+                  widget: new CodeBlockInfoWidget(
+                    lang,
+                    view.state.doc.sliceString(line.to + 1, node.to - 4)
+                  )
+                })
+              );
+            }
+            pos = line.to + 1;
+          }
+        }
+      }
+    });
+  }
+  return builder.finish();
+};
+class CodeBlockInfoWidget extends WidgetType {
+  constructor(lang, code) {
+    super();
+    this.lang = lang;
+    this.code = code;
+  }
+  eq(other) {
+    return other.lang === this.lang && other.code === this.code;
+  }
+  toDOM() {
+    const container = document.createElement("div");
+    container.className = "cm-code-block-info";
+    const langContainer = document.createElement("span");
+    langContainer.className = "cm-code-block-lang-container";
+    langContainer.innerText = this.lang;
+    container.appendChild(langContainer);
+    const copyButton = document.createElement("button");
+    copyButton.className = "cm-code-block-copy-button";
+    copyButton.innerHTML = `
+      <svg xmlns="http://www.w3.org/2000/svg"
+        width="16" height="16" viewBox="0 0 24 24"
+        fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
+        class="lucide lucide-copy-icon lucide-copy">
+          <rect width="14" height="14" x="8" y="8" rx="2" ry="2"/>
+          <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/>
+      </svg>`;
+    copyButton.onclick = () => {
+      void navigator.clipboard.writeText(this.code);
+    };
+    container.appendChild(copyButton);
+    return container;
+  }
+}
+const codeBlockDecorationsExtension = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      __publicField(this, "decorations");
+      this.decorations = codeBlockDecorations(view);
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        this.decorations = codeBlockDecorations(update.view);
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);
+const codeFenceTheme = EditorView.theme({
+  ".cm-fenced-code-line": {
+    display: "block",
+    marginLeft: "6px",
+    backgroundColor: "var(--pm-code-background-color)"
+  },
+  // In case the active line color changes
+  ".cm-activeLine.cm-fenced-code-line": {
+    backgroundColor: "var(--pm-code-background-color)"
+  },
+  ".cm-fenced-code-line-first": {
+    borderTopLeftRadius: "0.4rem",
+    borderTopRightRadius: "0.4rem"
+  },
+  ".cm-fenced-code-line-last": {
+    borderBottomLeftRadius: "0.4rem",
+    borderBottomRightRadius: "0.4rem"
+  },
+  ".cm-code-block-info": {
+    float: "right",
+    padding: "0.2rem",
+    display: "flex",
+    gap: "0.3rem",
+    alignItems: "center"
+  },
+  ".cm-code-block-lang-container": {
+    fontSize: "0.8rem",
+    color: "var(--pm-muted-color)"
+  },
+  ".cm-code-block-copy-button": {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    border: "none",
+    padding: "0.2rem",
+    borderRadius: "0.2rem",
+    cursor: "pointer",
+    backgroundColor: "var(--pm-code-btn-background-color)",
+    color: "var(--pm-muted-color)"
+  },
+  ".cm-code-block-copy-button:hover": {
+    backgroundColor: "var(--pm-code-btn-hover-background-color)"
+  },
+  ".cm-code-block-copy-button svg": {
+    width: "16px",
+    height: "16px"
+  }
+});
+const prosemarkMarkdownSyntaxExtensions = [
+  additionalMarkdownSyntaxTags,
+  escapeMarkdownSyntaxExtension,
+  emojiMarkdownSyntaxExtension
+];
+const defaultFoldableSyntaxExtensions = [
+  blockQuoteExtension,
+  bulletListExtension,
+  taskExtension,
+  imageExtension,
+  emojiExtension,
+  horizonalRuleExtension
+];
+const prosemarkBasicSetup = () => [
+  // Basic CodeMirror Setup
+  history(),
+  dropCursor(),
+  indentOnInput(),
+  bracketMatching(),
+  closeBrackets(),
+  autocompletion(),
+  keymap.of([
+    ...closeBracketsKeymap,
+    ...defaultKeymap,
+    ...searchKeymap,
+    ...historyKeymap,
+    ...foldKeymap,
+    ...completionKeymap,
+    ...lintKeymap,
+    indentWithTab
+  ]),
+  foldGutter(),
+  EditorView.lineWrapping,
+  // ProseMark Setup
+  defaultHideExtensions,
+  defaultFoldableSyntaxExtensions,
+  clickLinkExtension,
+  codeBlockDecorationsExtension
+];
+const prosemarkBaseThemeSetup = () => [
+  baseSyntaxHighlights,
+  generalSyntaxHighlights,
+  baseTheme,
+  codeFenceTheme
+];
+const prosemarkLightThemeSetup = () => lightTheme;
+export {
+  additionalMarkdownSyntaxTags,
+  baseSyntaxHighlights,
+  baseTheme,
+  blockQuoteExtension,
+  bulletListExtension,
+  clickLinkExtension,
+  codeBlockDecorationsExtension,
+  codeFenceTheme,
+  defaultFoldableSyntaxExtensions,
+  defaultHideExtensions,
+  emojiExtension,
+  emojiMarkdownSyntaxExtension,
+  escapeMarkdownSyntaxExtension,
+  eventHandlersWithClass,
+  foldDecorationExtension,
+  foldableSyntaxFacet,
+  generalSyntaxHighlights,
+  horizonalRuleExtension,
+  imageExtension,
+  lightTheme,
+  markdownTags,
+  prosemarkBaseThemeSetup,
+  prosemarkBasicSetup,
+  prosemarkLightThemeSetup,
+  prosemarkMarkdownSyntaxExtensions,
+  selectAllDecorationsOnSelectExtension,
+  taskExtension
+};
+//# sourceMappingURL=main.mjs.map