fec-dev-designer 1.0.0

package/es/node_modules/@lezer/common/dist/index.js

@@ -0,0 +1,1434 @@
+const Ce = 1024;
+let ge = 0;
+class Z {
+  constructor(e, t) {
+    this.from = e, this.to = t;
+  }
+}
+class k {
+  /**
+  Create a new node prop type.
+  */
+  constructor(e = {}) {
+    this.id = ge++, 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 = j.match(e)), (t) => {
+      let r = e(t);
+      return r === void 0 ? null : [this, r];
+    };
+  }
+}
+k.closedBy = new k({ deserialize: (l) => l.split(" ") });
+k.openedBy = new k({ deserialize: (l) => l.split(" ") });
+k.group = new k({ deserialize: (l) => l.split(" ") });
+k.isolate = new k({ deserialize: (l) => {
+  if (l && l != "rtl" && l != "ltr" && l != "auto")
+    throw new RangeError("Invalid value for isolate: " + l);
+  return l || "auto";
+} });
+k.contextHash = new k({ perNode: !0 });
+k.lookAhead = new k({ perNode: !0 });
+k.mounted = new k({ perNode: !0 });
+class V {
+  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[k.mounted.id];
+  }
+}
+const xe = /* @__PURE__ */ Object.create(null);
+class j {
+  /**
+  @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) : xe, r = (e.top ? 1 : 0) | (e.skipped ? 2 : 0) | (e.error ? 4 : 0) | (e.name == null ? 8 : 0), i = new j(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(k.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(k.group), n = -1; n < (i ? i.length : 0); n++) {
+        let s = t[n < 0 ? r.name : i[n]];
+        if (s)
+          return s;
+      }
+    };
+  }
+}
+j.none = new j(
+  "",
+  /* @__PURE__ */ Object.create(null),
+  0,
+  8
+  /* NodeFlag.Anonymous */
+);
+class ae {
+  /**
+  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 h = s[1], o = s[0];
+          o.combine && o.id in i && (h = o.combine(i[o.id], h)), i[o.id] = h;
+        }
+      }
+      t.push(i ? new j(r.name, i, r.id, r.flags) : r);
+    }
+    return new ae(t);
+  }
+}
+const Q = /* @__PURE__ */ new WeakMap(), fe = /* @__PURE__ */ new WeakMap();
+var _;
+(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";
+})(_ || (_ = {}));
+class P {
+  /**
+  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, h] of n)
+        this.props[typeof s == "number" ? s : s.id] = h;
+    }
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let e = V.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 te(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 = Q.get(this) || this.topNode, n = new te(i);
+    return n.moveTo(e, t), Q.set(this, n._tree), n;
+  }
+  /**
+  Get a [syntax node](#common.SyntaxNode) object for the top of the
+  tree.
+  */
+  get topNode() {
+    return new z(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 = $(Q.get(this) || this.topNode, e, t, !1);
+    return Q.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 = $(fe.get(this) || this.topNode, e, t, !0);
+    return fe.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 me(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, h = (s & _.IncludeAnonymous) > 0;
+    for (let o = this.cursor(s | _.IncludeAnonymous); ; ) {
+      let C = !1;
+      if (o.from <= n && o.to >= i && (!h && o.type.isAnonymous || t(o) !== !1)) {
+        if (o.firstChild())
+          continue;
+        C = !0;
+      }
+      for (; C && r && (h || !o.type.isAnonymous) && r(o), !o.nextSibling(); ) {
+        if (!o.parent())
+          return;
+        C = !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 : se(j.none, this.children, this.positions, 0, this.children.length, 0, this.length, (t, r, i) => new P(this.type, t, r, i, this.propValues), e.makeTree || ((t, r, i) => new P(j.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 we(e);
+  }
+}
+P.empty = new P(j.none, [], [], 0);
+class ie {
+  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 ie(this.buffer, this.index);
+  }
+}
+class M {
+  /**
+  Create a tree buffer.
+  */
+  constructor(e, t, r) {
+    this.buffer = e, this.length = t, this.set = r;
+  }
+  /**
+  @internal
+  */
+  get type() {
+    return j.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, h = -1;
+    for (let o = e; o != t && !(pe(n, i, s[o + 1], s[o + 2]) && (h = o, r > 0)); o = s[o + 3])
+      ;
+    return h;
+  }
+  /**
+  @internal
+  */
+  slice(e, t, r) {
+    let i = this.buffer, n = new Uint16Array(t - e), s = 0;
+    for (let h = e, o = 0; h < t; ) {
+      n[o++] = i[h++], n[o++] = i[h++] - r;
+      let C = n[o++] = i[h++] - r;
+      n[o++] = i[h++] - e, s = Math.max(s, C);
+    }
+    return new M(n, s, this.set);
+  }
+}
+function pe(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 $(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 z && l.index < 0 ? null : l.parent;
+    if (!s)
+      return l;
+    l = s;
+  }
+  let n = r ? 0 : _.IgnoreOverlays;
+  if (r)
+    for (let s = l, h = s.parent; h; s = h, h = s.parent)
+      s instanceof z && s.index < 0 && ((i = h.enter(e, t, n)) === null || i === void 0 ? void 0 : i.from) != s.from && (l = h);
+  for (; ; ) {
+    let s = l.enter(e, t, n);
+    if (!s)
+      return l;
+    l = s;
+  }
+}
+class de {
+  cursor(e = 0) {
+    return new te(this, e);
+  }
+  getChild(e, t = null, r = null) {
+    let i = ue(this, e, t, r);
+    return i.length ? i[0] : null;
+  }
+  getChildren(e, t = null, r = null) {
+    return ue(this, e, t, r);
+  }
+  resolve(e, t = 0) {
+    return $(this, e, t, !1);
+  }
+  resolveInner(e, t = 0) {
+    return $(this, e, t, !0);
+  }
+  matchContext(e) {
+    return ee(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 z 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: h, positions: o } = s._tree, C = t > 0 ? h.length : -1; e != C; e += t) {
+        let p = h[e], w = o[e] + s.from, A;
+        if (!(!(n & _.EnterBracketed && p instanceof P && (A = V.get(p)) && !A.overlay && A.bracketed && r >= w && r <= w + p.length) && !pe(i, r, w, w + p.length))) {
+          if (p instanceof M) {
+            if (n & _.ExcludeBuffers)
+              continue;
+            let N = p.findChild(0, p.buffer.length, t, r - w, i);
+            if (N > -1)
+              return new O(new be(s, p, e, w), null, N);
+          } else if (n & _.IncludeAnonymous || !p.type.isAnonymous || ne(p)) {
+            let N;
+            if (!(n & _.IgnoreMounts) && (N = V.get(p)) && !N.overlay)
+              return new z(N.tree, w, e, s);
+            let S = new z(p, w, e, s);
+            return n & _.IncludeAnonymous || !S.type.isAnonymous ? S : S.nextChild(t < 0 ? p.children.length - 1 : 0, t, r, i, n);
+          }
+        }
+      }
+      if (n & _.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 & _.IgnoreOverlays) && (i = V.get(this._tree)) && i.overlay) {
+      let n = e - this.from, s = r & _.EnterBracketed && i.bracketed;
+      for (let { from: h, to: o } of i.overlay)
+        if ((t > 0 || s ? h <= n : h < n) && (t < 0 || s ? o >= n : o > n))
+          return new z(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 ue(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 ee(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 be {
+  constructor(e, t, r, i) {
+    this.parent = e, this.buffer = t, this.index = r, this.start = i;
+  }
+}
+class O 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 O(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 & _.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 O(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 O(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 O(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 P(this.type, e, t, this.to - this.from);
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.context.buffer.childString(this.index);
+  }
+}
+function ce(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 z && t.index < 0 ? null : t.parent, i = l.slice();
+  return r ? i[e] = r : i.splice(e, 1), new ye(i, t);
+}
+class ye {
+  constructor(e, t) {
+    this.heads = e, this.node = t;
+  }
+  get next() {
+    return ce(this.heads);
+  }
+}
+function me(l, e, t) {
+  let r = l.resolveInner(e, t), i = null;
+  for (let n = r instanceof z ? 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 = V.get(n.tree);
+      if (s && s.overlay && s.overlay[0].from <= e && s.overlay[s.overlay.length - 1].to >= e) {
+        let h = new z(s.tree, s.overlay[0].from + n.from, -1, n);
+        (i || (i = [r])).push($(h, e, t, !1));
+      }
+    }
+  return i ? ce(i) : r;
+}
+class te {
+  /**
+  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 & ~_.EnterBracketed, e instanceof z)
+      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 z ? (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 & _.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 & _.IncludeAnonymous ? this._tree._parent : this._tree.parent);
+    if (this.stack.length)
+      return this.yieldBuf(this.stack.pop());
+    let e = this.mode & _.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 h = r._tree.children[n];
+          if (this.mode & _.IncludeAnonymous || h instanceof M || !h.type.isAnonymous || ne(h))
+            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 O(this.buffer, t, this.stack[i]);
+    return this.bufferNode = new O(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 ee(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 ee(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 ne(l) {
+  return l.children.some((e) => e instanceof M || !e.type.isAnonymous || ne(e));
+}
+function we(l) {
+  var e;
+  let { buffer: t, nodeSet: r, maxBufferLength: i = 1024, reused: n = [], minRepeatType: s = r.types.length } = l, h = Array.isArray(t) ? new ie(t, t.length) : t, o = r.types, C = 0, p = 0;
+  function w(c, x, f, y, d, m) {
+    let { id: a, start: u, end: g, size: b } = h, v = p, W = C;
+    if (b < 0)
+      if (h.next(), b == -1) {
+        let R = n[a];
+        f.push(R), y.push(u - c);
+        return;
+      } else if (b == -3) {
+        C = a;
+        return;
+      } else if (b == -4) {
+        p = a;
+        return;
+      } else
+        throw new RangeError(`Unrecognized record size: ${b}`);
+    let J = o[a], q, D, le = u - c;
+    if (g - u <= i && (D = Y(h.pos - x, d))) {
+      let R = new Uint16Array(D.size - D.skip), I = h.pos - D.size, E = R.length;
+      for (; h.pos > I; )
+        E = G(D.start, R, E);
+      q = new M(R, g - D.start, r), le = D.start - c;
+    } else {
+      let R = h.pos - b;
+      h.next();
+      let I = [], E = [], F = a >= s ? a : -1, H = 0, K = g;
+      for (; h.pos > R; )
+        F >= 0 && h.id == F && h.size >= 0 ? (h.end <= K - i && (S(I, E, u, H, h.end, K, F, v, W), H = I.length, K = h.end), h.next()) : m > 2500 ? A(u, R, I, E) : w(u, R, I, E, F, m + 1);
+      if (F >= 0 && H > 0 && H < I.length && S(I, E, u, H, u, K, F, v, W), I.reverse(), E.reverse(), F > -1 && H > 0) {
+        let he = N(J, W);
+        q = se(J, I, E, 0, I.length, 0, g - u, he, he);
+      } else
+        q = L(J, I, E, g - u, v - g, W);
+    }
+    f.push(q), y.push(le);
+  }
+  function A(c, x, f, y) {
+    let d = [], m = 0, a = -1;
+    for (; h.pos > x; ) {
+      let { id: u, start: g, end: b, size: v } = h;
+      if (v > 4)
+        h.next();
+      else {
+        if (a > -1 && g < a)
+          break;
+        a < 0 && (a = b - i), d.push(u, g, b), m++, h.next();
+      }
+    }
+    if (m) {
+      let u = new Uint16Array(m * 4), g = d[d.length - 2];
+      for (let b = d.length - 3, v = 0; b >= 0; b -= 3)
+        u[v++] = d[b], u[v++] = d[b + 1] - g, u[v++] = d[b + 2] - g, u[v++] = v;
+      f.push(new M(u, d[2] - g, r)), y.push(g - c);
+    }
+  }
+  function N(c, x) {
+    return (f, y, d) => {
+      let m = 0, a = f.length - 1, u, g;
+      if (a >= 0 && (u = f[a]) instanceof P) {
+        if (!a && u.type == c && u.length == d)
+          return u;
+        (g = u.prop(k.lookAhead)) && (m = y[a] + u.length + g);
+      }
+      return L(c, f, y, d, m, x);
+    };
+  }
+  function S(c, x, f, y, d, m, a, u, g) {
+    let b = [], v = [];
+    for (; c.length > y; )
+      b.push(c.pop()), v.push(x.pop() + f - d);
+    c.push(L(r.types[a], b, v, m - d, u - m, g)), x.push(d - f);
+  }
+  function L(c, x, f, y, d, m, a) {
+    if (m) {
+      let u = [k.contextHash, m];
+      a = a ? [u].concat(a) : [u];
+    }
+    if (d > 25) {
+      let u = [k.lookAhead, d];
+      a = a ? [u].concat(a) : [u];
+    }
+    return new P(c, x, f, y, a);
+  }
+  function Y(c, x) {
+    let f = h.fork(), y = 0, d = 0, m = 0, a = f.end - i, u = { size: 0, start: 0, skip: 0 };
+    e:
+      for (let g = f.pos - c; f.pos > g; ) {
+        let b = f.size;
+        if (f.id == x && b >= 0) {
+          u.size = y, u.start = d, u.skip = m, m += 4, y += 4, f.next();
+          continue;
+        }
+        let v = f.pos - b;
+        if (b < 0 || v < g || f.start < a)
+          break;
+        let W = f.id >= s ? 4 : 0, J = f.start;
+        for (f.next(); f.pos > v; ) {
+          if (f.size < 0)
+            if (f.size == -3 || f.size == -4)
+              W += 4;
+            else
+              break e;
+          else
+            f.id >= s && (W += 4);
+          f.next();
+        }
+        d = J, y += b, m += W;
+      }
+    return (x < 0 || y == c) && (u.size = y, u.start = d, u.skip = m), u.size > 4 ? u : void 0;
+  }
+  function G(c, x, f) {
+    let { id: y, start: d, end: m, size: a } = h;
+    if (h.next(), a >= 0 && y < s) {
+      let u = f;
+      if (a > 4) {
+        let g = h.pos - (a - 4);
+        for (; h.pos > g; )
+          f = G(c, x, f);
+      }
+      x[--f] = u, x[--f] = m - c, x[--f] = d - c, x[--f] = y;
+    } else
+      a == -3 ? C = y : a == -4 && (p = y);
+    return f;
+  }
+  let T = [], B = [];
+  for (; h.pos > 0; )
+    w(l.start || 0, l.bufferStart || 0, T, B, -1, 0);
+  let U = (e = l.length) !== null && e !== void 0 ? e : T.length ? B[0] + T[0].length : 0;
+  return new P(o[l.topID], T.reverse(), B.reverse(), U);
+}
+const oe = /* @__PURE__ */ new WeakMap();
+function X(l, e) {
+  if (!l.isAnonymous || e instanceof M || e.type != l)
+    return 1;
+  let t = oe.get(e);
+  if (t == null) {
+    t = 1;
+    for (let r of e.children) {
+      if (r.type != l || !(r instanceof P)) {
+        t = 1;
+        break;
+      }
+      t += X(l, r);
+    }
+    oe.set(e, t);
+  }
+  return t;
+}
+function se(l, e, t, r, i, n, s, h, o) {
+  let C = 0;
+  for (let S = r; S < i; S++)
+    C += X(l, e[S]);
+  let p = Math.ceil(
+    C * 1.5 / 8
+    /* Balance.BranchFactor */
+  ), w = [], A = [];
+  function N(S, L, Y, G, T) {
+    for (let B = Y; B < G; ) {
+      let U = B, c = L[B], x = X(l, S[B]);
+      for (B++; B < G; B++) {
+        let f = X(l, S[B]);
+        if (x + f >= p)
+          break;
+        x += f;
+      }
+      if (B == U + 1) {
+        if (x > p) {
+          let f = S[U];
+          N(f.children, f.positions, 0, f.children.length, L[U] + T);
+          continue;
+        }
+        w.push(S[U]);
+      } else {
+        let f = L[B - 1] + S[B - 1].length - c;
+        w.push(se(l, S, L, U, B, c, f, null, o));
+      }
+      A.push(c + T - n);
+    }
+  }
+  return N(e, t, r, i, 0), (h || o)(w, A, s);
+}
+class Se {
+  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 O ? this.setBuffer(e.context.buffer, e.index, t) : e instanceof z && this.map.set(e.tree, t);
+  }
+  /**
+  Retrieve value for this syntax node, if it exists in the map.
+  */
+  get(e) {
+    return e instanceof O ? this.getBuffer(e.context.buffer, e.index) : e instanceof z ? 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 re {
+  /**
+  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 re(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 h = 0, o = 0, C = 0; ; h++) {
+      let p = h < t.length ? t[h] : null, w = p ? p.fromA : 1e9;
+      if (w - o >= r)
+        for (; s && s.from < w; ) {
+          let A = s;
+          if (o >= A.from || w <= A.to || C) {
+            let N = Math.max(A.from, o) - C, S = Math.min(A.to, w) - C;
+            A = N >= S ? null : new re(N, S, A.tree, A.offset + C, h > 0, !!p);
+          }
+          if (A && i.push(A), s.to > w)
+            break;
+          s = n < e.length ? e[n++] : null;
+        }
+      if (!p)
+        break;
+      o = p.toA, C = p.toA - p.toB;
+    }
+    return i;
+  }
+}
+class _e {
+  /**
+  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 ke(e)), r = r ? r.length ? r.map((i) => new Z(i.from, i.to)) : [new Z(0, 0)] : [new Z(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 ke {
+  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);
+  }
+}
+new k({ perNode: !0 });
+export {
+  Ce as DefaultBufferLength,
+  _ as IterMode,
+  V as MountedTree,
+  k as NodeProp,
+  ae as NodeSet,
+  j as NodeType,
+  Se as NodeWeakMap,
+  _e as Parser,
+  P as Tree,
+  M as TreeBuffer,
+  te as TreeCursor,
+  re as TreeFragment
+};