@arach/arc 0.4.5 → 0.6.0

package/lib/index-CvsZLy9v.js

@@ -0,0 +1,2344 @@
+const ct = 1024;
+let Je = 0;
+class H {
+  constructor(e, t) {
+    this.from = e, this.to = t;
+  }
+}
+class A {
+  /**
+  Create a new node prop type.
+  */
+  constructor(e = {}) {
+    this.id = Je++, this.perNode = !!e.perNode, this.deserialize = e.deserialize || (() => {
+      throw new Error("This node type doesn't define a deserialize function");
+    }), this.combine = e.combine || null;
+  }
+  /**
+  This is meant to be used with
+  [`NodeSet.extend`](#common.NodeSet.extend) or
+  [`LRParser.configure`](#lr.ParserConfig.props) to compute
+  prop values for each node type in the set. Takes a [match
+  object](#common.NodeType^match) or function that returns undefined
+  if the node type doesn't get this prop, and the prop's value if
+  it does.
+  */
+  add(e) {
+    if (this.perNode)
+      throw new RangeError("Can't add per-node props to node types");
+    return typeof e != "function" && (e = L.match(e)), (t) => {
+      let r = e(t);
+      return r === void 0 ? null : [this, r];
+    };
+  }
+}
+A.closedBy = new A({ deserialize: (l) => l.split(" ") });
+A.openedBy = new A({ deserialize: (l) => l.split(" ") });
+A.group = new A({ deserialize: (l) => l.split(" ") });
+A.isolate = new A({ deserialize: (l) => {
+  if (l && l != "rtl" && l != "ltr" && l != "auto")
+    throw new RangeError("Invalid value for isolate: " + l);
+  return l || "auto";
+} });
+A.contextHash = new A({ perNode: !0 });
+A.lookAhead = new A({ perNode: !0 });
+A.mounted = new A({ perNode: !0 });
+class re {
+  constructor(e, t, r, i = !1) {
+    this.tree = e, this.overlay = t, this.parser = r, this.bracketed = i;
+  }
+  /**
+  @internal
+  */
+  static get(e) {
+    return e && e.props && e.props[A.mounted.id];
+  }
+}
+const Ke = /* @__PURE__ */ Object.create(null);
+class L {
+  /**
+  @internal
+  */
+  constructor(e, t, r, i = 0) {
+    this.name = e, this.props = t, this.id = r, this.flags = i;
+  }
+  /**
+  Define a node type.
+  */
+  static define(e) {
+    let t = e.props && e.props.length ? /* @__PURE__ */ Object.create(null) : Ke, r = (e.top ? 1 : 0) | (e.skipped ? 2 : 0) | (e.error ? 4 : 0) | (e.name == null ? 8 : 0), i = new L(e.name || "", t, e.id, r);
+    if (e.props) {
+      for (let n of e.props)
+        if (Array.isArray(n) || (n = n(i)), n) {
+          if (n[0].perNode)
+            throw new RangeError("Can't store a per-node prop on a node type");
+          t[n[0].id] = n[1];
+        }
+    }
+    return i;
+  }
+  /**
+  Retrieves a node prop for this type. Will return `undefined` if
+  the prop isn't present on this node.
+  */
+  prop(e) {
+    return this.props[e.id];
+  }
+  /**
+  True when this is the top node of a grammar.
+  */
+  get isTop() {
+    return (this.flags & 1) > 0;
+  }
+  /**
+  True when this node is produced by a skip rule.
+  */
+  get isSkipped() {
+    return (this.flags & 2) > 0;
+  }
+  /**
+  Indicates whether this is an error node.
+  */
+  get isError() {
+    return (this.flags & 4) > 0;
+  }
+  /**
+  When true, this node type doesn't correspond to a user-declared
+  named node, for example because it is used to cache repetition.
+  */
+  get isAnonymous() {
+    return (this.flags & 8) > 0;
+  }
+  /**
+  Returns true when this node's name or one of its
+  [groups](#common.NodeProp^group) matches the given string.
+  */
+  is(e) {
+    if (typeof e == "string") {
+      if (this.name == e)
+        return !0;
+      let t = this.prop(A.group);
+      return t ? t.indexOf(e) > -1 : !1;
+    }
+    return this.id == e;
+  }
+  /**
+  Create a function from node types to arbitrary values by
+  specifying an object whose property names are node or
+  [group](#common.NodeProp^group) names. Often useful with
+  [`NodeProp.add`](#common.NodeProp.add). You can put multiple
+  names, separated by spaces, in a single property name to map
+  multiple node names to a single value.
+  */
+  static match(e) {
+    let t = /* @__PURE__ */ Object.create(null);
+    for (let r in e)
+      for (let i of r.split(" "))
+        t[i] = e[r];
+    return (r) => {
+      for (let i = r.prop(A.group), n = -1; n < (i ? i.length : 0); n++) {
+        let s = t[n < 0 ? r.name : i[n]];
+        if (s)
+          return s;
+      }
+    };
+  }
+}
+L.none = new L(
+  "",
+  /* @__PURE__ */ Object.create(null),
+  0,
+  8
+  /* NodeFlag.Anonymous */
+);
+class je {
+  /**
+  Create a set with the given types. The `id` property of each
+  type should correspond to its position within the array.
+  */
+  constructor(e) {
+    this.types = e;
+    for (let t = 0; t < e.length; t++)
+      if (e[t].id != t)
+        throw new RangeError("Node type ids should correspond to array positions when creating a node set");
+  }
+  /**
+  Create a copy of this set with some node properties added. The
+  arguments to this method can be created with
+  [`NodeProp.add`](#common.NodeProp.add).
+  */
+  extend(...e) {
+    let t = [];
+    for (let r of this.types) {
+      let i = null;
+      for (let n of e) {
+        let s = n(r);
+        if (s) {
+          i || (i = Object.assign({}, r.props));
+          let o = s[1], a = s[0];
+          a.combine && a.id in i && (o = a.combine(i[a.id], o)), i[a.id] = o;
+        }
+      }
+      t.push(i ? new L(r.name, i, r.id, r.flags) : r);
+    }
+    return new je(t);
+  }
+}
+const he = /* @__PURE__ */ new WeakMap(), Ne = /* @__PURE__ */ new WeakMap();
+var v;
+(function(l) {
+  l[l.ExcludeBuffers = 1] = "ExcludeBuffers", l[l.IncludeAnonymous = 2] = "IncludeAnonymous", l[l.IgnoreMounts = 4] = "IgnoreMounts", l[l.IgnoreOverlays = 8] = "IgnoreOverlays", l[l.EnterBracketed = 16] = "EnterBracketed";
+})(v || (v = {}));
+class R {
+  /**
+  Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+  */
+  constructor(e, t, r, i, n) {
+    if (this.type = e, this.children = t, this.positions = r, this.length = i, this.props = null, n && n.length) {
+      this.props = /* @__PURE__ */ Object.create(null);
+      for (let [s, o] of n)
+        this.props[typeof s == "number" ? s : s.id] = o;
+    }
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let e = re.get(this);
+    if (e && !e.overlay)
+      return e.tree.toString();
+    let t = "";
+    for (let r of this.children) {
+      let i = r.toString();
+      i && (t && (t += ","), t += i);
+    }
+    return this.type.name ? (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (t.length ? "(" + t + ")" : "") : t;
+  }
+  /**
+  Get a [tree cursor](#common.TreeCursor) positioned at the top of
+  the tree. Mode can be used to [control](#common.IterMode) which
+  nodes the cursor visits.
+  */
+  cursor(e = 0) {
+    return new ge(this.topNode, e);
+  }
+  /**
+  Get a [tree cursor](#common.TreeCursor) pointing into this tree
+  at the given position and side (see
+  [`moveTo`](#common.TreeCursor.moveTo).
+  */
+  cursorAt(e, t = 0, r = 0) {
+    let i = he.get(this) || this.topNode, n = new ge(i);
+    return n.moveTo(e, t), he.set(this, n._tree), n;
+  }
+  /**
+  Get a [syntax node](#common.SyntaxNode) object for the top of the
+  tree.
+  */
+  get topNode() {
+    return new T(this, 0, 0, null);
+  }
+  /**
+  Get the [syntax node](#common.SyntaxNode) at the given position.
+  If `side` is -1, this will move into nodes that end at the
+  position. If 1, it'll move into nodes that start at the
+  position. With 0, it'll only enter nodes that cover the position
+  from both sides.
+  
+  Note that this will not enter
+  [overlays](#common.MountedTree.overlay), and you often want
+  [`resolveInner`](#common.Tree.resolveInner) instead.
+  */
+  resolve(e, t = 0) {
+    let r = se(he.get(this) || this.topNode, e, t, !1);
+    return he.set(this, r), r;
+  }
+  /**
+  Like [`resolve`](#common.Tree.resolve), but will enter
+  [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
+  pointing into the innermost overlaid tree at the given position
+  (with parent links going through all parent structure, including
+  the host trees).
+  */
+  resolveInner(e, t = 0) {
+    let r = se(Ne.get(this) || this.topNode, e, t, !0);
+    return Ne.set(this, r), r;
+  }
+  /**
+  In some situations, it can be useful to iterate through all
+  nodes around a position, including those in overlays that don't
+  directly cover the position. This method gives you an iterator
+  that will produce all nodes, from small to big, around the given
+  position.
+  */
+  resolveStack(e, t = 0) {
+    return Ge(this, e, t);
+  }
+  /**
+  Iterate over the tree and its children, calling `enter` for any
+  node that touches the `from`/`to` region (if given) before
+  running over such a node's children, and `leave` (if given) when
+  leaving the node. When `enter` returns `false`, that node will
+  not have its children iterated over (or `leave` called).
+  */
+  iterate(e) {
+    let { enter: t, leave: r, from: i = 0, to: n = this.length } = e, s = e.mode || 0, o = (s & v.IncludeAnonymous) > 0;
+    for (let a = this.cursor(s | v.IncludeAnonymous); ; ) {
+      let h = !1;
+      if (a.from <= n && a.to >= i && (!o && a.type.isAnonymous || t(a) !== !1)) {
+        if (a.firstChild())
+          continue;
+        h = !0;
+      }
+      for (; h && r && (o || !a.type.isAnonymous) && r(a), !a.nextSibling(); ) {
+        if (!a.parent())
+          return;
+        h = !0;
+      }
+    }
+  }
+  /**
+  Get the value of the given [node prop](#common.NodeProp) for this
+  node. Works with both per-node and per-type props.
+  */
+  prop(e) {
+    return e.perNode ? this.props ? this.props[e.id] : void 0 : this.type.prop(e);
+  }
+  /**
+  Returns the node's [per-node props](#common.NodeProp.perNode) in a
+  format that can be passed to the [`Tree`](#common.Tree)
+  constructor.
+  */
+  get propValues() {
+    let e = [];
+    if (this.props)
+      for (let t in this.props)
+        e.push([+t, this.props[t]]);
+    return e;
+  }
+  /**
+  Balance the direct children of this tree, producing a copy of
+  which may have children grouped into subtrees with type
+  [`NodeType.none`](#common.NodeType^none).
+  */
+  balance(e = {}) {
+    return this.children.length <= 8 ? this : Ae(L.none, this.children, this.positions, 0, this.children.length, 0, this.length, (t, r, i) => new R(this.type, t, r, i, this.propValues), e.makeTree || ((t, r, i) => new R(L.none, t, r, i)));
+  }
+  /**
+  Build a tree from a postfix-ordered buffer of node information,
+  or a cursor over such a buffer.
+  */
+  static build(e) {
+    return Qe(e);
+  }
+}
+R.empty = new R(L.none, [], [], 0);
+class we {
+  constructor(e, t) {
+    this.buffer = e, this.index = t;
+  }
+  get id() {
+    return this.buffer[this.index - 4];
+  }
+  get start() {
+    return this.buffer[this.index - 3];
+  }
+  get end() {
+    return this.buffer[this.index - 2];
+  }
+  get size() {
+    return this.buffer[this.index - 1];
+  }
+  get pos() {
+    return this.index;
+  }
+  next() {
+    this.index -= 4;
+  }
+  fork() {
+    return new we(this.buffer, this.index);
+  }
+}
+class X {
+  /**
+  Create a tree buffer.
+  */
+  constructor(e, t, r) {
+    this.buffer = e, this.length = t, this.set = r;
+  }
+  /**
+  @internal
+  */
+  get type() {
+    return L.none;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let e = [];
+    for (let t = 0; t < this.buffer.length; )
+      e.push(this.childString(t)), t = this.buffer[t + 3];
+    return e.join(",");
+  }
+  /**
+  @internal
+  */
+  childString(e) {
+    let t = this.buffer[e], r = this.buffer[e + 3], i = this.set.types[t], n = i.name;
+    if (/\W/.test(n) && !i.isError && (n = JSON.stringify(n)), e += 4, r == e)
+      return n;
+    let s = [];
+    for (; e < r; )
+      s.push(this.childString(e)), e = this.buffer[e + 3];
+    return n + "(" + s.join(",") + ")";
+  }
+  /**
+  @internal
+  */
+  findChild(e, t, r, i, n) {
+    let { buffer: s } = this, o = -1;
+    for (let a = e; a != t && !(Fe(n, i, s[a + 1], s[a + 2]) && (o = a, r > 0)); a = s[a + 3])
+      ;
+    return o;
+  }
+  /**
+  @internal
+  */
+  slice(e, t, r) {
+    let i = this.buffer, n = new Uint16Array(t - e), s = 0;
+    for (let o = e, a = 0; o < t; ) {
+      n[a++] = i[o++], n[a++] = i[o++] - r;
+      let h = n[a++] = i[o++] - r;
+      n[a++] = i[o++] - e, s = Math.max(s, h);
+    }
+    return new X(n, s, this.set);
+  }
+}
+function Fe(l, e, t, r) {
+  switch (l) {
+    case -2:
+      return t < e;
+    case -1:
+      return r >= e && t < e;
+    case 0:
+      return t < e && r > e;
+    case 1:
+      return t <= e && r > e;
+    case 2:
+      return r > e;
+    case 4:
+      return !0;
+  }
+}
+function se(l, e, t, r) {
+  for (var i; l.from == l.to || (t < 1 ? l.from >= e : l.from > e) || (t > -1 ? l.to <= e : l.to < e); ) {
+    let s = !r && l instanceof T && l.index < 0 ? null : l.parent;
+    if (!s)
+      return l;
+    l = s;
+  }
+  let n = r ? 0 : v.IgnoreOverlays;
+  if (r)
+    for (let s = l, o = s.parent; o; s = o, o = s.parent)
+      s instanceof T && s.index < 0 && ((i = o.enter(e, t, n)) === null || i === void 0 ? void 0 : i.from) != s.from && (l = o);
+  for (; ; ) {
+    let s = l.enter(e, t, n);
+    if (!s)
+      return l;
+    l = s;
+  }
+}
+class De {
+  cursor(e = 0) {
+    return new ge(this, e);
+  }
+  getChild(e, t = null, r = null) {
+    let i = _e(this, e, t, r);
+    return i.length ? i[0] : null;
+  }
+  getChildren(e, t = null, r = null) {
+    return _e(this, e, t, r);
+  }
+  resolve(e, t = 0) {
+    return se(this, e, t, !1);
+  }
+  resolveInner(e, t = 0) {
+    return se(this, e, t, !0);
+  }
+  matchContext(e) {
+    return be(this.parent, e);
+  }
+  enterUnfinishedNodesBefore(e) {
+    let t = this.childBefore(e), r = this;
+    for (; t; ) {
+      let i = t.lastChild;
+      if (!i || i.to != t.to)
+        break;
+      i.type.isError && i.from == i.to ? (r = t, t = i.prevSibling) : t = i;
+    }
+    return r;
+  }
+  get node() {
+    return this;
+  }
+  get next() {
+    return this.parent;
+  }
+}
+class T extends De {
+  constructor(e, t, r, i) {
+    super(), this._tree = e, this.from = t, this.index = r, this._parent = i;
+  }
+  get type() {
+    return this._tree.type;
+  }
+  get name() {
+    return this._tree.type.name;
+  }
+  get to() {
+    return this.from + this._tree.length;
+  }
+  nextChild(e, t, r, i, n = 0) {
+    for (let s = this; ; ) {
+      for (let { children: o, positions: a } = s._tree, h = t > 0 ? o.length : -1; e != h; e += t) {
+        let u = o[e], p = a[e] + s.from, c;
+        if (!(!(n & v.EnterBracketed && u instanceof R && (c = re.get(u)) && !c.overlay && c.bracketed && r >= p && r <= p + u.length) && !Fe(i, r, p, p + u.length))) {
+          if (u instanceof X) {
+            if (n & v.ExcludeBuffers)
+              continue;
+            let m = u.findChild(0, u.buffer.length, t, r - p, i);
+            if (m > -1)
+              return new K(new Ve(s, u, e, p), null, m);
+          } else if (n & v.IncludeAnonymous || !u.type.isAnonymous || ve(u)) {
+            let m;
+            if (!(n & v.IgnoreMounts) && (m = re.get(u)) && !m.overlay)
+              return new T(m.tree, p, e, s);
+            let k = new T(u, p, e, s);
+            return n & v.IncludeAnonymous || !k.type.isAnonymous ? k : k.nextChild(t < 0 ? u.children.length - 1 : 0, t, r, i, n);
+          }
+        }
+      }
+      if (n & v.IncludeAnonymous || !s.type.isAnonymous || (s.index >= 0 ? e = s.index + t : e = t < 0 ? -1 : s._parent._tree.children.length, s = s._parent, !s))
+        return null;
+    }
+  }
+  get firstChild() {
+    return this.nextChild(
+      0,
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get lastChild() {
+    return this.nextChild(
+      this._tree.children.length - 1,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  childAfter(e) {
+    return this.nextChild(
+      0,
+      1,
+      e,
+      2
+      /* Side.After */
+    );
+  }
+  childBefore(e) {
+    return this.nextChild(
+      this._tree.children.length - 1,
+      -1,
+      e,
+      -2
+      /* Side.Before */
+    );
+  }
+  prop(e) {
+    return this._tree.prop(e);
+  }
+  enter(e, t, r = 0) {
+    let i;
+    if (!(r & v.IgnoreOverlays) && (i = re.get(this._tree)) && i.overlay) {
+      let n = e - this.from, s = r & v.EnterBracketed && i.bracketed;
+      for (let { from: o, to: a } of i.overlay)
+        if ((t > 0 || s ? o <= n : o < n) && (t < 0 || s ? a >= n : a > n))
+          return new T(i.tree, i.overlay[0].from + this.from, -1, this);
+    }
+    return this.nextChild(0, 1, e, t, r);
+  }
+  nextSignificantParent() {
+    let e = this;
+    for (; e.type.isAnonymous && e._parent; )
+      e = e._parent;
+    return e;
+  }
+  get parent() {
+    return this._parent ? this._parent.nextSignificantParent() : null;
+  }
+  get nextSibling() {
+    return this._parent && this.index >= 0 ? this._parent.nextChild(
+      this.index + 1,
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    ) : null;
+  }
+  get prevSibling() {
+    return this._parent && this.index >= 0 ? this._parent.nextChild(
+      this.index - 1,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    ) : null;
+  }
+  get tree() {
+    return this._tree;
+  }
+  toTree() {
+    return this._tree;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this._tree.toString();
+  }
+}
+function _e(l, e, t, r) {
+  let i = l.cursor(), n = [];
+  if (!i.firstChild())
+    return n;
+  if (t != null) {
+    for (let s = !1; !s; )
+      if (s = i.type.is(t), !i.nextSibling())
+        return n;
+  }
+  for (; ; ) {
+    if (r != null && i.type.is(r))
+      return n;
+    if (i.type.is(e) && n.push(i.node), !i.nextSibling())
+      return r == null ? n : [];
+  }
+}
+function be(l, e, t = e.length - 1) {
+  for (let r = l; t >= 0; r = r.parent) {
+    if (!r)
+      return !1;
+    if (!r.type.isAnonymous) {
+      if (e[t] && e[t] != r.name)
+        return !1;
+      t--;
+    }
+  }
+  return !0;
+}
+class Ve {
+  constructor(e, t, r, i) {
+    this.parent = e, this.buffer = t, this.index = r, this.start = i;
+  }
+}
+class K extends De {
+  get name() {
+    return this.type.name;
+  }
+  get from() {
+    return this.context.start + this.context.buffer.buffer[this.index + 1];
+  }
+  get to() {
+    return this.context.start + this.context.buffer.buffer[this.index + 2];
+  }
+  constructor(e, t, r) {
+    super(), this.context = e, this._parent = t, this.index = r, this.type = e.buffer.set.types[e.buffer.buffer[r]];
+  }
+  child(e, t, r) {
+    let { buffer: i } = this.context, n = i.findChild(this.index + 4, i.buffer[this.index + 3], e, t - this.context.start, r);
+    return n < 0 ? null : new K(this.context, this, n);
+  }
+  get firstChild() {
+    return this.child(
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get lastChild() {
+    return this.child(
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  childAfter(e) {
+    return this.child(
+      1,
+      e,
+      2
+      /* Side.After */
+    );
+  }
+  childBefore(e) {
+    return this.child(
+      -1,
+      e,
+      -2
+      /* Side.Before */
+    );
+  }
+  prop(e) {
+    return this.type.prop(e);
+  }
+  enter(e, t, r = 0) {
+    if (r & v.ExcludeBuffers)
+      return null;
+    let { buffer: i } = this.context, n = i.findChild(this.index + 4, i.buffer[this.index + 3], t > 0 ? 1 : -1, e - this.context.start, t);
+    return n < 0 ? null : new K(this.context, this, n);
+  }
+  get parent() {
+    return this._parent || this.context.parent.nextSignificantParent();
+  }
+  externalSibling(e) {
+    return this._parent ? null : this.context.parent.nextChild(
+      this.context.index + e,
+      e,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get nextSibling() {
+    let { buffer: e } = this.context, t = e.buffer[this.index + 3];
+    return t < (this._parent ? e.buffer[this._parent.index + 3] : e.buffer.length) ? new K(this.context, this._parent, t) : this.externalSibling(1);
+  }
+  get prevSibling() {
+    let { buffer: e } = this.context, t = this._parent ? this._parent.index + 4 : 0;
+    return this.index == t ? this.externalSibling(-1) : new K(this.context, this._parent, e.findChild(
+      t,
+      this.index,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    ));
+  }
+  get tree() {
+    return null;
+  }
+  toTree() {
+    let e = [], t = [], { buffer: r } = this.context, i = this.index + 4, n = r.buffer[this.index + 3];
+    if (n > i) {
+      let s = r.buffer[this.index + 1];
+      e.push(r.slice(i, n, s)), t.push(0);
+    }
+    return new R(this.type, e, t, this.to - this.from);
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.context.buffer.childString(this.index);
+  }
+}
+function He(l) {
+  if (!l.length)
+    return null;
+  let e = 0, t = l[0];
+  for (let n = 1; n < l.length; n++) {
+    let s = l[n];
+    (s.from > t.from || s.to < t.to) && (t = s, e = n);
+  }
+  let r = t instanceof T && t.index < 0 ? null : t.parent, i = l.slice();
+  return r ? i[e] = r : i.splice(e, 1), new $e(i, t);
+}
+class $e {
+  constructor(e, t) {
+    this.heads = e, this.node = t;
+  }
+  get next() {
+    return He(this.heads);
+  }
+}
+function Ge(l, e, t) {
+  let r = l.resolveInner(e, t), i = null;
+  for (let n = r instanceof T ? r : r.context.parent; n; n = n.parent)
+    if (n.index < 0) {
+      let s = n.parent;
+      (i || (i = [r])).push(s.resolve(e, t)), n = s;
+    } else {
+      let s = re.get(n.tree);
+      if (s && s.overlay && s.overlay[0].from <= e && s.overlay[s.overlay.length - 1].to >= e) {
+        let o = new T(s.tree, s.overlay[0].from + n.from, -1, n);
+        (i || (i = [r])).push(se(o, e, t, !1));
+      }
+    }
+  return i ? He(i) : r;
+}
+class ge {
+  /**
+  Shorthand for `.type.name`.
+  */
+  get name() {
+    return this.type.name;
+  }
+  /**
+  @internal
+  */
+  constructor(e, t = 0) {
+    if (this.buffer = null, this.stack = [], this.index = 0, this.bufferNode = null, this.mode = t & ~v.EnterBracketed, e instanceof T)
+      this.yieldNode(e);
+    else {
+      this._tree = e.context.parent, this.buffer = e.context;
+      for (let r = e._parent; r; r = r._parent)
+        this.stack.unshift(r.index);
+      this.bufferNode = e, this.yieldBuf(e.index);
+    }
+  }
+  yieldNode(e) {
+    return e ? (this._tree = e, this.type = e.type, this.from = e.from, this.to = e.to, !0) : !1;
+  }
+  yieldBuf(e, t) {
+    this.index = e;
+    let { start: r, buffer: i } = this.buffer;
+    return this.type = t || i.set.types[i.buffer[e]], this.from = r + i.buffer[e + 1], this.to = r + i.buffer[e + 2], !0;
+  }
+  /**
+  @internal
+  */
+  yield(e) {
+    return e ? e instanceof T ? (this.buffer = null, this.yieldNode(e)) : (this.buffer = e.context, this.yieldBuf(e.index, e.type)) : !1;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
+  }
+  /**
+  @internal
+  */
+  enterChild(e, t, r) {
+    if (!this.buffer)
+      return this.yield(this._tree.nextChild(e < 0 ? this._tree._tree.children.length - 1 : 0, e, t, r, this.mode));
+    let { buffer: i } = this.buffer, n = i.findChild(this.index + 4, i.buffer[this.index + 3], e, t - this.buffer.start, r);
+    return n < 0 ? !1 : (this.stack.push(this.index), this.yieldBuf(n));
+  }
+  /**
+  Move the cursor to this node's first child. When this returns
+  false, the node has no child, and the cursor has not been moved.
+  */
+  firstChild() {
+    return this.enterChild(
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  /**
+  Move the cursor to this node's last child.
+  */
+  lastChild() {
+    return this.enterChild(
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  /**
+  Move the cursor to the first child that ends after `pos`.
+  */
+  childAfter(e) {
+    return this.enterChild(
+      1,
+      e,
+      2
+      /* Side.After */
+    );
+  }
+  /**
+  Move to the last child that starts before `pos`.
+  */
+  childBefore(e) {
+    return this.enterChild(
+      -1,
+      e,
+      -2
+      /* Side.Before */
+    );
+  }
+  /**
+  Move the cursor to the child around `pos`. If side is -1 the
+  child may end at that position, when 1 it may start there. This
+  will also enter [overlaid](#common.MountedTree.overlay)
+  [mounted](#common.NodeProp^mounted) trees unless `overlays` is
+  set to false.
+  */
+  enter(e, t, r = this.mode) {
+    return this.buffer ? r & v.ExcludeBuffers ? !1 : this.enterChild(1, e, t) : this.yield(this._tree.enter(e, t, r));
+  }
+  /**
+  Move to the node's parent node, if this isn't the top node.
+  */
+  parent() {
+    if (!this.buffer)
+      return this.yieldNode(this.mode & v.IncludeAnonymous ? this._tree._parent : this._tree.parent);
+    if (this.stack.length)
+      return this.yieldBuf(this.stack.pop());
+    let e = this.mode & v.IncludeAnonymous ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+    return this.buffer = null, this.yieldNode(e);
+  }
+  /**
+  @internal
+  */
+  sibling(e) {
+    if (!this.buffer)
+      return this._tree._parent ? this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + e, e, 0, 4, this.mode)) : !1;
+    let { buffer: t } = this.buffer, r = this.stack.length - 1;
+    if (e < 0) {
+      let i = r < 0 ? 0 : this.stack[r] + 4;
+      if (this.index != i)
+        return this.yieldBuf(t.findChild(
+          i,
+          this.index,
+          -1,
+          0,
+          4
+          /* Side.DontCare */
+        ));
+    } else {
+      let i = t.buffer[this.index + 3];
+      if (i < (r < 0 ? t.buffer.length : t.buffer[this.stack[r] + 3]))
+        return this.yieldBuf(i);
+    }
+    return r < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + e, e, 0, 4, this.mode)) : !1;
+  }
+  /**
+  Move to this node's next sibling, if any.
+  */
+  nextSibling() {
+    return this.sibling(1);
+  }
+  /**
+  Move to this node's previous sibling, if any.
+  */
+  prevSibling() {
+    return this.sibling(-1);
+  }
+  atLastNode(e) {
+    let t, r, { buffer: i } = this;
+    if (i) {
+      if (e > 0) {
+        if (this.index < i.buffer.buffer.length)
+          return !1;
+      } else
+        for (let n = 0; n < this.index; n++)
+          if (i.buffer.buffer[n + 3] < this.index)
+            return !1;
+      ({ index: t, parent: r } = i);
+    } else
+      ({ index: t, _parent: r } = this._tree);
+    for (; r; { index: t, _parent: r } = r)
+      if (t > -1)
+        for (let n = t + e, s = e < 0 ? -1 : r._tree.children.length; n != s; n += e) {
+          let o = r._tree.children[n];
+          if (this.mode & v.IncludeAnonymous || o instanceof X || !o.type.isAnonymous || ve(o))
+            return !1;
+        }
+    return !0;
+  }
+  move(e, t) {
+    if (t && this.enterChild(
+      e,
+      0,
+      4
+      /* Side.DontCare */
+    ))
+      return !0;
+    for (; ; ) {
+      if (this.sibling(e))
+        return !0;
+      if (this.atLastNode(e) || !this.parent())
+        return !1;
+    }
+  }
+  /**
+  Move to the next node in a
+  [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
+  traversal, going from a node to its first child or, if the
+  current node is empty or `enter` is false, its next sibling or
+  the next sibling of the first parent node that has one.
+  */
+  next(e = !0) {
+    return this.move(1, e);
+  }
+  /**
+  Move to the next node in a last-to-first pre-order traversal. A
+  node is followed by its last child or, if it has none, its
+  previous sibling or the previous sibling of the first parent
+  node that has one.
+  */
+  prev(e = !0) {
+    return this.move(-1, e);
+  }
+  /**
+  Move the cursor to the innermost node that covers `pos`. If
+  `side` is -1, it will enter nodes that end at `pos`. If it is 1,
+  it will enter nodes that start at `pos`.
+  */
+  moveTo(e, t = 0) {
+    for (; (this.from == this.to || (t < 1 ? this.from >= e : this.from > e) || (t > -1 ? this.to <= e : this.to < e)) && this.parent(); )
+      ;
+    for (; this.enterChild(1, e, t); )
+      ;
+    return this;
+  }
+  /**
+  Get a [syntax node](#common.SyntaxNode) at the cursor's current
+  position.
+  */
+  get node() {
+    if (!this.buffer)
+      return this._tree;
+    let e = this.bufferNode, t = null, r = 0;
+    if (e && e.context == this.buffer)
+      e: for (let i = this.index, n = this.stack.length; n >= 0; ) {
+        for (let s = e; s; s = s._parent)
+          if (s.index == i) {
+            if (i == this.index)
+              return s;
+            t = s, r = n + 1;
+            break e;
+          }
+        i = this.stack[--n];
+      }
+    for (let i = r; i < this.stack.length; i++)
+      t = new K(this.buffer, t, this.stack[i]);
+    return this.bufferNode = new K(this.buffer, t, this.index);
+  }
+  /**
+  Get the [tree](#common.Tree) that represents the current node, if
+  any. Will return null when the node is in a [tree
+  buffer](#common.TreeBuffer).
+  */
+  get tree() {
+    return this.buffer ? null : this._tree._tree;
+  }
+  /**
+  Iterate over the current node and all its descendants, calling
+  `enter` when entering a node and `leave`, if given, when leaving
+  one. When `enter` returns `false`, any children of that node are
+  skipped, and `leave` isn't called for it.
+  */
+  iterate(e, t) {
+    for (let r = 0; ; ) {
+      let i = !1;
+      if (this.type.isAnonymous || e(this) !== !1) {
+        if (this.firstChild()) {
+          r++;
+          continue;
+        }
+        this.type.isAnonymous || (i = !0);
+      }
+      for (; ; ) {
+        if (i && t && t(this), i = this.type.isAnonymous, !r)
+          return;
+        if (this.nextSibling())
+          break;
+        this.parent(), r--, i = !0;
+      }
+    }
+  }
+  /**
+  Test whether the current node matches a given context—a sequence
+  of direct parent node names. Empty strings in the context array
+  are treated as wildcards.
+  */
+  matchContext(e) {
+    if (!this.buffer)
+      return be(this.node.parent, e);
+    let { buffer: t } = this.buffer, { types: r } = t.set;
+    for (let i = e.length - 1, n = this.stack.length - 1; i >= 0; n--) {
+      if (n < 0)
+        return be(this._tree, e, i);
+      let s = r[t.buffer[this.stack[n]]];
+      if (!s.isAnonymous) {
+        if (e[i] && e[i] != s.name)
+          return !1;
+        i--;
+      }
+    }
+    return !0;
+  }
+}
+function ve(l) {
+  return l.children.some((e) => e instanceof X || !e.type.isAnonymous || ve(e));
+}
+function Qe(l) {
+  var e;
+  let { buffer: t, nodeSet: r, maxBufferLength: i = 1024, reused: n = [], minRepeatType: s = r.types.length } = l, o = Array.isArray(t) ? new we(t, t.length) : t, a = r.types, h = 0, u = 0;
+  function p(x, N, d, B, w, I) {
+    let { id: b, start: g, end: S, size: _ } = o, O = u, $ = h;
+    if (_ < 0)
+      if (o.next(), _ == -1) {
+        let V = n[b];
+        d.push(V), B.push(g - x);
+        return;
+      } else if (_ == -3) {
+        h = b;
+        return;
+      } else if (_ == -4) {
+        u = b;
+        return;
+      } else
+        throw new RangeError(`Unrecognized record size: ${_}`);
+    let ie = a[b], ae, Y, Ce = g - x;
+    if (S - g <= i && (Y = M(o.pos - N, w))) {
+      let V = new Uint16Array(Y.size - Y.skip), D = o.pos - Y.size, W = V.length;
+      for (; o.pos > D; )
+        W = E(Y.start, V, W);
+      ae = new X(V, S - Y.start, r), Ce = Y.start - x;
+    } else {
+      let V = o.pos - _;
+      o.next();
+      let D = [], W = [], Z = b >= s ? b : -1, te = 0, fe = S;
+      for (; o.pos > V; )
+        Z >= 0 && o.id == Z && o.size >= 0 ? (o.end <= fe - i && (k(D, W, g, te, o.end, fe, Z, O, $), te = D.length, fe = o.end), o.next()) : I > 2500 ? c(g, V, D, W) : p(g, V, D, W, Z, I + 1);
+      if (Z >= 0 && te > 0 && te < D.length && k(D, W, g, te, g, fe, Z, O, $), D.reverse(), W.reverse(), Z > -1 && te > 0) {
+        let Se = m(ie, $);
+        ae = Ae(ie, D, W, 0, D.length, 0, S - g, Se, Se);
+      } else
+        ae = P(ie, D, W, S - g, O - S, $);
+    }
+    d.push(ae), B.push(Ce);
+  }
+  function c(x, N, d, B) {
+    let w = [], I = 0, b = -1;
+    for (; o.pos > N; ) {
+      let { id: g, start: S, end: _, size: O } = o;
+      if (O > 4)
+        o.next();
+      else {
+        if (b > -1 && S < b)
+          break;
+        b < 0 && (b = _ - i), w.push(g, S, _), I++, o.next();
+      }
+    }
+    if (I) {
+      let g = new Uint16Array(I * 4), S = w[w.length - 2];
+      for (let _ = w.length - 3, O = 0; _ >= 0; _ -= 3)
+        g[O++] = w[_], g[O++] = w[_ + 1] - S, g[O++] = w[_ + 2] - S, g[O++] = O;
+      d.push(new X(g, w[2] - S, r)), B.push(S - x);
+    }
+  }
+  function m(x, N) {
+    return (d, B, w) => {
+      let I = 0, b = d.length - 1, g, S;
+      if (b >= 0 && (g = d[b]) instanceof R) {
+        if (!b && g.type == x && g.length == w)
+          return g;
+        (S = g.prop(A.lookAhead)) && (I = B[b] + g.length + S);
+      }
+      return P(x, d, B, w, I, N);
+    };
+  }
+  function k(x, N, d, B, w, I, b, g, S) {
+    let _ = [], O = [];
+    for (; x.length > B; )
+      _.push(x.pop()), O.push(N.pop() + d - w);
+    x.push(P(r.types[b], _, O, I - w, g - I, S)), N.push(w - d);
+  }
+  function P(x, N, d, B, w, I, b) {
+    if (I) {
+      let g = [A.contextHash, I];
+      b = b ? [g].concat(b) : [g];
+    }
+    if (w > 25) {
+      let g = [A.lookAhead, w];
+      b = b ? [g].concat(b) : [g];
+    }
+    return new R(x, N, d, B, b);
+  }
+  function M(x, N) {
+    let d = o.fork(), B = 0, w = 0, I = 0, b = d.end - i, g = { size: 0, start: 0, skip: 0 };
+    e: for (let S = d.pos - x; d.pos > S; ) {
+      let _ = d.size;
+      if (d.id == N && _ >= 0) {
+        g.size = B, g.start = w, g.skip = I, I += 4, B += 4, d.next();
+        continue;
+      }
+      let O = d.pos - _;
+      if (_ < 0 || O < S || d.start < b)
+        break;
+      let $ = d.id >= s ? 4 : 0, ie = d.start;
+      for (d.next(); d.pos > O; ) {
+        if (d.size < 0)
+          if (d.size == -3 || d.size == -4)
+            $ += 4;
+          else
+            break e;
+        else d.id >= s && ($ += 4);
+        d.next();
+      }
+      w = ie, B += _, I += $;
+    }
+    return (N < 0 || B == x) && (g.size = B, g.start = w, g.skip = I), g.size > 4 ? g : void 0;
+  }
+  function E(x, N, d) {
+    let { id: B, start: w, end: I, size: b } = o;
+    if (o.next(), b >= 0 && B < s) {
+      let g = d;
+      if (b > 4) {
+        let S = o.pos - (b - 4);
+        for (; o.pos > S; )
+          d = E(x, N, d);
+      }
+      N[--d] = g, N[--d] = I - x, N[--d] = w - x, N[--d] = B;
+    } else b == -3 ? h = B : b == -4 && (u = B);
+    return d;
+  }
+  let z = [], C = [];
+  for (; o.pos > 0; )
+    p(l.start || 0, l.bufferStart || 0, z, C, -1, 0);
+  let F = (e = l.length) !== null && e !== void 0 ? e : z.length ? C[0] + z[0].length : 0;
+  return new R(a[l.topID], z.reverse(), C.reverse(), F);
+}
+const Be = /* @__PURE__ */ new WeakMap();
+function de(l, e) {
+  if (!l.isAnonymous || e instanceof X || e.type != l)
+    return 1;
+  let t = Be.get(e);
+  if (t == null) {
+    t = 1;
+    for (let r of e.children) {
+      if (r.type != l || !(r instanceof R)) {
+        t = 1;
+        break;
+      }
+      t += de(l, r);
+    }
+    Be.set(e, t);
+  }
+  return t;
+}
+function Ae(l, e, t, r, i, n, s, o, a) {
+  let h = 0;
+  for (let k = r; k < i; k++)
+    h += de(l, e[k]);
+  let u = Math.ceil(
+    h * 1.5 / 8
+    /* Balance.BranchFactor */
+  ), p = [], c = [];
+  function m(k, P, M, E, z) {
+    for (let C = M; C < E; ) {
+      let F = C, x = P[C], N = de(l, k[C]);
+      for (C++; C < E; C++) {
+        let d = de(l, k[C]);
+        if (N + d >= u)
+          break;
+        N += d;
+      }
+      if (C == F + 1) {
+        if (N > u) {
+          let d = k[F];
+          m(d.children, d.positions, 0, d.children.length, P[F] + z);
+          continue;
+        }
+        p.push(k[F]);
+      } else {
+        let d = P[C - 1] + k[C - 1].length - x;
+        p.push(Ae(l, k, P, F, C, x, d, null, a));
+      }
+      c.push(x + z - n);
+    }
+  }
+  return m(e, t, r, i, 0), (o || a)(p, c, s);
+}
+class dt {
+  constructor() {
+    this.map = /* @__PURE__ */ new WeakMap();
+  }
+  setBuffer(e, t, r) {
+    let i = this.map.get(e);
+    i || this.map.set(e, i = /* @__PURE__ */ new Map()), i.set(t, r);
+  }
+  getBuffer(e, t) {
+    let r = this.map.get(e);
+    return r && r.get(t);
+  }
+  /**
+  Set the value for this syntax node.
+  */
+  set(e, t) {
+    e instanceof K ? this.setBuffer(e.context.buffer, e.index, t) : e instanceof T && this.map.set(e.tree, t);
+  }
+  /**
+  Retrieve value for this syntax node, if it exists in the map.
+  */
+  get(e) {
+    return e instanceof K ? this.getBuffer(e.context.buffer, e.index) : e instanceof T ? this.map.get(e.tree) : void 0;
+  }
+  /**
+  Set the value for the node that a cursor currently points to.
+  */
+  cursorSet(e, t) {
+    e.buffer ? this.setBuffer(e.buffer.buffer, e.index, t) : this.map.set(e.tree, t);
+  }
+  /**
+  Retrieve the value for the node that a cursor currently points
+  to.
+  */
+  cursorGet(e) {
+    return e.buffer ? this.getBuffer(e.buffer.buffer, e.index) : this.map.get(e.tree);
+  }
+}
+class le {
+  /**
+  Construct a tree fragment. You'll usually want to use
+  [`addTree`](#common.TreeFragment^addTree) and
+  [`applyChanges`](#common.TreeFragment^applyChanges) instead of
+  calling this directly.
+  */
+  constructor(e, t, r, i, n = !1, s = !1) {
+    this.from = e, this.to = t, this.tree = r, this.offset = i, this.open = (n ? 1 : 0) | (s ? 2 : 0);
+  }
+  /**
+  Whether the start of the fragment represents the start of a
+  parse, or the end of a change. (In the second case, it may not
+  be safe to reuse some nodes at the start, depending on the
+  parsing algorithm.)
+  */
+  get openStart() {
+    return (this.open & 1) > 0;
+  }
+  /**
+  Whether the end of the fragment represents the end of a
+  full-document parse, or the start of a change.
+  */
+  get openEnd() {
+    return (this.open & 2) > 0;
+  }
+  /**
+  Create a set of fragments from a freshly parsed tree, or update
+  an existing set of fragments by replacing the ones that overlap
+  with a tree with content from the new tree. When `partial` is
+  true, the parse is treated as incomplete, and the resulting
+  fragment has [`openEnd`](#common.TreeFragment.openEnd) set to
+  true.
+  */
+  static addTree(e, t = [], r = !1) {
+    let i = [new le(0, e.length, e, 0, !1, r)];
+    for (let n of t)
+      n.to > e.length && i.push(n);
+    return i;
+  }
+  /**
+  Apply a set of edits to an array of fragments, removing or
+  splitting fragments as necessary to remove edited ranges, and
+  adjusting offsets for fragments that moved.
+  */
+  static applyChanges(e, t, r = 128) {
+    if (!t.length)
+      return e;
+    let i = [], n = 1, s = e.length ? e[0] : null;
+    for (let o = 0, a = 0, h = 0; ; o++) {
+      let u = o < t.length ? t[o] : null, p = u ? u.fromA : 1e9;
+      if (p - a >= r)
+        for (; s && s.from < p; ) {
+          let c = s;
+          if (a >= c.from || p <= c.to || h) {
+            let m = Math.max(c.from, a) - h, k = Math.min(c.to, p) - h;
+            c = m >= k ? null : new le(m, k, c.tree, c.offset + h, o > 0, !!u);
+          }
+          if (c && i.push(c), s.to > p)
+            break;
+          s = n < e.length ? e[n++] : null;
+        }
+      if (!u)
+        break;
+      a = u.toA, h = u.toA - u.toB;
+    }
+    return i;
+  }
+}
+class gt {
+  /**
+  Start a parse, returning a [partial parse](#common.PartialParse)
+  object. [`fragments`](#common.TreeFragment) can be passed in to
+  make the parse incremental.
+  
+  By default, the entire input is parsed. You can pass `ranges`,
+  which should be a sorted array of non-empty, non-overlapping
+  ranges, to parse only those ranges. The tree returned in that
+  case will start at `ranges[0].from`.
+  */
+  startParse(e, t, r) {
+    return typeof e == "string" && (e = new Xe(e)), r = r ? r.length ? r.map((i) => new H(i.from, i.to)) : [new H(0, 0)] : [new H(0, e.length)], this.createParse(e, t || [], r);
+  }
+  /**
+  Run a full parse, returning the resulting tree.
+  */
+  parse(e, t, r) {
+    let i = this.startParse(e, t, r);
+    for (; ; ) {
+      let n = i.advance();
+      if (n)
+        return n;
+    }
+  }
+}
+class Xe {
+  constructor(e) {
+    this.string = e;
+  }
+  get length() {
+    return this.string.length;
+  }
+  chunk(e) {
+    return this.string.slice(e);
+  }
+  get lineChunks() {
+    return !1;
+  }
+  read(e, t) {
+    return this.string.slice(e, t);
+  }
+}
+function mt(l) {
+  return (e, t, r, i) => new Ze(e, l, t, r, i);
+}
+class Ie {
+  constructor(e, t, r, i, n, s) {
+    this.parser = e, this.parse = t, this.overlay = r, this.bracketed = i, this.target = n, this.from = s;
+  }
+}
+function Pe(l) {
+  if (!l.length || l.some((e) => e.from >= e.to))
+    throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(l));
+}
+class Ye {
+  constructor(e, t, r, i, n, s, o, a) {
+    this.parser = e, this.predicate = t, this.mounts = r, this.index = i, this.start = n, this.bracketed = s, this.target = o, this.prev = a, this.depth = 0, this.ranges = [];
+  }
+}
+const xe = new A({ perNode: !0 });
+class Ze {
+  constructor(e, t, r, i, n) {
+    this.nest = t, this.input = r, this.fragments = i, this.ranges = n, this.inner = [], this.innerDone = 0, this.baseTree = null, this.stoppedAt = null, this.baseParse = e;
+  }
+  advance() {
+    if (this.baseParse) {
+      let r = this.baseParse.advance();
+      if (!r)
+        return null;
+      if (this.baseParse = null, this.baseTree = r, this.startInner(), this.stoppedAt != null)
+        for (let i of this.inner)
+          i.parse.stopAt(this.stoppedAt);
+    }
+    if (this.innerDone == this.inner.length) {
+      let r = this.baseTree;
+      return this.stoppedAt != null && (r = new R(r.type, r.children, r.positions, r.length, r.propValues.concat([[xe, this.stoppedAt]]))), r;
+    }
+    let e = this.inner[this.innerDone], t = e.parse.advance();
+    if (t) {
+      this.innerDone++;
+      let r = Object.assign(/* @__PURE__ */ Object.create(null), e.target.props);
+      r[A.mounted.id] = new re(t, e.overlay, e.parser, e.bracketed), e.target.props = r;
+    }
+    return null;
+  }
+  get parsedPos() {
+    if (this.baseParse)
+      return 0;
+    let e = this.input.length;
+    for (let t = this.innerDone; t < this.inner.length; t++)
+      this.inner[t].from < e && (e = Math.min(e, this.inner[t].parse.parsedPos));
+    return e;
+  }
+  stopAt(e) {
+    if (this.stoppedAt = e, this.baseParse)
+      this.baseParse.stopAt(e);
+    else
+      for (let t = this.innerDone; t < this.inner.length; t++)
+        this.inner[t].parse.stopAt(e);
+  }
+  startInner() {
+    let e = new rt(this.fragments), t = null, r = null, i = new ge(new T(this.baseTree, this.ranges[0].from, 0, null), v.IncludeAnonymous | v.IgnoreMounts);
+    e: for (let n, s; ; ) {
+      let o = !0, a;
+      if (this.stoppedAt != null && i.from >= this.stoppedAt)
+        o = !1;
+      else if (e.hasNode(i)) {
+        if (t) {
+          let h = t.mounts.find((u) => u.frag.from <= i.from && u.frag.to >= i.to && u.mount.overlay);
+          if (h)
+            for (let u of h.mount.overlay) {
+              let p = u.from + h.pos, c = u.to + h.pos;
+              p >= i.from && c <= i.to && !t.ranges.some((m) => m.from < c && m.to > p) && t.ranges.push({ from: p, to: c });
+            }
+        }
+        o = !1;
+      } else if (r && (s = et(r.ranges, i.from, i.to)))
+        o = s != 2;
+      else if (!i.type.isAnonymous && (n = this.nest(i, this.input)) && (i.from < i.to || !n.overlay)) {
+        i.tree || (tt(i), t && t.depth++, r && r.depth++);
+        let h = e.findMounts(i.from, n.parser);
+        if (typeof n.overlay == "function")
+          t = new Ye(n.parser, n.overlay, h, this.inner.length, i.from, !!n.bracketed, i.tree, t);
+        else {
+          let u = Ee(this.ranges, n.overlay || (i.from < i.to ? [new H(i.from, i.to)] : []));
+          u.length && Pe(u), (u.length || !n.overlay) && this.inner.push(new Ie(n.parser, u.length ? n.parser.startParse(this.input, Oe(h, u), u) : n.parser.startParse(""), n.overlay ? n.overlay.map((p) => new H(p.from - i.from, p.to - i.from)) : null, !!n.bracketed, i.tree, u.length ? u[0].from : i.from)), n.overlay ? u.length && (r = { ranges: u, depth: 0, prev: r }) : o = !1;
+        }
+      } else if (t && (a = t.predicate(i)) && (a === !0 && (a = new H(i.from, i.to)), a.from < a.to)) {
+        let h = t.ranges.length - 1;
+        h >= 0 && t.ranges[h].to == a.from ? t.ranges[h] = { from: t.ranges[h].from, to: a.to } : t.ranges.push(a);
+      }
+      if (o && i.firstChild())
+        t && t.depth++, r && r.depth++;
+      else
+        for (; !i.nextSibling(); ) {
+          if (!i.parent())
+            break e;
+          if (t && !--t.depth) {
+            let h = Ee(this.ranges, t.ranges);
+            h.length && (Pe(h), this.inner.splice(t.index, 0, new Ie(t.parser, t.parser.startParse(this.input, Oe(t.mounts, h), h), t.ranges.map((u) => new H(u.from - t.start, u.to - t.start)), t.bracketed, t.target, h[0].from))), t = t.prev;
+          }
+          r && !--r.depth && (r = r.prev);
+        }
+    }
+  }
+}
+function et(l, e, t) {
+  for (let r of l) {
+    if (r.from >= t)
+      break;
+    if (r.to > e)
+      return r.from <= e && r.to >= t ? 2 : 1;
+  }
+  return 0;
+}
+function Me(l, e, t, r, i, n) {
+  if (e < t) {
+    let s = l.buffer[e + 1];
+    r.push(l.slice(e, t, s)), i.push(s - n);
+  }
+}
+function tt(l) {
+  let { node: e } = l, t = [], r = e.context.buffer;
+  do
+    t.push(l.index), l.parent();
+  while (!l.tree);
+  let i = l.tree, n = i.children.indexOf(r), s = i.children[n], o = s.buffer, a = [n];
+  function h(u, p, c, m, k, P) {
+    let M = t[P], E = [], z = [];
+    Me(s, u, M, E, z, m);
+    let C = o[M + 1], F = o[M + 2];
+    a.push(E.length);
+    let x = P ? h(M + 4, o[M + 3], s.set.types[o[M]], C, F - C, P - 1) : e.toTree();
+    return E.push(x), z.push(C - m), Me(s, o[M + 3], p, E, z, m), new R(c, E, z, k);
+  }
+  i.children[n] = h(0, o.length, L.none, 0, s.length, t.length - 1);
+  for (let u of a) {
+    let p = l.tree.children[u], c = l.tree.positions[u];
+    l.yield(new T(p, c + l.from, u, l._tree));
+  }
+}
+class ze {
+  constructor(e, t) {
+    this.offset = t, this.done = !1, this.cursor = e.cursor(v.IncludeAnonymous | v.IgnoreMounts);
+  }
+  // Move to the first node (in pre-order) that starts at or after `pos`.
+  moveTo(e) {
+    let { cursor: t } = this, r = e - this.offset;
+    for (; !this.done && t.from < r; )
+      if (!(t.to >= e && t.enter(r, 1, v.IgnoreOverlays | v.ExcludeBuffers))) if (t.to <= e)
+        t.next(!1) || (this.done = !0);
+      else
+        break;
+  }
+  hasNode(e) {
+    if (this.moveTo(e.from), !this.done && this.cursor.from + this.offset == e.from && this.cursor.tree)
+      for (let t = this.cursor.tree; ; ) {
+        if (t == e.tree)
+          return !0;
+        if (t.children.length && t.positions[0] == 0 && t.children[0] instanceof R)
+          t = t.children[0];
+        else
+          break;
+      }
+    return !1;
+  }
+}
+class rt {
+  constructor(e) {
+    var t;
+    if (this.fragments = e, this.curTo = 0, this.fragI = 0, e.length) {
+      let r = this.curFrag = e[0];
+      this.curTo = (t = r.tree.prop(xe)) !== null && t !== void 0 ? t : r.to, this.inner = new ze(r.tree, -r.offset);
+    } else
+      this.curFrag = this.inner = null;
+  }
+  hasNode(e) {
+    for (; this.curFrag && e.from >= this.curTo; )
+      this.nextFrag();
+    return this.curFrag && this.curFrag.from <= e.from && this.curTo >= e.to && this.inner.hasNode(e);
+  }
+  nextFrag() {
+    var e;
+    if (this.fragI++, this.fragI == this.fragments.length)
+      this.curFrag = this.inner = null;
+    else {
+      let t = this.curFrag = this.fragments[this.fragI];
+      this.curTo = (e = t.tree.prop(xe)) !== null && e !== void 0 ? e : t.to, this.inner = new ze(t.tree, -t.offset);
+    }
+  }
+  findMounts(e, t) {
+    var r;
+    let i = [];
+    if (this.inner) {
+      this.inner.cursor.moveTo(e, 1);
+      for (let n = this.inner.cursor.node; n; n = n.parent) {
+        let s = (r = n.tree) === null || r === void 0 ? void 0 : r.prop(A.mounted);
+        if (s && s.parser == t)
+          for (let o = this.fragI; o < this.fragments.length; o++) {
+            let a = this.fragments[o];
+            if (a.from >= n.to)
+              break;
+            a.tree == this.curFrag.tree && i.push({
+              frag: a,
+              pos: n.from - a.offset,
+              mount: s
+            });
+          }
+      }
+    }
+    return i;
+  }
+}
+function Ee(l, e) {
+  let t = null, r = e;
+  for (let i = 1, n = 0; i < l.length; i++) {
+    let s = l[i - 1].to, o = l[i].from;
+    for (; n < r.length; n++) {
+      let a = r[n];
+      if (a.from >= o)
+        break;
+      a.to <= s || (t || (r = t = e.slice()), a.from < s ? (t[n] = new H(a.from, s), a.to > o && t.splice(n + 1, 0, new H(o, a.to))) : a.to > o ? t[n--] = new H(o, a.to) : t.splice(n--, 1));
+    }
+  }
+  return r;
+}
+function it(l, e, t, r) {
+  let i = 0, n = 0, s = !1, o = !1, a = -1e9, h = [];
+  for (; ; ) {
+    let u = i == l.length ? 1e9 : s ? l[i].to : l[i].from, p = n == e.length ? 1e9 : o ? e[n].to : e[n].from;
+    if (s != o) {
+      let c = Math.max(a, t), m = Math.min(u, p, r);
+      c < m && h.push(new H(c, m));
+    }
+    if (a = Math.min(u, p), a == 1e9)
+      break;
+    u == a && (s ? (s = !1, i++) : s = !0), p == a && (o ? (o = !1, n++) : o = !0);
+  }
+  return h;
+}
+function Oe(l, e) {
+  let t = [];
+  for (let { pos: r, mount: i, frag: n } of l) {
+    let s = r + (i.overlay ? i.overlay[0].from : 0), o = s + i.tree.length, a = Math.max(n.from, s), h = Math.min(n.to, o);
+    if (i.overlay) {
+      let u = i.overlay.map((c) => new H(c.from + r, c.to + r)), p = it(e, u, a, h);
+      for (let c = 0, m = a; ; c++) {
+        let k = c == p.length, P = k ? h : p[c].from;
+        if (P > m && t.push(new le(m, P, i.tree, -s, n.from >= m || n.openStart, n.to <= P || n.openEnd)), k)
+          break;
+        m = p[c].to;
+      }
+    } else
+      t.push(new le(a, h, i.tree, -s, n.from >= s || n.openStart, n.to <= o || n.openEnd));
+  }
+  return t;
+}
+let nt = 0;
+class j {
+  /**
+  @internal
+  */
+  constructor(e, t, r, i) {
+    this.name = e, this.set = t, this.base = r, this.modified = i, this.id = nt++;
+  }
+  toString() {
+    let { name: e } = this;
+    for (let t of this.modified)
+      t.name && (e = `${t.name}(${e})`);
+    return e;
+  }
+  static define(e, t) {
+    let r = typeof e == "string" ? e : "?";
+    if (e instanceof j && (t = e), t?.base)
+      throw new Error("Can not derive from a modified tag");
+    let i = new j(r, [], null, []);
+    if (i.set.push(i), t)
+      for (let n of t.set)
+        i.set.push(n);
+    return i;
+  }
+  /**
+  Define a tag _modifier_, which is a function that, given a tag,
+  will return a tag that is a subtag of the original. Applying the
+  same modifier to a twice tag will return the same value (`m1(t1)
+  == m1(t1)`) and applying multiple modifiers will, regardless or
+  order, produce the same tag (`m1(m2(t1)) == m2(m1(t1))`).
+  
+  When multiple modifiers are applied to a given base tag, each
+  smaller set of modifiers is registered as a parent, so that for
+  example `m1(m2(m3(t1)))` is a subtype of `m1(m2(t1))`,
+  `m1(m3(t1)`, and so on.
+  */
+  static defineModifier(e) {
+    let t = new me(e);
+    return (r) => r.modified.indexOf(t) > -1 ? r : me.get(r.base || r, r.modified.concat(t).sort((i, n) => i.id - n.id));
+  }
+}
+let st = 0;
+class me {
+  constructor(e) {
+    this.name = e, this.instances = [], this.id = st++;
+  }
+  static get(e, t) {
+    if (!t.length)
+      return e;
+    let r = t[0].instances.find((o) => o.base == e && lt(t, o.modified));
+    if (r)
+      return r;
+    let i = [], n = new j(e.name, i, e, t);
+    for (let o of t)
+      o.instances.push(n);
+    let s = ot(t);
+    for (let o of e.set)
+      if (!o.modified.length)
+        for (let a of s)
+          i.push(me.get(o, a));
+    return n;
+  }
+}
+function lt(l, e) {
+  return l.length == e.length && l.every((t, r) => t == e[r]);
+}
+function ot(l) {
+  let e = [[]];
+  for (let t = 0; t < l.length; t++)
+    for (let r = 0, i = e.length; r < i; r++)
+      e.push(e[r].concat(l[t]));
+  return e.sort((t, r) => r.length - t.length);
+}
+function at(l) {
+  let e = /* @__PURE__ */ Object.create(null);
+  for (let t in l) {
+    let r = l[t];
+    Array.isArray(r) || (r = [r]);
+    for (let i of t.split(" "))
+      if (i) {
+        let n = [], s = 2, o = i;
+        for (let p = 0; ; ) {
+          if (o == "..." && p > 0 && p + 3 == i.length) {
+            s = 1;
+            break;
+          }
+          let c = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(o);
+          if (!c)
+            throw new RangeError("Invalid path: " + i);
+          if (n.push(c[0] == "*" ? "" : c[0][0] == '"' ? JSON.parse(c[0]) : c[0]), p += c[0].length, p == i.length)
+            break;
+          let m = i[p++];
+          if (p == i.length && m == "!") {
+            s = 0;
+            break;
+          }
+          if (m != "/")
+            throw new RangeError("Invalid path: " + i);
+          o = i.slice(p);
+        }
+        let a = n.length - 1, h = n[a];
+        if (!h)
+          throw new RangeError("Invalid path: " + i);
+        let u = new oe(r, s, a > 0 ? n.slice(0, a) : null);
+        e[h] = u.sort(e[h]);
+      }
+  }
+  return Le.add(e);
+}
+const Le = new A({
+  combine(l, e) {
+    let t, r, i;
+    for (; l || e; ) {
+      if (!l || e && l.depth >= e.depth ? (i = e, e = e.next) : (i = l, l = l.next), t && t.mode == i.mode && !i.context && !t.context)
+        continue;
+      let n = new oe(i.tags, i.mode, i.context);
+      t ? t.next = n : r = n, t = n;
+    }
+    return r;
+  }
+});
+class oe {
+  constructor(e, t, r, i) {
+    this.tags = e, this.mode = t, this.context = r, this.next = i;
+  }
+  get opaque() {
+    return this.mode == 0;
+  }
+  get inherit() {
+    return this.mode == 1;
+  }
+  sort(e) {
+    return !e || e.depth < this.depth ? (this.next = e, this) : (e.next = this.sort(e.next), e);
+  }
+  get depth() {
+    return this.context ? this.context.length : 0;
+  }
+}
+oe.empty = new oe([], 2, null);
+function We(l, e) {
+  let t = /* @__PURE__ */ Object.create(null);
+  for (let n of l)
+    if (!Array.isArray(n.tag))
+      t[n.tag.id] = n.class;
+    else
+      for (let s of n.tag)
+        t[s.id] = n.class;
+  let { scope: r, all: i = null } = e || {};
+  return {
+    style: (n) => {
+      let s = i;
+      for (let o of n)
+        for (let a of o.set) {
+          let h = t[a.id];
+          if (h) {
+            s = s ? s + " " + h : h;
+            break;
+          }
+        }
+      return s;
+    },
+    scope: r
+  };
+}
+function ft(l, e) {
+  let t = null;
+  for (let r of l) {
+    let i = r.style(e);
+    i && (t = t ? t + " " + i : i);
+  }
+  return t;
+}
+function Ue(l, e, t, r = 0, i = l.length) {
+  let n = new ut(r, Array.isArray(e) ? e : [e], t);
+  n.highlightRange(l.cursor(), r, i, "", n.highlighters), n.flush(i);
+}
+function ht(l, e, t, r, i, n = 0, s = l.length) {
+  let o = n;
+  function a(h, u) {
+    if (!(h <= o)) {
+      for (let p = l.slice(o, h), c = 0; ; ) {
+        let m = p.indexOf(`
+`, c), k = m < 0 ? p.length : m;
+        if (k > c && r(p.slice(c, k), u), m < 0)
+          break;
+        i(), c = m + 1;
+      }
+      o = h;
+    }
+  }
+  Ue(e, t, (h, u, p) => {
+    a(h, ""), a(u, p);
+  }, n, s), a(s, "");
+}
+class ut {
+  constructor(e, t, r) {
+    this.at = e, this.highlighters = t, this.span = r, this.class = "";
+  }
+  startSpan(e, t) {
+    t != this.class && (this.flush(e), e > this.at && (this.at = e), this.class = t);
+  }
+  flush(e) {
+    e > this.at && this.class && this.span(this.at, e, this.class);
+  }
+  highlightRange(e, t, r, i, n) {
+    let { type: s, from: o, to: a } = e;
+    if (o >= r || a <= t)
+      return;
+    s.isTop && (n = this.highlighters.filter((m) => !m.scope || m.scope(s)));
+    let h = i, u = qe(e) || oe.empty, p = ft(n, u.tags);
+    if (p && (h && (h += " "), h += p, u.mode == 1 && (i += (i ? " " : "") + p)), this.startSpan(Math.max(t, o), h), u.opaque)
+      return;
+    let c = e.tree && e.tree.prop(A.mounted);
+    if (c && c.overlay) {
+      let m = e.node.enter(c.overlay[0].from + o, 1), k = this.highlighters.filter((M) => !M.scope || M.scope(c.tree.type)), P = e.firstChild();
+      for (let M = 0, E = o; ; M++) {
+        let z = M < c.overlay.length ? c.overlay[M] : null, C = z ? z.from + o : a, F = Math.max(t, E), x = Math.min(r, C);
+        if (F < x && P)
+          for (; e.from < x && (this.highlightRange(e, F, x, i, n), this.startSpan(Math.min(x, e.to), h), !(e.to >= C || !e.nextSibling())); )
+            ;
+        if (!z || C > r)
+          break;
+        E = z.to + o, E > t && (this.highlightRange(m.cursor(), Math.max(t, z.from + o), Math.min(r, E), "", k), this.startSpan(Math.min(r, E), h));
+      }
+      P && e.parent();
+    } else if (e.firstChild()) {
+      c && (i = "");
+      do
+        if (!(e.to <= t)) {
+          if (e.from >= r)
+            break;
+          this.highlightRange(e, t, r, i, n), this.startSpan(Math.min(r, e.to), h);
+        }
+      while (e.nextSibling());
+      e.parent();
+    }
+  }
+}
+function qe(l) {
+  let e = l.type.prop(Le);
+  for (; e && e.context && !l.matchContext(e.context); )
+    e = e.next;
+  return e || null;
+}
+const f = j.define, ue = f(), G = f(), Te = f(G), Re = f(G), Q = f(), pe = f(Q), ye = f(Q), J = f(), ee = f(J), U = f(), q = f(), ke = f(), ne = f(ke), ce = f(), y = {
+  /**
+  A comment.
+  */
+  comment: ue,
+  /**
+  A line [comment](#highlight.tags.comment).
+  */
+  lineComment: f(ue),
+  /**
+  A block [comment](#highlight.tags.comment).
+  */
+  blockComment: f(ue),
+  /**
+  A documentation [comment](#highlight.tags.comment).
+  */
+  docComment: f(ue),
+  /**
+  Any kind of identifier.
+  */
+  name: G,
+  /**
+  The [name](#highlight.tags.name) of a variable.
+  */
+  variableName: f(G),
+  /**
+  A type [name](#highlight.tags.name).
+  */
+  typeName: Te,
+  /**
+  A tag name (subtag of [`typeName`](#highlight.tags.typeName)).
+  */
+  tagName: f(Te),
+  /**
+  A property or field [name](#highlight.tags.name).
+  */
+  propertyName: Re,
+  /**
+  An attribute name (subtag of [`propertyName`](#highlight.tags.propertyName)).
+  */
+  attributeName: f(Re),
+  /**
+  The [name](#highlight.tags.name) of a class.
+  */
+  className: f(G),
+  /**
+  A label [name](#highlight.tags.name).
+  */
+  labelName: f(G),
+  /**
+  A namespace [name](#highlight.tags.name).
+  */
+  namespace: f(G),
+  /**
+  The [name](#highlight.tags.name) of a macro.
+  */
+  macroName: f(G),
+  /**
+  A literal value.
+  */
+  literal: Q,
+  /**
+  A string [literal](#highlight.tags.literal).
+  */
+  string: pe,
+  /**
+  A documentation [string](#highlight.tags.string).
+  */
+  docString: f(pe),
+  /**
+  A character literal (subtag of [string](#highlight.tags.string)).
+  */
+  character: f(pe),
+  /**
+  An attribute value (subtag of [string](#highlight.tags.string)).
+  */
+  attributeValue: f(pe),
+  /**
+  A number [literal](#highlight.tags.literal).
+  */
+  number: ye,
+  /**
+  An integer [number](#highlight.tags.number) literal.
+  */
+  integer: f(ye),
+  /**
+  A floating-point [number](#highlight.tags.number) literal.
+  */
+  float: f(ye),
+  /**
+  A boolean [literal](#highlight.tags.literal).
+  */
+  bool: f(Q),
+  /**
+  Regular expression [literal](#highlight.tags.literal).
+  */
+  regexp: f(Q),
+  /**
+  An escape [literal](#highlight.tags.literal), for example a
+  backslash escape in a string.
+  */
+  escape: f(Q),
+  /**
+  A color [literal](#highlight.tags.literal).
+  */
+  color: f(Q),
+  /**
+  A URL [literal](#highlight.tags.literal).
+  */
+  url: f(Q),
+  /**
+  A language keyword.
+  */
+  keyword: U,
+  /**
+  The [keyword](#highlight.tags.keyword) for the self or this
+  object.
+  */
+  self: f(U),
+  /**
+  The [keyword](#highlight.tags.keyword) for null.
+  */
+  null: f(U),
+  /**
+  A [keyword](#highlight.tags.keyword) denoting some atomic value.
+  */
+  atom: f(U),
+  /**
+  A [keyword](#highlight.tags.keyword) that represents a unit.
+  */
+  unit: f(U),
+  /**
+  A modifier [keyword](#highlight.tags.keyword).
+  */
+  modifier: f(U),
+  /**
+  A [keyword](#highlight.tags.keyword) that acts as an operator.
+  */
+  operatorKeyword: f(U),
+  /**
+  A control-flow related [keyword](#highlight.tags.keyword).
+  */
+  controlKeyword: f(U),
+  /**
+  A [keyword](#highlight.tags.keyword) that defines something.
+  */
+  definitionKeyword: f(U),
+  /**
+  A [keyword](#highlight.tags.keyword) related to defining or
+  interfacing with modules.
+  */
+  moduleKeyword: f(U),
+  /**
+  An operator.
+  */
+  operator: q,
+  /**
+  An [operator](#highlight.tags.operator) that dereferences something.
+  */
+  derefOperator: f(q),
+  /**
+  Arithmetic-related [operator](#highlight.tags.operator).
+  */
+  arithmeticOperator: f(q),
+  /**
+  Logical [operator](#highlight.tags.operator).
+  */
+  logicOperator: f(q),
+  /**
+  Bit [operator](#highlight.tags.operator).
+  */
+  bitwiseOperator: f(q),
+  /**
+  Comparison [operator](#highlight.tags.operator).
+  */
+  compareOperator: f(q),
+  /**
+  [Operator](#highlight.tags.operator) that updates its operand.
+  */
+  updateOperator: f(q),
+  /**
+  [Operator](#highlight.tags.operator) that defines something.
+  */
+  definitionOperator: f(q),
+  /**
+  Type-related [operator](#highlight.tags.operator).
+  */
+  typeOperator: f(q),
+  /**
+  Control-flow [operator](#highlight.tags.operator).
+  */
+  controlOperator: f(q),
+  /**
+  Program or markup punctuation.
+  */
+  punctuation: ke,
+  /**
+  [Punctuation](#highlight.tags.punctuation) that separates
+  things.
+  */
+  separator: f(ke),
+  /**
+  Bracket-style [punctuation](#highlight.tags.punctuation).
+  */
+  bracket: ne,
+  /**
+  Angle [brackets](#highlight.tags.bracket) (usually `<` and `>`
+  tokens).
+  */
+  angleBracket: f(ne),
+  /**
+  Square [brackets](#highlight.tags.bracket) (usually `[` and `]`
+  tokens).
+  */
+  squareBracket: f(ne),
+  /**
+  Parentheses (usually `(` and `)` tokens). Subtag of
+  [bracket](#highlight.tags.bracket).
+  */
+  paren: f(ne),
+  /**
+  Braces (usually `{` and `}` tokens). Subtag of
+  [bracket](#highlight.tags.bracket).
+  */
+  brace: f(ne),
+  /**
+  Content, for example plain text in XML or markup documents.
+  */
+  content: J,
+  /**
+  [Content](#highlight.tags.content) that represents a heading.
+  */
+  heading: ee,
+  /**
+  A level 1 [heading](#highlight.tags.heading).
+  */
+  heading1: f(ee),
+  /**
+  A level 2 [heading](#highlight.tags.heading).
+  */
+  heading2: f(ee),
+  /**
+  A level 3 [heading](#highlight.tags.heading).
+  */
+  heading3: f(ee),
+  /**
+  A level 4 [heading](#highlight.tags.heading).
+  */
+  heading4: f(ee),
+  /**
+  A level 5 [heading](#highlight.tags.heading).
+  */
+  heading5: f(ee),
+  /**
+  A level 6 [heading](#highlight.tags.heading).
+  */
+  heading6: f(ee),
+  /**
+  A prose [content](#highlight.tags.content) separator (such as a horizontal rule).
+  */
+  contentSeparator: f(J),
+  /**
+  [Content](#highlight.tags.content) that represents a list.
+  */
+  list: f(J),
+  /**
+  [Content](#highlight.tags.content) that represents a quote.
+  */
+  quote: f(J),
+  /**
+  [Content](#highlight.tags.content) that is emphasized.
+  */
+  emphasis: f(J),
+  /**
+  [Content](#highlight.tags.content) that is styled strong.
+  */
+  strong: f(J),
+  /**
+  [Content](#highlight.tags.content) that is part of a link.
+  */
+  link: f(J),
+  /**
+  [Content](#highlight.tags.content) that is styled as code or
+  monospace.
+  */
+  monospace: f(J),
+  /**
+  [Content](#highlight.tags.content) that has a strike-through
+  style.
+  */
+  strikethrough: f(J),
+  /**
+  Inserted text in a change-tracking format.
+  */
+  inserted: f(),
+  /**
+  Deleted text.
+  */
+  deleted: f(),
+  /**
+  Changed text.
+  */
+  changed: f(),
+  /**
+  An invalid or unsyntactic element.
+  */
+  invalid: f(),
+  /**
+  Metadata or meta-instruction.
+  */
+  meta: ce,
+  /**
+  [Metadata](#highlight.tags.meta) that applies to the entire
+  document.
+  */
+  documentMeta: f(ce),
+  /**
+  [Metadata](#highlight.tags.meta) that annotates or adds
+  attributes to a given syntactic element.
+  */
+  annotation: f(ce),
+  /**
+  Processing instruction or preprocessor directive. Subtag of
+  [meta](#highlight.tags.meta).
+  */
+  processingInstruction: f(ce),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates that a
+  given element is being defined. Expected to be used with the
+  various [name](#highlight.tags.name) tags.
+  */
+  definition: j.defineModifier("definition"),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates that
+  something is constant. Mostly expected to be used with
+  [variable names](#highlight.tags.variableName).
+  */
+  constant: j.defineModifier("constant"),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) used to indicate that
+  a [variable](#highlight.tags.variableName) or [property
+  name](#highlight.tags.propertyName) is being called or defined
+  as a function.
+  */
+  function: j.defineModifier("function"),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that can be applied to
+  [names](#highlight.tags.name) to indicate that they belong to
+  the language's standard environment.
+  */
+  standard: j.defineModifier("standard"),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates a given
+  [names](#highlight.tags.name) is local to some scope.
+  */
+  local: j.defineModifier("local"),
+  /**
+  A generic variant [modifier](#highlight.Tag^defineModifier) that
+  can be used to tag language-specific alternative variants of
+  some common tag. It is recommended for themes to define special
+  forms of at least the [string](#highlight.tags.string) and
+  [variable name](#highlight.tags.variableName) tags, since those
+  come up a lot.
+  */
+  special: j.defineModifier("special")
+};
+for (let l in y) {
+  let e = y[l];
+  e instanceof j && (e.name = l);
+}
+const pt = We([
+  { tag: y.link, class: "tok-link" },
+  { tag: y.heading, class: "tok-heading" },
+  { tag: y.emphasis, class: "tok-emphasis" },
+  { tag: y.strong, class: "tok-strong" },
+  { tag: y.keyword, class: "tok-keyword" },
+  { tag: y.atom, class: "tok-atom" },
+  { tag: y.bool, class: "tok-bool" },
+  { tag: y.url, class: "tok-url" },
+  { tag: y.labelName, class: "tok-labelName" },
+  { tag: y.inserted, class: "tok-inserted" },
+  { tag: y.deleted, class: "tok-deleted" },
+  { tag: y.literal, class: "tok-literal" },
+  { tag: y.string, class: "tok-string" },
+  { tag: y.number, class: "tok-number" },
+  { tag: [y.regexp, y.escape, y.special(y.string)], class: "tok-string2" },
+  { tag: y.variableName, class: "tok-variableName" },
+  { tag: y.local(y.variableName), class: "tok-variableName tok-local" },
+  { tag: y.definition(y.variableName), class: "tok-variableName tok-definition" },
+  { tag: y.special(y.variableName), class: "tok-variableName2" },
+  { tag: y.definition(y.propertyName), class: "tok-propertyName tok-definition" },
+  { tag: y.typeName, class: "tok-typeName" },
+  { tag: y.namespace, class: "tok-namespace" },
+  { tag: y.className, class: "tok-className" },
+  { tag: y.macroName, class: "tok-macroName" },
+  { tag: y.propertyName, class: "tok-propertyName" },
+  { tag: y.operator, class: "tok-operator" },
+  { tag: y.comment, class: "tok-comment" },
+  { tag: y.meta, class: "tok-meta" },
+  { tag: y.invalid, class: "tok-invalid" },
+  { tag: y.punctuation, class: "tok-punctuation" }
+]), yt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Tag: j,
+  classHighlighter: pt,
+  getStyleTags: qe,
+  highlightCode: ht,
+  highlightTree: Ue,
+  styleTags: at,
+  tagHighlighter: We,
+  tags: y
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ct as D,
+  v as I,
+  A as N,
+  gt as P,
+  j as T,
+  L as a,
+  je as b,
+  R as c,
+  dt as d,
+  We as e,
+  le as f,
+  Ue as h,
+  yt as i,
+  mt as p,
+  at as s,
+  y as t
+};