@arach/arc 0.4.5 → 0.6.0

package/lib/index-DBTOQDAV.js

@@ -0,0 +1,1886 @@
+import { N as y, e as ee, c as g, f as W, P as Tt, t as u, I as ft, a as j, b as ne, s as re, h as se } from "./index-CvsZLy9v.js";
+import { StateEffect as z, Facet as v, StateField as xt, countColumn as ie, EditorState as O, RangeSetBuilder as nt, RangeSet as St, Prec as Pt, combineConfig as Ct } from "./index-CI-w1U9t.js";
+import { V as R, E as b, g as oe, a as p, S as ut, D as H, G as le, W as At, l as ae } from "./index-CnGsbmkP.js";
+var J;
+const S = /* @__PURE__ */ new y();
+function It(n) {
+  return v.define({
+    combine: n ? (t) => t.concat(n) : void 0
+  });
+}
+const he = /* @__PURE__ */ new y();
+class d {
+  /**
+  Construct a language object. If you need to invoke this
+  directly, first define a data facet with
+  [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet), and then
+  configure your parser to [attach](https://codemirror.net/6/docs/ref/#language.languageDataProp) it
+  to the language's outer syntax node.
+  */
+  constructor(t, e, r = [], s = "") {
+    this.data = t, this.name = s, O.prototype.hasOwnProperty("tree") || Object.defineProperty(O.prototype, "tree", { get() {
+      return m(this);
+    } }), this.parser = e, this.extension = [
+      T.of(this),
+      O.languageData.of((i, o, a) => {
+        let l = ct(i, o, a), h = l.type.prop(S);
+        if (!h)
+          return [];
+        let f = i.facet(h), c = l.type.prop(he);
+        if (c) {
+          let w = l.resolve(o - l.from, a);
+          for (let k of c)
+            if (k.test(w, i)) {
+              let P = i.facet(k.facet);
+              return k.type == "replace" ? P : P.concat(f);
+            }
+        }
+        return f;
+      })
+    ].concat(r);
+  }
+  /**
+  Query whether this language is active at the given position.
+  */
+  isActiveAt(t, e, r = -1) {
+    return ct(t, e, r).type.prop(S) == this.data;
+  }
+  /**
+  Find the document regions that were parsed using this language.
+  The returned regions will _include_ any nested languages rooted
+  in this language, when those exist.
+  */
+  findRegions(t) {
+    let e = t.facet(T);
+    if (e?.data == this.data)
+      return [{ from: 0, to: t.doc.length }];
+    if (!e || !e.allowsNesting)
+      return [];
+    let r = [], s = (i, o) => {
+      if (i.prop(S) == this.data) {
+        r.push({ from: o, to: o + i.length });
+        return;
+      }
+      let a = i.prop(y.mounted);
+      if (a) {
+        if (a.tree.prop(S) == this.data) {
+          if (a.overlay)
+            for (let l of a.overlay)
+              r.push({ from: l.from + o, to: l.to + o });
+          else
+            r.push({ from: o, to: o + i.length });
+          return;
+        } else if (a.overlay) {
+          let l = r.length;
+          if (s(a.tree, a.overlay[0].from + o), r.length > l)
+            return;
+        }
+      }
+      for (let l = 0; l < i.children.length; l++) {
+        let h = i.children[l];
+        h instanceof g && s(h, i.positions[l] + o);
+      }
+    };
+    return s(m(t), 0), r;
+  }
+  /**
+  Indicates whether this language allows nested languages. The
+  default implementation returns true.
+  */
+  get allowsNesting() {
+    return !0;
+  }
+}
+d.setState = /* @__PURE__ */ z.define();
+function ct(n, t, e) {
+  let r = n.facet(T), s = m(n).topNode;
+  if (!r || r.allowsNesting)
+    for (let i = s; i; i = i.enter(t, e, ft.ExcludeBuffers | ft.EnterBracketed))
+      i.type.isTop && (s = i);
+  return s;
+}
+class X extends d {
+  constructor(t, e, r) {
+    super(t, e, [], r), this.parser = e;
+  }
+  /**
+  Define a language from a parser.
+  */
+  static define(t) {
+    let e = It(t.languageData);
+    return new X(e, t.parser.configure({
+      props: [S.add((r) => r.isTop ? e : void 0)]
+    }), t.name);
+  }
+  /**
+  Create a new instance of this language with a reconfigured
+  version of its parser and optionally a new name.
+  */
+  configure(t, e) {
+    return new X(this.data, this.parser.configure(t), e || this.name);
+  }
+  get allowsNesting() {
+    return this.parser.hasWrappers();
+  }
+}
+function m(n) {
+  let t = n.field(d.state, !1);
+  return t ? t.tree : g.empty;
+}
+function fe(n, t, e = 50) {
+  var r;
+  let s = (r = n.field(d.state, !1)) === null || r === void 0 ? void 0 : r.context;
+  if (!s)
+    return null;
+  let i = s.viewport;
+  s.updateViewport({ from: 0, to: t });
+  let o = s.isDone(t) || s.work(e, t) ? s.tree : null;
+  return s.updateViewport(i), o;
+}
+function on(n, t = n.doc.length) {
+  var e;
+  return ((e = n.field(d.state, !1)) === null || e === void 0 ? void 0 : e.context.isDone(t)) || !1;
+}
+function ln(n, t = n.viewport.to, e = 100) {
+  let r = fe(n.state, t, e);
+  return r != m(n.state) && n.dispatch({}), !!r;
+}
+function an(n) {
+  var t;
+  return ((t = n.plugin(Mt)) === null || t === void 0 ? void 0 : t.isWorking()) || !1;
+}
+class ue {
+  /**
+  Create an input object for the given document.
+  */
+  constructor(t) {
+    this.doc = t, this.cursorPos = 0, this.string = "", this.cursor = t.iter();
+  }
+  get length() {
+    return this.doc.length;
+  }
+  syncTo(t) {
+    return this.string = this.cursor.next(t - this.cursorPos).value, this.cursorPos = t + this.string.length, this.cursorPos - this.string.length;
+  }
+  chunk(t) {
+    return this.syncTo(t), this.string;
+  }
+  get lineChunks() {
+    return !0;
+  }
+  read(t, e) {
+    let r = this.cursorPos - this.string.length;
+    return t < r || e >= this.cursorPos ? this.doc.sliceString(t, e) : this.string.slice(t - r, e - r);
+  }
+}
+let M = null;
+class A {
+  constructor(t, e, r = [], s, i, o, a, l) {
+    this.parser = t, this.state = e, this.fragments = r, this.tree = s, this.treeLen = i, this.viewport = o, this.skipped = a, this.scheduleOn = l, this.parse = null, this.tempSkipped = [];
+  }
+  /**
+  @internal
+  */
+  static create(t, e, r) {
+    return new A(t, e, [], g.empty, 0, r, [], null);
+  }
+  startParse() {
+    return this.parser.startParse(new ue(this.state.doc), this.fragments);
+  }
+  /**
+  @internal
+  */
+  work(t, e) {
+    return e != null && e >= this.state.doc.length && (e = void 0), this.tree != g.empty && this.isDone(e ?? this.state.doc.length) ? (this.takeTree(), !0) : this.withContext(() => {
+      var r;
+      if (typeof t == "number") {
+        let s = Date.now() + t;
+        t = () => Date.now() > s;
+      }
+      for (this.parse || (this.parse = this.startParse()), e != null && (this.parse.stoppedAt == null || this.parse.stoppedAt > e) && e < this.state.doc.length && this.parse.stopAt(e); ; ) {
+        let s = this.parse.advance();
+        if (s)
+          if (this.fragments = this.withoutTempSkipped(W.addTree(s, this.fragments, this.parse.stoppedAt != null)), this.treeLen = (r = this.parse.stoppedAt) !== null && r !== void 0 ? r : this.state.doc.length, this.tree = s, this.parse = null, this.treeLen < (e ?? this.state.doc.length))
+            this.parse = this.startParse();
+          else
+            return !0;
+        if (t())
+          return !1;
+      }
+    });
+  }
+  /**
+  @internal
+  */
+  takeTree() {
+    let t, e;
+    this.parse && (t = this.parse.parsedPos) >= this.treeLen && ((this.parse.stoppedAt == null || this.parse.stoppedAt > t) && this.parse.stopAt(t), this.withContext(() => {
+      for (; !(e = this.parse.advance()); )
+        ;
+    }), this.treeLen = t, this.tree = e, this.fragments = this.withoutTempSkipped(W.addTree(this.tree, this.fragments, !0)), this.parse = null);
+  }
+  withContext(t) {
+    let e = M;
+    M = this;
+    try {
+      return t();
+    } finally {
+      M = e;
+    }
+  }
+  withoutTempSkipped(t) {
+    for (let e; e = this.tempSkipped.pop(); )
+      t = dt(t, e.from, e.to);
+    return t;
+  }
+  /**
+  @internal
+  */
+  changes(t, e) {
+    let { fragments: r, tree: s, treeLen: i, viewport: o, skipped: a } = this;
+    if (this.takeTree(), !t.empty) {
+      let l = [];
+      if (t.iterChangedRanges((h, f, c, w) => l.push({ fromA: h, toA: f, fromB: c, toB: w })), r = W.applyChanges(r, l), s = g.empty, i = 0, o = { from: t.mapPos(o.from, -1), to: t.mapPos(o.to, 1) }, this.skipped.length) {
+        a = [];
+        for (let h of this.skipped) {
+          let f = t.mapPos(h.from, 1), c = t.mapPos(h.to, -1);
+          f < c && a.push({ from: f, to: c });
+        }
+      }
+    }
+    return new A(this.parser, e, r, s, i, o, a, this.scheduleOn);
+  }
+  /**
+  @internal
+  */
+  updateViewport(t) {
+    if (this.viewport.from == t.from && this.viewport.to == t.to)
+      return !1;
+    this.viewport = t;
+    let e = this.skipped.length;
+    for (let r = 0; r < this.skipped.length; r++) {
+      let { from: s, to: i } = this.skipped[r];
+      s < t.to && i > t.from && (this.fragments = dt(this.fragments, s, i), this.skipped.splice(r--, 1));
+    }
+    return this.skipped.length >= e ? !1 : (this.reset(), !0);
+  }
+  /**
+  @internal
+  */
+  reset() {
+    this.parse && (this.takeTree(), this.parse = null);
+  }
+  /**
+  Notify the parse scheduler that the given region was skipped
+  because it wasn't in view, and the parse should be restarted
+  when it comes into view.
+  */
+  skipUntilInView(t, e) {
+    this.skipped.push({ from: t, to: e });
+  }
+  /**
+  Returns a parser intended to be used as placeholder when
+  asynchronously loading a nested parser. It'll skip its input and
+  mark it as not-really-parsed, so that the next update will parse
+  it again.
+  
+  When `until` is given, a reparse will be scheduled when that
+  promise resolves.
+  */
+  static getSkippingParser(t) {
+    return new class extends Tt {
+      createParse(e, r, s) {
+        let i = s[0].from, o = s[s.length - 1].to;
+        return {
+          parsedPos: i,
+          advance() {
+            let l = M;
+            if (l) {
+              for (let h of s)
+                l.tempSkipped.push(h);
+              t && (l.scheduleOn = l.scheduleOn ? Promise.all([l.scheduleOn, t]) : t);
+            }
+            return this.parsedPos = o, new g(j.none, [], [], o - i);
+          },
+          stoppedAt: null,
+          stopAt() {
+          }
+        };
+      }
+    }();
+  }
+  /**
+  @internal
+  */
+  isDone(t) {
+    t = Math.min(t, this.state.doc.length);
+    let e = this.fragments;
+    return this.treeLen >= t && e.length && e[0].from == 0 && e[0].to >= t;
+  }
+  /**
+  Get the context for the current parse, or `null` if no editor
+  parse is in progress.
+  */
+  static get() {
+    return M;
+  }
+}
+function dt(n, t, e) {
+  return W.applyChanges(n, [{ fromA: t, toA: e, fromB: t, toB: e }]);
+}
+class I {
+  constructor(t) {
+    this.context = t, this.tree = t.tree;
+  }
+  apply(t) {
+    if (!t.docChanged && this.tree == this.context.tree)
+      return this;
+    let e = this.context.changes(t.changes, t.state), r = this.context.treeLen == t.startState.doc.length ? void 0 : Math.max(t.changes.mapPos(this.context.treeLen), e.viewport.to);
+    return e.work(20, r) || e.takeTree(), new I(e);
+  }
+  static init(t) {
+    let e = Math.min(3e3, t.doc.length), r = A.create(t.facet(T).parser, t, { from: 0, to: e });
+    return r.work(20, e) || r.takeTree(), new I(r);
+  }
+}
+d.state = /* @__PURE__ */ xt.define({
+  create: I.init,
+  update(n, t) {
+    for (let e of t.effects)
+      if (e.is(d.setState))
+        return e.value;
+    return t.startState.facet(T) != t.state.facet(T) ? I.init(t.state) : n.apply(t);
+  }
+});
+let Dt = (n) => {
+  let t = setTimeout(
+    () => n(),
+    500
+    /* Work.MaxPause */
+  );
+  return () => clearTimeout(t);
+};
+typeof requestIdleCallback < "u" && (Dt = (n) => {
+  let t = -1, e = setTimeout(
+    () => {
+      t = requestIdleCallback(n, {
+        timeout: 400
+        /* Work.MinPause */
+      });
+    },
+    100
+    /* Work.MinPause */
+  );
+  return () => t < 0 ? clearTimeout(e) : cancelIdleCallback(t);
+});
+const _ = typeof navigator < "u" && (!((J = navigator.scheduling) === null || J === void 0) && J.isInputPending) ? () => navigator.scheduling.isInputPending() : null, Mt = /* @__PURE__ */ R.fromClass(class {
+  constructor(t) {
+    this.view = t, this.working = null, this.workScheduled = 0, this.chunkEnd = -1, this.chunkBudget = -1, this.work = this.work.bind(this), this.scheduleWork();
+  }
+  update(t) {
+    let e = this.view.state.field(d.state).context;
+    (e.updateViewport(t.view.viewport) || this.view.viewport.to > e.treeLen) && this.scheduleWork(), (t.docChanged || t.selectionSet) && (this.view.hasFocus && (this.chunkBudget += 50), this.scheduleWork()), this.checkAsyncSchedule(e);
+  }
+  scheduleWork() {
+    if (this.working)
+      return;
+    let { state: t } = this.view, e = t.field(d.state);
+    (e.tree != e.context.tree || !e.context.isDone(t.doc.length)) && (this.working = Dt(this.work));
+  }
+  work(t) {
+    this.working = null;
+    let e = Date.now();
+    if (this.chunkEnd < e && (this.chunkEnd < 0 || this.view.hasFocus) && (this.chunkEnd = e + 3e4, this.chunkBudget = 3e3), this.chunkBudget <= 0)
+      return;
+    let { state: r, viewport: { to: s } } = this.view, i = r.field(d.state);
+    if (i.tree == i.context.tree && i.context.isDone(
+      s + 1e5
+      /* Work.MaxParseAhead */
+    ))
+      return;
+    let o = Date.now() + Math.min(this.chunkBudget, 100, t && !_ ? Math.max(25, t.timeRemaining() - 5) : 1e9), a = i.context.treeLen < s && r.doc.length > s + 1e3, l = i.context.work(() => _ && _() || Date.now() > o, s + (a ? 0 : 1e5));
+    this.chunkBudget -= Date.now() - e, (l || this.chunkBudget <= 0) && (i.context.takeTree(), this.view.dispatch({ effects: d.setState.of(new I(i.context)) })), this.chunkBudget > 0 && !(l && !a) && this.scheduleWork(), this.checkAsyncSchedule(i.context);
+  }
+  checkAsyncSchedule(t) {
+    t.scheduleOn && (this.workScheduled++, t.scheduleOn.then(() => this.scheduleWork()).catch((e) => ae(this.view.state, e)).then(() => this.workScheduled--), t.scheduleOn = null);
+  }
+  destroy() {
+    this.working && this.working();
+  }
+  isWorking() {
+    return !!(this.working || this.workScheduled > 0);
+  }
+}, {
+  eventHandlers: { focus() {
+    this.scheduleWork();
+  } }
+}), T = /* @__PURE__ */ v.define({
+  combine(n) {
+    return n.length ? n[0] : null;
+  },
+  enables: (n) => [
+    d.state,
+    Mt,
+    b.contentAttributes.compute([n], (t) => {
+      let e = t.facet(n);
+      return e && e.name ? { "data-language": e.name } : {};
+    })
+  ]
+});
+class fn {
+  /**
+  Create a language support object.
+  */
+  constructor(t, e = []) {
+    this.language = t, this.support = e, this.extension = [t, e];
+  }
+}
+class Ot {
+  constructor(t, e, r, s, i, o = void 0) {
+    this.name = t, this.alias = e, this.extensions = r, this.filename = s, this.loadFunc = i, this.support = o, this.loading = null;
+  }
+  /**
+  Start loading the the language. Will return a promise that
+  resolves to a [`LanguageSupport`](https://codemirror.net/6/docs/ref/#language.LanguageSupport)
+  object when the language successfully loads.
+  */
+  load() {
+    return this.loading || (this.loading = this.loadFunc().then((t) => this.support = t, (t) => {
+      throw this.loading = null, t;
+    }));
+  }
+  /**
+  Create a language description.
+  */
+  static of(t) {
+    let { load: e, support: r } = t;
+    if (!e) {
+      if (!r)
+        throw new RangeError("Must pass either 'load' or 'support' to LanguageDescription.of");
+      e = () => Promise.resolve(r);
+    }
+    return new Ot(t.name, (t.alias || []).concat(t.name).map((s) => s.toLowerCase()), t.extensions || [], t.filename, e, r);
+  }
+  /**
+  Look for a language in the given array of descriptions that
+  matches the filename. Will first match
+  [`filename`](https://codemirror.net/6/docs/ref/#language.LanguageDescription.filename) patterns,
+  and then [extensions](https://codemirror.net/6/docs/ref/#language.LanguageDescription.extensions),
+  and return the first language that matches.
+  */
+  static matchFilename(t, e) {
+    for (let s of t)
+      if (s.filename && s.filename.test(e))
+        return s;
+    let r = /\.([^.]+)$/.exec(e);
+    if (r) {
+      for (let s of t)
+        if (s.extensions.indexOf(r[1]) > -1)
+          return s;
+    }
+    return null;
+  }
+  /**
+  Look for a language whose name or alias matches the the given
+  name (case-insensitively). If `fuzzy` is true, and no direct
+  matchs is found, this'll also search for a language whose name
+  or alias occurs in the string (for names shorter than three
+  characters, only when surrounded by non-word characters).
+  */
+  static matchLanguageName(t, e, r = !0) {
+    e = e.toLowerCase();
+    for (let s of t)
+      if (s.alias.some((i) => i == e))
+        return s;
+    if (r)
+      for (let s of t)
+        for (let i of s.alias) {
+          let o = e.indexOf(i);
+          if (o > -1 && (i.length > 2 || !/\w/.test(e[o - 1]) && !/\w/.test(e[o + i.length])))
+            return s;
+        }
+    return null;
+  }
+}
+const ce = /* @__PURE__ */ v.define(), Bt = /* @__PURE__ */ v.define({
+  combine: (n) => {
+    if (!n.length)
+      return "  ";
+    let t = n[0];
+    if (!t || /\S/.test(t) || Array.from(t).some((e) => e != t[0]))
+      throw new Error("Invalid indent unit: " + JSON.stringify(n[0]));
+    return t;
+  }
+});
+function V(n) {
+  let t = n.facet(Bt);
+  return t.charCodeAt(0) == 9 ? n.tabSize * t.length : t.length;
+}
+function Lt(n, t) {
+  let e = "", r = n.tabSize, s = n.facet(Bt)[0];
+  if (s == "	") {
+    for (; t >= r; )
+      e += "	", t -= r;
+    s = " ";
+  }
+  for (let i = 0; i < t; i++)
+    e += s;
+  return e;
+}
+function Nt(n, t) {
+  n instanceof O && (n = new rt(n));
+  for (let r of n.state.facet(ce)) {
+    let s = r(n, t);
+    if (s !== void 0)
+      return s;
+  }
+  let e = m(n.state);
+  return e.length >= t ? de(n, e, t) : null;
+}
+function un(n, t, e) {
+  let r = /* @__PURE__ */ Object.create(null), s = new rt(n, { overrideIndentation: (o) => {
+    var a;
+    return (a = r[o]) !== null && a !== void 0 ? a : -1;
+  } }), i = [];
+  for (let o = t; o <= e; ) {
+    let a = n.doc.lineAt(o);
+    o = a.to + 1;
+    let l = Nt(s, a.from);
+    if (l == null)
+      continue;
+    /\S/.test(a.text) || (l = 0);
+    let h = /^\s*/.exec(a.text)[0], f = Lt(n, l);
+    h != f && (r[a.from] = l, i.push({ from: a.from, to: a.from + h.length, insert: f }));
+  }
+  return n.changes(i);
+}
+class rt {
+  /**
+  Create an indent context.
+  */
+  constructor(t, e = {}) {
+    this.state = t, this.options = e, this.unit = V(t);
+  }
+  /**
+  Get a description of the line at the given position, taking
+  [simulated line
+  breaks](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
+  into account. If there is such a break at `pos`, the `bias`
+  argument determines whether the part of the line line before or
+  after the break is used.
+  */
+  lineAt(t, e = 1) {
+    let r = this.state.doc.lineAt(t), { simulateBreak: s, simulateDoubleBreak: i } = this.options;
+    return s != null && s >= r.from && s <= r.to ? i && s == t ? { text: "", from: t } : (e < 0 ? s < t : s <= t) ? { text: r.text.slice(s - r.from), from: s } : { text: r.text.slice(0, s - r.from), from: r.from } : r;
+  }
+  /**
+  Get the text directly after `pos`, either the entire line
+  or the next 100 characters, whichever is shorter.
+  */
+  textAfterPos(t, e = 1) {
+    if (this.options.simulateDoubleBreak && t == this.options.simulateBreak)
+      return "";
+    let { text: r, from: s } = this.lineAt(t, e);
+    return r.slice(t - s, Math.min(r.length, t + 100 - s));
+  }
+  /**
+  Find the column for the given position.
+  */
+  column(t, e = 1) {
+    let { text: r, from: s } = this.lineAt(t, e), i = this.countColumn(r, t - s), o = this.options.overrideIndentation ? this.options.overrideIndentation(s) : -1;
+    return o > -1 && (i += o - this.countColumn(r, r.search(/\S|$/))), i;
+  }
+  /**
+  Find the column position (taking tabs into account) of the given
+  position in the given string.
+  */
+  countColumn(t, e = t.length) {
+    return ie(t, this.state.tabSize, e);
+  }
+  /**
+  Find the indentation column of the line at the given point.
+  */
+  lineIndent(t, e = 1) {
+    let { text: r, from: s } = this.lineAt(t, e), i = this.options.overrideIndentation;
+    if (i) {
+      let o = i(s);
+      if (o > -1)
+        return o;
+    }
+    return this.countColumn(r, r.search(/\S|$/));
+  }
+  /**
+  Returns the [simulated line
+  break](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
+  for this context, if any.
+  */
+  get simulatedBreak() {
+    return this.options.simulateBreak || null;
+  }
+}
+const Rt = /* @__PURE__ */ new y();
+function de(n, t, e) {
+  let r = t.resolveStack(e), s = t.resolveInner(e, -1).resolve(e, 0).enterUnfinishedNodesBefore(e);
+  if (s != r.node) {
+    let i = [];
+    for (let o = s; o && !(o.from < r.node.from || o.to > r.node.to || o.from == r.node.from && o.type == r.node.type); o = o.parent)
+      i.push(o);
+    for (let o = i.length - 1; o >= 0; o--)
+      r = { node: i[o], next: r };
+  }
+  return Et(r, n, e);
+}
+function Et(n, t, e) {
+  for (let r = n; r; r = r.next) {
+    let s = ge(r.node);
+    if (s)
+      return s(st.create(t, e, r));
+  }
+  return 0;
+}
+function pe(n) {
+  return n.pos == n.options.simulateBreak && n.options.simulateDoubleBreak;
+}
+function ge(n) {
+  let t = n.type.prop(Rt);
+  if (t)
+    return t;
+  let e = n.firstChild, r;
+  if (e && (r = e.type.prop(y.closedBy))) {
+    let s = n.lastChild, i = s && r.indexOf(s.name) > -1;
+    return (o) => Ft(o, !0, 1, void 0, i && !pe(o) ? s.from : void 0);
+  }
+  return n.parent == null ? me : null;
+}
+function me() {
+  return 0;
+}
+class st extends rt {
+  constructor(t, e, r) {
+    super(t.state, t.options), this.base = t, this.pos = e, this.context = r;
+  }
+  /**
+  The syntax tree node to which the indentation strategy
+  applies.
+  */
+  get node() {
+    return this.context.node;
+  }
+  /**
+  @internal
+  */
+  static create(t, e, r) {
+    return new st(t, e, r);
+  }
+  /**
+  Get the text directly after `this.pos`, either the entire line
+  or the next 100 characters, whichever is shorter.
+  */
+  get textAfter() {
+    return this.textAfterPos(this.pos);
+  }
+  /**
+  Get the indentation at the reference line for `this.node`, which
+  is the line on which it starts, unless there is a node that is
+  _not_ a parent of this node covering the start of that line. If
+  so, the line at the start of that node is tried, again skipping
+  on if it is covered by another such node.
+  */
+  get baseIndent() {
+    return this.baseIndentFor(this.node);
+  }
+  /**
+  Get the indentation for the reference line of the given node
+  (see [`baseIndent`](https://codemirror.net/6/docs/ref/#language.TreeIndentContext.baseIndent)).
+  */
+  baseIndentFor(t) {
+    let e = this.state.doc.lineAt(t.from);
+    for (; ; ) {
+      let r = t.resolve(e.from);
+      for (; r.parent && r.parent.from == r.from; )
+        r = r.parent;
+      if (ke(r, t))
+        break;
+      e = this.state.doc.lineAt(r.from);
+    }
+    return this.lineIndent(e.from);
+  }
+  /**
+  Continue looking for indentations in the node's parent nodes,
+  and return the result of that.
+  */
+  continue() {
+    return Et(this.context.next, this.base, this.pos);
+  }
+}
+function ke(n, t) {
+  for (let e = t; e; e = e.parent)
+    if (n == e)
+      return !0;
+  return !1;
+}
+function be(n) {
+  let t = n.node, e = t.childAfter(t.from), r = t.lastChild;
+  if (!e)
+    return null;
+  let s = n.options.simulateBreak, i = n.state.doc.lineAt(e.from), o = s == null || s <= i.from ? i.to : Math.min(i.to, s);
+  for (let a = e.to; ; ) {
+    let l = t.childAfter(a);
+    if (!l || l == r)
+      return null;
+    if (!l.type.isSkipped) {
+      if (l.from >= o)
+        return null;
+      let h = /^ */.exec(i.text.slice(e.to - i.from))[0].length;
+      return { from: e.from, to: e.to + h };
+    }
+    a = l.to;
+  }
+}
+function cn({ closing: n, align: t = !0, units: e = 1 }) {
+  return (r) => Ft(r, t, e, n);
+}
+function Ft(n, t, e, r, s) {
+  let i = n.textAfter, o = i.match(/^\s*/)[0].length, a = r && i.slice(o, o + r.length) == r || s == n.pos + o, l = t ? be(n) : null;
+  return l ? a ? n.column(l.from) : n.column(l.to) : n.baseIndent + (a ? 0 : n.unit * e);
+}
+const dn = (n) => n.baseIndent;
+function pn({ except: n, units: t = 1 } = {}) {
+  return (e) => {
+    let r = n && n.test(e.textAfter);
+    return e.baseIndent + (r ? 0 : t * e.unit);
+  };
+}
+const we = 200;
+function gn() {
+  return O.transactionFilter.of((n) => {
+    if (!n.docChanged || !n.isUserEvent("input.type") && !n.isUserEvent("input.complete"))
+      return n;
+    let t = n.startState.languageDataAt("indentOnInput", n.startState.selection.main.head);
+    if (!t.length)
+      return n;
+    let e = n.newDoc, { head: r } = n.newSelection.main, s = e.lineAt(r);
+    if (r > s.from + we)
+      return n;
+    let i = e.sliceString(s.from, r);
+    if (!t.some((h) => h.test(i)))
+      return n;
+    let { state: o } = n, a = -1, l = [];
+    for (let { head: h } of o.selection.ranges) {
+      let f = o.doc.lineAt(h);
+      if (f.from == a)
+        continue;
+      a = f.from;
+      let c = Nt(o, f.from);
+      if (c == null)
+        continue;
+      let w = /^\s*/.exec(f.text)[0], k = Lt(o, c);
+      w != k && l.push({ from: f.from, to: f.from + w.length, insert: k });
+    }
+    return l.length ? [n, { changes: l, sequential: !0 }] : n;
+  });
+}
+const ye = /* @__PURE__ */ v.define(), ve = /* @__PURE__ */ new y();
+function mn(n) {
+  let t = n.firstChild, e = n.lastChild;
+  return t && t.to < e.from ? { from: t.to, to: e.type.isError ? n.to : e.from } : null;
+}
+function Te(n, t, e) {
+  let r = m(n);
+  if (r.length < e)
+    return null;
+  let s = r.resolveStack(e, 1), i = null;
+  for (let o = s; o; o = o.next) {
+    let a = o.node;
+    if (a.to <= e || a.from > e)
+      continue;
+    if (i && a.from < t)
+      break;
+    let l = a.type.prop(ve);
+    if (l && (a.to < r.length - 50 || r.length == n.doc.length || !xe(a))) {
+      let h = l(a, n);
+      h && h.from <= e && h.from >= t && h.to > e && (i = h);
+    }
+  }
+  return i;
+}
+function xe(n) {
+  let t = n.lastChild;
+  return t && t.to == n.to && t.type.isError;
+}
+function B(n, t, e) {
+  for (let r of n.facet(ye)) {
+    let s = r(n, t, e);
+    if (s)
+      return s;
+  }
+  return Te(n, t, e);
+}
+function Wt(n, t) {
+  let e = t.mapPos(n.from, 1), r = t.mapPos(n.to, -1);
+  return e >= r ? void 0 : { from: e, to: r };
+}
+const E = /* @__PURE__ */ z.define({ map: Wt }), D = /* @__PURE__ */ z.define({ map: Wt });
+function it(n) {
+  let t = [];
+  for (let { head: e } of n.state.selection.ranges)
+    t.some((r) => r.from <= e && r.to >= e) || t.push(n.lineBlockAt(e));
+  return t;
+}
+const x = /* @__PURE__ */ xt.define({
+  create() {
+    return p.none;
+  },
+  update(n, t) {
+    t.isUserEvent("delete") && t.changes.iterChangedRanges((r, s) => n = pt(n, r, s)), n = n.map(t.changes);
+    let e = [];
+    for (let r of t.effects)
+      r.is(E) && !Se(n, r.value.from, r.value.to) ? e.push(r.value) : r.is(D) && (n = n.update({
+        filter: (s, i) => r.value.from != s || r.value.to != i,
+        filterFrom: r.value.from,
+        filterTo: r.value.to
+      }));
+    if (e.length) {
+      let { preparePlaceholder: r } = t.state.facet(lt), s = e.map((i) => (r ? p.replace({ widget: new Oe(r(t.state, i)) }) : gt).range(i.from, i.to));
+      n = n.update({ add: s });
+    }
+    return t.selection && (n = pt(n, t.selection.main.head)), n;
+  },
+  provide: (n) => b.decorations.from(n),
+  toJSON(n, t) {
+    let e = [];
+    return n.between(0, t.doc.length, (r, s) => {
+      e.push(r, s);
+    }), e;
+  },
+  fromJSON(n) {
+    if (!Array.isArray(n) || n.length % 2)
+      throw new RangeError("Invalid JSON for fold state");
+    let t = [];
+    for (let e = 0; e < n.length; ) {
+      let r = n[e++], s = n[e++];
+      if (typeof r != "number" || typeof s != "number")
+        throw new RangeError("Invalid JSON for fold state");
+      t.push(gt.range(r, s));
+    }
+    return p.set(t, !0);
+  }
+});
+function pt(n, t, e = t) {
+  let r = !1;
+  return n.between(t, e, (s, i) => {
+    s < e && i > t && (r = !0);
+  }), r ? n.update({
+    filterFrom: t,
+    filterTo: e,
+    filter: (s, i) => s >= e || i <= t
+  }) : n;
+}
+function kn(n) {
+  return n.field(x, !1) || St.empty;
+}
+function L(n, t, e) {
+  var r;
+  let s = null;
+  return (r = n.field(x, !1)) === null || r === void 0 || r.between(t, e, (i, o) => {
+    (!s || s.from > i) && (s = { from: i, to: o });
+  }), s;
+}
+function Se(n, t, e) {
+  let r = !1;
+  return n.between(t, t, (s, i) => {
+    s == t && i == e && (r = !0);
+  }), r;
+}
+function ot(n, t) {
+  return n.field(x, !1) ? t : t.concat(z.appendConfig.of(Ut()));
+}
+const Pe = (n) => {
+  for (let t of it(n)) {
+    let e = B(n.state, t.from, t.to);
+    if (e)
+      return n.dispatch({ effects: ot(n.state, [E.of(e), $(n, e)]) }), !0;
+  }
+  return !1;
+}, Ce = (n) => {
+  if (!n.state.field(x, !1))
+    return !1;
+  let t = [];
+  for (let e of it(n)) {
+    let r = L(n.state, e.from, e.to);
+    r && t.push(D.of(r), $(n, r, !1));
+  }
+  return t.length && n.dispatch({ effects: t }), t.length > 0;
+};
+function $(n, t, e = !0) {
+  let r = n.state.doc.lineAt(t.from).number, s = n.state.doc.lineAt(t.to).number;
+  return b.announce.of(`${n.state.phrase(e ? "Folded lines" : "Unfolded lines")} ${r} ${n.state.phrase("to")} ${s}.`);
+}
+const Ae = (n) => {
+  let { state: t } = n, e = [];
+  for (let r = 0; r < t.doc.length; ) {
+    let s = n.lineBlockAt(r), i = B(t, s.from, s.to);
+    i && e.push(E.of(i)), r = (i ? n.lineBlockAt(i.to) : s).to + 1;
+  }
+  return e.length && n.dispatch({ effects: ot(n.state, e) }), !!e.length;
+}, Ie = (n) => {
+  let t = n.state.field(x, !1);
+  if (!t || !t.size)
+    return !1;
+  let e = [];
+  return t.between(0, n.state.doc.length, (r, s) => {
+    e.push(D.of({ from: r, to: s }));
+  }), n.dispatch({ effects: e }), !0;
+};
+function De(n, t) {
+  for (let e = t; ; ) {
+    let r = B(n.state, e.from, e.to);
+    if (r && r.to > t.from)
+      return r;
+    if (!e.from)
+      return null;
+    e = n.lineBlockAt(e.from - 1);
+  }
+}
+const bn = (n) => {
+  let t = [];
+  for (let e of it(n)) {
+    let r = L(n.state, e.from, e.to);
+    if (r)
+      t.push(D.of(r), $(n, r, !1));
+    else {
+      let s = De(n, e);
+      s && t.push(E.of(s), $(n, s));
+    }
+  }
+  return t.length > 0 && n.dispatch({ effects: ot(n.state, t) }), !!t.length;
+}, wn = [
+  { key: "Ctrl-Shift-[", mac: "Cmd-Alt-[", run: Pe },
+  { key: "Ctrl-Shift-]", mac: "Cmd-Alt-]", run: Ce },
+  { key: "Ctrl-Alt-[", run: Ae },
+  { key: "Ctrl-Alt-]", run: Ie }
+], Me = {
+  placeholderDOM: null,
+  preparePlaceholder: null,
+  placeholderText: "…"
+}, lt = /* @__PURE__ */ v.define({
+  combine(n) {
+    return Ct(n, Me);
+  }
+});
+function Ut(n) {
+  let t = [x, Le];
+  return n && t.push(lt.of(n)), t;
+}
+function Ht(n, t) {
+  let { state: e } = n, r = e.facet(lt), s = (o) => {
+    let a = n.lineBlockAt(n.posAtDOM(o.target)), l = L(n.state, a.from, a.to);
+    l && n.dispatch({ effects: D.of(l) }), o.preventDefault();
+  };
+  if (r.placeholderDOM)
+    return r.placeholderDOM(n, s, t);
+  let i = document.createElement("span");
+  return i.textContent = r.placeholderText, i.setAttribute("aria-label", e.phrase("folded code")), i.title = e.phrase("unfold"), i.className = "cm-foldPlaceholder", i.onclick = s, i;
+}
+const gt = /* @__PURE__ */ p.replace({ widget: /* @__PURE__ */ new class extends At {
+  toDOM(n) {
+    return Ht(n, null);
+  }
+}() });
+class Oe extends At {
+  constructor(t) {
+    super(), this.value = t;
+  }
+  eq(t) {
+    return this.value == t.value;
+  }
+  toDOM(t) {
+    return Ht(t, this.value);
+  }
+}
+const Be = {
+  openText: "⌄",
+  closedText: "›",
+  markerDOM: null,
+  domEventHandlers: {},
+  foldingChanged: () => !1
+};
+class K extends le {
+  constructor(t, e) {
+    super(), this.config = t, this.open = e;
+  }
+  eq(t) {
+    return this.config == t.config && this.open == t.open;
+  }
+  toDOM(t) {
+    if (this.config.markerDOM)
+      return this.config.markerDOM(this.open);
+    let e = document.createElement("span");
+    return e.textContent = this.open ? this.config.openText : this.config.closedText, e.title = t.state.phrase(this.open ? "Fold line" : "Unfold line"), e;
+  }
+}
+function yn(n = {}) {
+  let t = { ...Be, ...n }, e = new K(t, !0), r = new K(t, !1), s = R.fromClass(class {
+    constructor(o) {
+      this.from = o.viewport.from, this.markers = this.buildMarkers(o);
+    }
+    update(o) {
+      (o.docChanged || o.viewportChanged || o.startState.facet(T) != o.state.facet(T) || o.startState.field(x, !1) != o.state.field(x, !1) || m(o.startState) != m(o.state) || t.foldingChanged(o)) && (this.markers = this.buildMarkers(o.view));
+    }
+    buildMarkers(o) {
+      let a = new nt();
+      for (let l of o.viewportLineBlocks) {
+        let h = L(o.state, l.from, l.to) ? r : B(o.state, l.from, l.to) ? e : null;
+        h && a.add(l.from, l.from, h);
+      }
+      return a.finish();
+    }
+  }), { domEventHandlers: i } = t;
+  return [
+    s,
+    oe({
+      class: "cm-foldGutter",
+      markers(o) {
+        var a;
+        return ((a = o.plugin(s)) === null || a === void 0 ? void 0 : a.markers) || St.empty;
+      },
+      initialSpacer() {
+        return new K(t, !1);
+      },
+      domEventHandlers: {
+        ...i,
+        click: (o, a, l) => {
+          if (i.click && i.click(o, a, l))
+            return !0;
+          let h = L(o.state, a.from, a.to);
+          if (h)
+            return o.dispatch({ effects: D.of(h) }), !0;
+          let f = B(o.state, a.from, a.to);
+          return f ? (o.dispatch({ effects: E.of(f) }), !0) : !1;
+        }
+      }
+    }),
+    Ut()
+  ];
+}
+const Le = /* @__PURE__ */ b.baseTheme({
+  ".cm-foldPlaceholder": {
+    backgroundColor: "#eee",
+    border: "1px solid #ddd",
+    color: "#888",
+    borderRadius: ".2em",
+    margin: "0 1px",
+    padding: "0 1px",
+    cursor: "pointer"
+  },
+  ".cm-foldGutter span": {
+    padding: "0 1px",
+    cursor: "pointer"
+  }
+});
+class G {
+  constructor(t, e) {
+    this.specs = t;
+    let r;
+    function s(a) {
+      let l = ut.newName();
+      return (r || (r = /* @__PURE__ */ Object.create(null)))["." + l] = a, l;
+    }
+    const i = typeof e.all == "string" ? e.all : e.all ? s(e.all) : void 0, o = e.scope;
+    this.scope = o instanceof d ? (a) => a.prop(S) == o.data : o ? (a) => a == o : void 0, this.style = ee(t.map((a) => ({
+      tag: a.tag,
+      class: a.class || s(Object.assign({}, a, { tag: null }))
+    })), {
+      all: i
+    }).style, this.module = r ? new ut(r) : null, this.themeType = e.themeType;
+  }
+  /**
+  Create a highlighter style that associates the given styles to
+  the given tags. The specs must be objects that hold a style tag
+  or array of tags in their `tag` property, and either a single
+  `class` property providing a static CSS class (for highlighter
+  that rely on external styling), or a
+  [`style-mod`](https://code.haverbeke.berlin/marijn/style-mod#documentation)-style
+  set of CSS properties (which define the styling for those tags).
+  
+  The CSS rules created for a highlighter will be emitted in the
+  order of the spec's properties. That means that for elements that
+  have multiple tags associated with them, styles defined further
+  down in the list will have a higher CSS precedence than styles
+  defined earlier.
+  */
+  static define(t, e) {
+    return new G(t, e || {});
+  }
+}
+const Y = /* @__PURE__ */ v.define(), Vt = /* @__PURE__ */ v.define({
+  combine(n) {
+    return n.length ? [n[0]] : null;
+  }
+});
+function U(n) {
+  let t = n.facet(Y);
+  return t.length ? t : n.facet(Vt);
+}
+function vn(n, t) {
+  let e = [Re], r;
+  return n instanceof G && (n.module && e.push(b.styleModule.of(n.module)), r = n.themeType), t?.fallback ? e.push(Vt.of(n)) : r ? e.push(Y.computeN([b.darkTheme], (s) => s.facet(b.darkTheme) == (r == "dark") ? [n] : [])) : e.push(Y.of(n)), e;
+}
+function Tn(n, t, e) {
+  let r = U(n), s = null;
+  if (r) {
+    for (let i of r)
+      if (!i.scope || e && i.scope(e)) {
+        let o = i.style(t);
+        o && (s = s ? s + " " + o : o);
+      }
+  }
+  return s;
+}
+class Ne {
+  constructor(t) {
+    this.markCache = /* @__PURE__ */ Object.create(null), this.tree = m(t.state), this.decorations = this.buildDeco(t, U(t.state)), this.decoratedTo = t.viewport.to;
+  }
+  update(t) {
+    let e = m(t.state), r = U(t.state), s = r != U(t.startState), { viewport: i } = t.view, o = t.changes.mapPos(this.decoratedTo, 1);
+    e.length < i.to && !s && e.type == this.tree.type && o >= i.to ? (this.decorations = this.decorations.map(t.changes), this.decoratedTo = o) : (e != this.tree || t.viewportChanged || s) && (this.tree = e, this.decorations = this.buildDeco(t.view, r), this.decoratedTo = i.to);
+  }
+  buildDeco(t, e) {
+    if (!e || !this.tree.length)
+      return p.none;
+    let r = new nt();
+    for (let { from: s, to: i } of t.visibleRanges)
+      se(this.tree, e, (o, a, l) => {
+        r.add(o, a, this.markCache[l] || (this.markCache[l] = p.mark({ class: l })));
+      }, s, i);
+    return r.finish();
+  }
+}
+const Re = /* @__PURE__ */ Pt.high(/* @__PURE__ */ R.fromClass(Ne, {
+  decorations: (n) => n.decorations
+})), xn = /* @__PURE__ */ G.define([
+  {
+    tag: u.meta,
+    color: "#404740"
+  },
+  {
+    tag: u.link,
+    textDecoration: "underline"
+  },
+  {
+    tag: u.heading,
+    textDecoration: "underline",
+    fontWeight: "bold"
+  },
+  {
+    tag: u.emphasis,
+    fontStyle: "italic"
+  },
+  {
+    tag: u.strong,
+    fontWeight: "bold"
+  },
+  {
+    tag: u.strikethrough,
+    textDecoration: "line-through"
+  },
+  {
+    tag: u.keyword,
+    color: "#708"
+  },
+  {
+    tag: [u.atom, u.bool, u.url, u.contentSeparator, u.labelName],
+    color: "#219"
+  },
+  {
+    tag: [u.literal, u.inserted],
+    color: "#164"
+  },
+  {
+    tag: [u.string, u.deleted],
+    color: "#a11"
+  },
+  {
+    tag: [u.regexp, u.escape, /* @__PURE__ */ u.special(u.string)],
+    color: "#e40"
+  },
+  {
+    tag: /* @__PURE__ */ u.definition(u.variableName),
+    color: "#00f"
+  },
+  {
+    tag: /* @__PURE__ */ u.local(u.variableName),
+    color: "#30a"
+  },
+  {
+    tag: [u.typeName, u.namespace],
+    color: "#085"
+  },
+  {
+    tag: u.className,
+    color: "#167"
+  },
+  {
+    tag: [/* @__PURE__ */ u.special(u.variableName), u.macroName],
+    color: "#256"
+  },
+  {
+    tag: /* @__PURE__ */ u.definition(u.propertyName),
+    color: "#00c"
+  },
+  {
+    tag: u.comment,
+    color: "#940"
+  },
+  {
+    tag: u.invalid,
+    color: "#f00"
+  }
+]), Ee = /* @__PURE__ */ b.baseTheme({
+  "&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
+  "&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
+}), $t = 1e4, jt = "()[]{}", zt = /* @__PURE__ */ v.define({
+  combine(n) {
+    return Ct(n, {
+      afterCursor: !0,
+      brackets: jt,
+      maxScanDistance: $t,
+      renderMatch: Ue
+    });
+  }
+}), Fe = /* @__PURE__ */ p.mark({ class: "cm-matchingBracket" }), We = /* @__PURE__ */ p.mark({ class: "cm-nonmatchingBracket" });
+function Ue(n) {
+  let t = [], e = n.matched ? Fe : We;
+  return t.push(e.range(n.start.from, n.start.to)), n.end && t.push(e.range(n.end.from, n.end.to)), t;
+}
+function mt(n) {
+  let t = [], e = n.facet(zt);
+  for (let r of n.selection.ranges) {
+    if (!r.empty)
+      continue;
+    let s = F(n, r.head, -1, e) || r.head > 0 && F(n, r.head - 1, 1, e) || e.afterCursor && (F(n, r.head, 1, e) || r.head < n.doc.length && F(n, r.head + 1, -1, e));
+    s && (t = t.concat(e.renderMatch(s, n)));
+  }
+  return p.set(t, !0);
+}
+const He = /* @__PURE__ */ R.fromClass(class {
+  constructor(n) {
+    this.paused = !1, this.decorations = mt(n.state);
+  }
+  update(n) {
+    (n.docChanged || n.selectionSet || this.paused) && (n.view.composing ? (this.decorations = this.decorations.map(n.changes), this.paused = !0) : (this.decorations = mt(n.state), this.paused = !1));
+  }
+}, {
+  decorations: (n) => n.decorations
+}), Ve = [
+  He,
+  Ee
+];
+function Sn(n = {}) {
+  return [zt.of(n), Ve];
+}
+const $e = /* @__PURE__ */ new y();
+function Z(n, t, e) {
+  let r = n.prop(t < 0 ? y.openedBy : y.closedBy);
+  if (r)
+    return r;
+  if (n.name.length == 1) {
+    let s = e.indexOf(n.name);
+    if (s > -1 && s % 2 == (t < 0 ? 1 : 0))
+      return [e[s + t]];
+  }
+  return null;
+}
+function tt(n) {
+  let t = n.type.prop($e);
+  return t ? t(n.node) : n;
+}
+function F(n, t, e, r = {}) {
+  let s = r.maxScanDistance || $t, i = r.brackets || jt, o = m(n), a = o.resolveInner(t, e);
+  for (let l = a; l; l = l.parent) {
+    let h = Z(l.type, e, i);
+    if (h && l.from < l.to) {
+      let f = tt(l);
+      if (f && (e > 0 ? t >= f.from && t < f.to : t > f.from && t <= f.to))
+        return je(n, t, e, l, f, h, i);
+    }
+  }
+  return ze(n, t, e, o, a.type, s, i);
+}
+function je(n, t, e, r, s, i, o) {
+  let a = r.parent, l = { from: s.from, to: s.to }, h = 0, f = a?.cursor();
+  if (f && (e < 0 ? f.childBefore(r.from) : f.childAfter(r.to)))
+    do
+      if (e < 0 ? f.to <= r.from : f.from >= r.to) {
+        if (h == 0 && i.indexOf(f.type.name) > -1 && f.from < f.to) {
+          let c = tt(f);
+          return { start: l, end: c ? { from: c.from, to: c.to } : void 0, matched: !0 };
+        } else if (Z(f.type, e, o))
+          h++;
+        else if (Z(f.type, -e, o)) {
+          if (h == 0) {
+            let c = tt(f);
+            return {
+              start: l,
+              end: c && c.from < c.to ? { from: c.from, to: c.to } : void 0,
+              matched: !1
+            };
+          }
+          h--;
+        }
+      }
+    while (e < 0 ? f.prevSibling() : f.nextSibling());
+  return { start: l, matched: !1 };
+}
+function ze(n, t, e, r, s, i, o) {
+  if (e < 0 ? !t : t == n.doc.length)
+    return null;
+  let a = e < 0 ? n.sliceDoc(t - 1, t) : n.sliceDoc(t, t + 1), l = o.indexOf(a);
+  if (l < 0 || l % 2 == 0 != e > 0)
+    return null;
+  let h = { from: e < 0 ? t - 1 : t, to: e > 0 ? t + 1 : t }, f = n.doc.iterRange(t, e > 0 ? n.doc.length : 0), c = 0;
+  for (let w = 0; !f.next().done && w <= i; ) {
+    let k = f.value;
+    e < 0 && (w += k.length);
+    let P = t + w * e;
+    for (let C = e > 0 ? 0 : k.length - 1, te = e > 0 ? k.length : -1; C != te; C += e) {
+      let q = o.indexOf(k[C]);
+      if (!(q < 0 || r.resolveInner(P + C, 1).type != s))
+        if (q % 2 == 0 == e > 0)
+          c++;
+        else {
+          if (c == 1)
+            return { start: h, end: { from: P + C, to: P + C + 1 }, matched: q >> 1 == l >> 1 };
+          c--;
+        }
+    }
+    e > 0 && (w += k.length);
+  }
+  return f.done ? { start: h, matched: !1 } : null;
+}
+function kt(n, t, e, r = 0, s = 0) {
+  t == null && (t = n.search(/[^\s\u00a0]/), t == -1 && (t = n.length));
+  let i = s;
+  for (let o = r; o < t; o++)
+    n.charCodeAt(o) == 9 ? i += e - i % e : i++;
+  return i;
+}
+class Gt {
+  /**
+  Create a stream.
+  */
+  constructor(t, e, r, s) {
+    this.string = t, this.tabSize = e, this.indentUnit = r, this.overrideIndent = s, this.pos = 0, this.start = 0, this.lastColumnPos = 0, this.lastColumnValue = 0;
+  }
+  /**
+  True if we are at the end of the line.
+  */
+  eol() {
+    return this.pos >= this.string.length;
+  }
+  /**
+  True if we are at the start of the line.
+  */
+  sol() {
+    return this.pos == 0;
+  }
+  /**
+  Get the next code unit after the current position, or undefined
+  if we're at the end of the line.
+  */
+  peek() {
+    return this.string.charAt(this.pos) || void 0;
+  }
+  /**
+  Read the next code unit and advance `this.pos`.
+  */
+  next() {
+    if (this.pos < this.string.length)
+      return this.string.charAt(this.pos++);
+  }
+  /**
+  Match the next character against the given string, regular
+  expression, or predicate. Consume and return it if it matches.
+  */
+  eat(t) {
+    let e = this.string.charAt(this.pos), r;
+    if (typeof t == "string" ? r = e == t : r = e && (t instanceof RegExp ? t.test(e) : t(e)), r)
+      return ++this.pos, e;
+  }
+  /**
+  Continue matching characters that match the given string,
+  regular expression, or predicate function. Return true if any
+  characters were consumed.
+  */
+  eatWhile(t) {
+    let e = this.pos;
+    for (; this.eat(t); )
+      ;
+    return this.pos > e;
+  }
+  /**
+  Consume whitespace ahead of `this.pos`. Return true if any was
+  found.
+  */
+  eatSpace() {
+    let t = this.pos;
+    for (; /[\s\u00a0]/.test(this.string.charAt(this.pos)); )
+      ++this.pos;
+    return this.pos > t;
+  }
+  /**
+  Move to the end of the line.
+  */
+  skipToEnd() {
+    this.pos = this.string.length;
+  }
+  /**
+  Move to directly before the given character, if found on the
+  current line.
+  */
+  skipTo(t) {
+    let e = this.string.indexOf(t, this.pos);
+    if (e > -1)
+      return this.pos = e, !0;
+  }
+  /**
+  Move back `n` characters.
+  */
+  backUp(t) {
+    this.pos -= t;
+  }
+  /**
+  Get the column position at `this.pos`.
+  */
+  column() {
+    return this.lastColumnPos < this.start && (this.lastColumnValue = kt(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue), this.lastColumnPos = this.start), this.lastColumnValue;
+  }
+  /**
+  Get the indentation column of the current line.
+  */
+  indentation() {
+    var t;
+    return (t = this.overrideIndent) !== null && t !== void 0 ? t : kt(this.string, null, this.tabSize);
+  }
+  /**
+  Match the input against the given string or regular expression
+  (which should start with a `^`). Return true or the regexp match
+  if it matches.
+  
+  Unless `consume` is set to `false`, this will move `this.pos`
+  past the matched text.
+  
+  When matching a string `caseInsensitive` can be set to true to
+  make the match case-insensitive.
+  */
+  match(t, e, r) {
+    if (typeof t == "string") {
+      let s = (o) => r ? o.toLowerCase() : o, i = this.string.substr(this.pos, t.length);
+      return s(i) == s(t) ? (e !== !1 && (this.pos += t.length), !0) : null;
+    } else {
+      let s = this.string.slice(this.pos).match(t);
+      return s && s.index > 0 ? null : (s && e !== !1 && (this.pos += s[0].length), s);
+    }
+  }
+  /**
+  Get the current token.
+  */
+  current() {
+    return this.string.slice(this.start, this.pos);
+  }
+}
+function Ge(n) {
+  return {
+    name: n.name || "",
+    token: n.token,
+    blankLine: n.blankLine || (() => {
+    }),
+    startState: n.startState || (() => !0),
+    copyState: n.copyState || qe,
+    indent: n.indent || (() => null),
+    languageData: n.languageData || {},
+    tokenTable: n.tokenTable || ht,
+    mergeTokens: n.mergeTokens !== !1
+  };
+}
+function qe(n) {
+  if (typeof n != "object")
+    return n;
+  let t = {};
+  for (let e in n) {
+    let r = n[e];
+    t[e] = r instanceof Array ? r.slice() : r;
+  }
+  return t;
+}
+const bt = /* @__PURE__ */ new WeakMap();
+class qt extends d {
+  constructor(t) {
+    let e = It(t.languageData), r = Ge(t), s, i = new class extends Tt {
+      createParse(o, a, l) {
+        return new _e(s, o, a, l);
+      }
+    }();
+    super(e, i, [], t.name), this.topNode = Xe(e, this), s = this, this.streamParser = r, this.stateAfter = new y({ perNode: !0 }), this.tokenTable = t.tokenTable ? new Qt(r.tokenTable) : Qe;
+  }
+  /**
+  Define a stream language.
+  */
+  static define(t) {
+    return new qt(t);
+  }
+  /**
+  @internal
+  */
+  getIndent(t) {
+    let e, { overrideIndentation: r } = t.options;
+    r && (e = bt.get(t.state), e != null && e < t.pos - 1e4 && (e = void 0));
+    let s = at(this, t.node.tree, t.node.from, t.node.from, e ?? t.pos), i, o;
+    if (s ? (o = s.state, i = s.pos + 1) : (o = this.streamParser.startState(t.unit), i = t.node.from), t.pos - i > 1e4)
+      return null;
+    for (; i < t.pos; ) {
+      let l = t.state.doc.lineAt(i), h = Math.min(t.pos, l.to);
+      if (l.length) {
+        let f = r ? r(l.from) : -1, c = new Gt(l.text, t.state.tabSize, t.unit, f < 0 ? void 0 : f);
+        for (; c.pos < h - l.from; )
+          _t(this.streamParser.token, c, o);
+      } else
+        this.streamParser.blankLine(o, t.unit);
+      if (h == t.pos)
+        break;
+      i = l.to + 1;
+    }
+    let a = t.lineAt(t.pos);
+    return r && e == null && bt.set(t.state, a.from), this.streamParser.indent(o, /^\s*(.*)/.exec(a.text)[1], t);
+  }
+  get allowsNesting() {
+    return !1;
+  }
+}
+function at(n, t, e, r, s) {
+  let i = e >= r && e + t.length <= s && t.prop(n.stateAfter);
+  if (i)
+    return { state: n.streamParser.copyState(i), pos: e + t.length };
+  for (let o = t.children.length - 1; o >= 0; o--) {
+    let a = t.children[o], l = e + t.positions[o], h = a instanceof g && l < s && at(n, a, l, r, s);
+    if (h)
+      return h;
+  }
+  return null;
+}
+function Jt(n, t, e, r, s) {
+  if (s && e <= 0 && r >= t.length)
+    return t;
+  !s && e == 0 && t.type == n.topNode && (s = !0);
+  for (let i = t.children.length - 1; i >= 0; i--) {
+    let o = t.positions[i], a = t.children[i], l;
+    if (o < r && a instanceof g) {
+      if (!(l = Jt(n, a, e - o, r - o, s)))
+        break;
+      return s ? new g(t.type, t.children.slice(0, i).concat(l), t.positions.slice(0, i + 1), o + l.length) : l;
+    }
+  }
+  return null;
+}
+function Je(n, t, e, r, s) {
+  for (let i of t) {
+    let o = i.from + (i.openStart ? 25 : 0), a = i.to - (i.openEnd ? 25 : 0), l = o <= e && a > e && at(n, i.tree, 0 - i.offset, e, a), h;
+    if (l && l.pos <= r && (h = Jt(n, i.tree, e + i.offset, l.pos + i.offset, !1)))
+      return { state: l.state, tree: h };
+  }
+  return { state: n.streamParser.startState(s ? V(s) : 4), tree: g.empty };
+}
+class _e {
+  constructor(t, e, r, s) {
+    this.lang = t, this.input = e, this.fragments = r, this.ranges = s, this.stoppedAt = null, this.chunks = [], this.chunkPos = [], this.chunk = [], this.chunkReused = void 0, this.rangeIndex = 0, this.to = s[s.length - 1].to;
+    let i = A.get(), o = s[0].from, { state: a, tree: l } = Je(t, r, o, this.to, i?.state);
+    this.state = a, this.parsedPos = this.chunkStart = o + l.length;
+    for (let h = 0; h < l.children.length; h++)
+      this.chunks.push(l.children[h]), this.chunkPos.push(l.positions[h]);
+    i && this.parsedPos < i.viewport.from - 1e5 && s.some((h) => h.from <= i.viewport.from && h.to >= i.viewport.from) && (this.state = this.lang.streamParser.startState(V(i.state)), i.skipUntilInView(this.parsedPos, i.viewport.from), this.parsedPos = i.viewport.from), this.moveRangeIndex();
+  }
+  advance() {
+    let t = A.get(), e = this.stoppedAt == null ? this.to : Math.min(this.to, this.stoppedAt), r = Math.min(
+      e,
+      this.chunkStart + 512
+      /* C.ChunkSize */
+    );
+    for (t && (r = Math.min(r, t.viewport.to)); this.parsedPos < r; )
+      this.parseLine(t);
+    return this.chunkStart < this.parsedPos && this.finishChunk(), this.parsedPos >= e ? this.finish() : t && this.parsedPos >= t.viewport.to ? (t.skipUntilInView(this.parsedPos, e), this.finish()) : null;
+  }
+  stopAt(t) {
+    this.stoppedAt = t;
+  }
+  lineAfter(t) {
+    let e = this.input.chunk(t);
+    if (this.input.lineChunks)
+      e == `
+` && (e = "");
+    else {
+      let r = e.indexOf(`
+`);
+      r > -1 && (e = e.slice(0, r));
+    }
+    return t + e.length <= this.to ? e : e.slice(0, this.to - t);
+  }
+  nextLine() {
+    let t = this.parsedPos, e = this.lineAfter(t), r = t + e.length;
+    for (let s = this.rangeIndex; ; ) {
+      let i = this.ranges[s].to;
+      if (i >= r || (e = e.slice(0, i - (r - e.length)), s++, s == this.ranges.length))
+        break;
+      let o = this.ranges[s].from, a = this.lineAfter(o);
+      e += a, r = o + a.length;
+    }
+    return { line: e, end: r };
+  }
+  skipGapsTo(t, e, r) {
+    for (; ; ) {
+      let s = this.ranges[this.rangeIndex].to, i = t + e;
+      if (r > 0 ? s > i : s >= i)
+        break;
+      let o = this.ranges[++this.rangeIndex].from;
+      e += o - s;
+    }
+    return e;
+  }
+  moveRangeIndex() {
+    for (; this.ranges[this.rangeIndex].to < this.parsedPos; )
+      this.rangeIndex++;
+  }
+  emitToken(t, e, r, s) {
+    let i = 4;
+    if (this.ranges.length > 1) {
+      s = this.skipGapsTo(e, s, 1), e += s;
+      let a = this.chunk.length;
+      s = this.skipGapsTo(r, s, -1), r += s, i += this.chunk.length - a;
+    }
+    let o = this.chunk.length - 4;
+    return this.lang.streamParser.mergeTokens && i == 4 && o >= 0 && this.chunk[o] == t && this.chunk[o + 2] == e ? this.chunk[o + 2] = r : this.chunk.push(t, e, r, i), s;
+  }
+  parseLine(t) {
+    let { line: e, end: r } = this.nextLine(), s = 0, { streamParser: i } = this.lang, o = new Gt(e, t ? t.state.tabSize : 4, t ? V(t.state) : 2);
+    if (o.eol())
+      i.blankLine(this.state, o.indentUnit);
+    else
+      for (; !o.eol(); ) {
+        let a = _t(i.token, o, this.state);
+        if (a && (s = this.emitToken(this.lang.tokenTable.resolve(a), this.parsedPos + o.start, this.parsedPos + o.pos, s)), o.start > 1e4)
+          break;
+      }
+    this.parsedPos = r, this.moveRangeIndex(), this.parsedPos < this.to && this.parsedPos++;
+  }
+  finishChunk() {
+    let t = g.build({
+      buffer: this.chunk,
+      start: this.chunkStart,
+      length: this.parsedPos - this.chunkStart,
+      nodeSet: Ke,
+      topID: 0,
+      maxBufferLength: 512,
+      reused: this.chunkReused
+    });
+    t = new g(t.type, t.children, t.positions, t.length, [[this.lang.stateAfter, this.lang.streamParser.copyState(this.state)]]), this.chunks.push(t), this.chunkPos.push(this.chunkStart - this.ranges[0].from), this.chunk = [], this.chunkReused = void 0, this.chunkStart = this.parsedPos;
+  }
+  finish() {
+    return new g(this.lang.topNode, this.chunks, this.chunkPos, this.parsedPos - this.ranges[0].from).balance();
+  }
+}
+function _t(n, t, e) {
+  t.start = t.pos;
+  for (let r = 0; r < 10; r++) {
+    let s = n(t, e);
+    if (t.pos > t.start)
+      return s;
+  }
+  throw new Error("Stream parser failed to advance stream.");
+}
+const ht = /* @__PURE__ */ Object.create(null), N = [j.none], Ke = /* @__PURE__ */ new ne(N), wt = [], yt = /* @__PURE__ */ Object.create(null), Kt = /* @__PURE__ */ Object.create(null);
+for (let [n, t] of [
+  ["variable", "variableName"],
+  ["variable-2", "variableName.special"],
+  ["string-2", "string.special"],
+  ["def", "variableName.definition"],
+  ["tag", "tagName"],
+  ["attribute", "attributeName"],
+  ["type", "typeName"],
+  ["builtin", "variableName.standard"],
+  ["qualifier", "modifier"],
+  ["error", "invalid"],
+  ["header", "heading"],
+  ["property", "propertyName"]
+])
+  Kt[n] = /* @__PURE__ */ Xt(ht, t);
+class Qt {
+  constructor(t) {
+    this.extra = t, this.table = Object.assign(/* @__PURE__ */ Object.create(null), Kt);
+  }
+  resolve(t) {
+    return t ? this.table[t] || (this.table[t] = Xt(this.extra, t)) : 0;
+  }
+}
+const Qe = /* @__PURE__ */ new Qt(ht);
+function Q(n, t) {
+  wt.indexOf(n) > -1 || (wt.push(n), console.warn(t));
+}
+function Xt(n, t) {
+  let e = [];
+  for (let a of t.split(" ")) {
+    let l = [];
+    for (let h of a.split(".")) {
+      let f = n[h] || u[h];
+      f ? typeof f == "function" ? l.length ? l = l.map(f) : Q(h, `Modifier ${h} used at start of tag`) : l.length ? Q(h, `Tag ${h} used as modifier`) : l = Array.isArray(f) ? f : [f] : Q(h, `Unknown highlighting tag ${h}`);
+    }
+    for (let h of l)
+      e.push(h);
+  }
+  if (!e.length)
+    return 0;
+  let r = t.replace(/ /g, "_"), s = r + " " + e.map((a) => a.id), i = yt[s];
+  if (i)
+    return i.id;
+  let o = yt[s] = j.define({
+    id: N.length,
+    name: r,
+    props: [re({ [r]: e })]
+  });
+  return N.push(o), o.id;
+}
+function Xe(n, t) {
+  let e = j.define({ id: N.length, name: "Document", props: [
+    S.add(() => n),
+    Rt.add(() => (r) => t.getIndent(r))
+  ], top: !0 });
+  return N.push(e), e;
+}
+function Yt(n) {
+  return n.length <= 4096 && /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\ufb50-\ufdff]/.test(n);
+}
+function Zt(n) {
+  for (let t = n.iter(); !t.next().done; )
+    if (Yt(t.value))
+      return !0;
+  return !1;
+}
+function Ye(n) {
+  let t = !1;
+  return n.iterChanges((e, r, s, i, o) => {
+    !t && Zt(o) && (t = !0);
+  }), t;
+}
+const et = /* @__PURE__ */ v.define({ combine: (n) => n.some((t) => t) });
+function Pn(n = {}) {
+  let t = [Ze];
+  return n.alwaysIsolate && t.push(et.of(!0)), t;
+}
+const Ze = /* @__PURE__ */ R.fromClass(class {
+  constructor(n) {
+    this.always = n.state.facet(et) || n.textDirection != H.LTR || n.state.facet(b.perLineTextDirection), this.hasRTL = !this.always && Zt(n.state.doc), this.tree = m(n.state), this.decorations = this.always || this.hasRTL ? vt(n, this.tree, this.always) : p.none;
+  }
+  update(n) {
+    let t = n.state.facet(et) || n.view.textDirection != H.LTR || n.state.facet(b.perLineTextDirection);
+    if (!t && !this.hasRTL && Ye(n.changes) && (this.hasRTL = !0), !t && !this.hasRTL)
+      return;
+    let e = m(n.state);
+    (t != this.always || e != this.tree || n.docChanged || n.viewportChanged) && (this.tree = e, this.always = t, this.decorations = vt(n.view, e, t));
+  }
+}, {
+  provide: (n) => {
+    function t(e) {
+      var r, s;
+      return (s = (r = e.plugin(n)) === null || r === void 0 ? void 0 : r.decorations) !== null && s !== void 0 ? s : p.none;
+    }
+    return [
+      b.outerDecorations.of(t),
+      Pt.lowest(b.bidiIsolatedRanges.of(t))
+    ];
+  }
+});
+function vt(n, t, e) {
+  let r = new nt(), s = n.visibleRanges;
+  e || (s = tn(s, n.state.doc));
+  for (let { from: i, to: o } of s)
+    t.iterate({
+      enter: (a) => {
+        let l = a.type.prop(y.isolate);
+        l && r.add(a.from, a.to, en[l]);
+      },
+      from: i,
+      to: o
+    });
+  return r.finish();
+}
+function tn(n, t) {
+  let e = t.iter(), r = 0, s = [], i = null;
+  for (let { from: o, to: a } of n)
+    if (!(i && i.to > o && (o = i.to, o >= a)))
+      for (r + e.value.length < o && (e.next(o - (r + e.value.length)), r = o); ; ) {
+        let l = r, h = r + e.value.length;
+        if (!e.lineBreak && Yt(e.value) && (i && i.to > l - 10 ? i.to = Math.min(a, h) : s.push(i = { from: l, to: Math.min(a, h) })), h >= a)
+          break;
+        r = h, e.next();
+      }
+  return s;
+}
+const en = {
+  rtl: /* @__PURE__ */ p.mark({ class: "cm-iso", inclusive: !0, attributes: { dir: "rtl" }, bidiIsolate: H.RTL }),
+  ltr: /* @__PURE__ */ p.mark({ class: "cm-iso", inclusive: !0, attributes: { dir: "ltr" }, bidiIsolate: H.LTR }),
+  auto: /* @__PURE__ */ p.mark({ class: "cm-iso", inclusive: !0, attributes: { dir: "auto" }, bidiIsolate: null })
+};
+export {
+  ue as DocInput,
+  G as HighlightStyle,
+  rt as IndentContext,
+  X as LRLanguage,
+  d as Language,
+  Ot as LanguageDescription,
+  fn as LanguageSupport,
+  A as ParseContext,
+  qt as StreamLanguage,
+  Gt as StringStream,
+  st as TreeIndentContext,
+  Pn as bidiIsolates,
+  Sn as bracketMatching,
+  $e as bracketMatchingHandle,
+  Ut as codeFolding,
+  pn as continuedIndent,
+  xn as defaultHighlightStyle,
+  It as defineLanguageFacet,
+  cn as delimitedIndent,
+  fe as ensureSyntaxTree,
+  dn as flatIndent,
+  Ae as foldAll,
+  Pe as foldCode,
+  E as foldEffect,
+  yn as foldGutter,
+  mn as foldInside,
+  wn as foldKeymap,
+  ve as foldNodeProp,
+  ye as foldService,
+  x as foldState,
+  B as foldable,
+  kn as foldedRanges,
+  ln as forceParsing,
+  V as getIndentUnit,
+  Nt as getIndentation,
+  Tn as highlightingFor,
+  Rt as indentNodeProp,
+  gn as indentOnInput,
+  un as indentRange,
+  ce as indentService,
+  Lt as indentString,
+  Bt as indentUnit,
+  T as language,
+  S as languageDataProp,
+  F as matchBrackets,
+  he as sublanguageProp,
+  vn as syntaxHighlighting,
+  an as syntaxParserRunning,
+  m as syntaxTree,
+  on as syntaxTreeAvailable,
+  bn as toggleFold,
+  Ie as unfoldAll,
+  Ce as unfoldCode,
+  D as unfoldEffect
+};