@vuu-ui/vuu-data-test 0.8.18-debug → 0.8.19-debug

package/esm/index.js

@@ -879,4658 +879,132 @@ var getSchema = (tableName) => {
   throw Error(`getSchema no schema for table ${tableName}`);
 };
 
-// ../../node_modules/@lezer/common/dist/index.js
-var DefaultBufferLength = 1024;
-var nextPropID = 0;
-var Range = class {
-  constructor(from, to) {
-    this.from = from;
-    this.to = to;
-  }
-};
-var NodeProp = class {
-  /// Create a new node prop type.
-  constructor(config = {}) {
-    this.id = nextPropID++;
-    this.perNode = !!config.perNode;
-    this.deserialize = config.deserialize || (() => {
-      throw new Error("This node type doesn't define a deserialize function");
-    });
-  }
-  /// 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(match) {
-    if (this.perNode)
-      throw new RangeError("Can't add per-node props to node types");
-    if (typeof match != "function")
-      match = NodeType.match(match);
-    return (type) => {
-      let result = match(type);
-      return result === void 0 ? null : [this, result];
-    };
-  }
-};
-NodeProp.closedBy = new NodeProp({ deserialize: (str) => str.split(" ") });
-NodeProp.openedBy = new NodeProp({ deserialize: (str) => str.split(" ") });
-NodeProp.group = new NodeProp({ deserialize: (str) => str.split(" ") });
-NodeProp.contextHash = new NodeProp({ perNode: true });
-NodeProp.lookAhead = new NodeProp({ perNode: true });
-NodeProp.mounted = new NodeProp({ perNode: true });
-var noProps = /* @__PURE__ */ Object.create(null);
-var NodeType = class _NodeType {
-  /// @internal
-  constructor(name, props, id, flags = 0) {
-    this.name = name;
-    this.props = props;
-    this.id = id;
-    this.flags = flags;
-  }
-  /// Define a node type.
-  static define(spec) {
-    let props = spec.props && spec.props.length ? /* @__PURE__ */ Object.create(null) : noProps;
-    let flags = (spec.top ? 1 : 0) | (spec.skipped ? 2 : 0) | (spec.error ? 4 : 0) | (spec.name == null ? 8 : 0);
-    let type = new _NodeType(spec.name || "", props, spec.id, flags);
-    if (spec.props)
-      for (let src of spec.props) {
-        if (!Array.isArray(src))
-          src = src(type);
-        if (src) {
-          if (src[0].perNode)
-            throw new RangeError("Can't store a per-node prop on a node type");
-          props[src[0].id] = src[1];
-        }
-      }
-    return type;
-  }
-  /// Retrieves a node prop for this type. Will return `undefined` if
-  /// the prop isn't present on this node.
-  prop(prop) {
-    return this.props[prop.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(name) {
-    if (typeof name == "string") {
-      if (this.name == name)
-        return true;
-      let group = this.prop(NodeProp.group);
-      return group ? group.indexOf(name) > -1 : false;
-    }
-    return this.id == name;
-  }
-  /// 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(map) {
-    let direct = /* @__PURE__ */ Object.create(null);
-    for (let prop in map)
-      for (let name of prop.split(" "))
-        direct[name] = map[prop];
-    return (node) => {
-      for (let groups = node.prop(NodeProp.group), i = -1; i < (groups ? groups.length : 0); i++) {
-        let found = direct[i < 0 ? node.name : groups[i]];
-        if (found)
-          return found;
-      }
-    };
-  }
-};
-NodeType.none = new NodeType(
-  "",
-  /* @__PURE__ */ Object.create(null),
-  0,
-  8
-  /* NodeFlag.Anonymous */
-);
-var NodeSet = class _NodeSet {
-  /// Create a set with the given types. The `id` property of each
-  /// type should correspond to its position within the array.
-  constructor(types) {
-    this.types = types;
-    for (let i = 0; i < types.length; i++)
-      if (types[i].id != i)
-        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(...props) {
-    let newTypes = [];
-    for (let type of this.types) {
-      let newProps = null;
-      for (let source of props) {
-        let add = source(type);
-        if (add) {
-          if (!newProps)
-            newProps = Object.assign({}, type.props);
-          newProps[add[0].id] = add[1];
-        }
-      }
-      newTypes.push(newProps ? new NodeType(type.name, newProps, type.id, type.flags) : type);
-    }
-    return new _NodeSet(newTypes);
-  }
-};
-var CachedNode = /* @__PURE__ */ new WeakMap();
-var CachedInnerNode = /* @__PURE__ */ new WeakMap();
-var IterMode;
-(function(IterMode2) {
-  IterMode2[IterMode2["ExcludeBuffers"] = 1] = "ExcludeBuffers";
-  IterMode2[IterMode2["IncludeAnonymous"] = 2] = "IncludeAnonymous";
-  IterMode2[IterMode2["IgnoreMounts"] = 4] = "IgnoreMounts";
-  IterMode2[IterMode2["IgnoreOverlays"] = 8] = "IgnoreOverlays";
-})(IterMode || (IterMode = {}));
-var Tree = class _Tree {
-  /// Construct a new tree. See also [`Tree.build`](#common.Tree^build).
-  constructor(type, children, positions, length2, props) {
-    this.type = type;
-    this.children = children;
-    this.positions = positions;
-    this.length = length2;
-    this.props = null;
-    if (props && props.length) {
-      this.props = /* @__PURE__ */ Object.create(null);
-      for (let [prop, value] of props)
-        this.props[typeof prop == "number" ? prop : prop.id] = value;
-    }
-  }
-  /// @internal
-  toString() {
-    let mounted = this.prop(NodeProp.mounted);
-    if (mounted && !mounted.overlay)
-      return mounted.tree.toString();
-    let children = "";
-    for (let ch of this.children) {
-      let str = ch.toString();
-      if (str) {
-        if (children)
-          children += ",";
-        children += str;
-      }
-    }
-    return !this.type.name ? children : (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (children.length ? "(" + children + ")" : "");
-  }
-  /// 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(mode = 0) {
-    return new TreeCursor(this.topNode, mode);
-  }
-  /// Get a [tree cursor](#common.TreeCursor) pointing into this tree
-  /// at the given position and side (see
-  /// [`moveTo`](#common.TreeCursor.moveTo).
-  cursorAt(pos, side = 0, mode = 0) {
-    let scope = CachedNode.get(this) || this.topNode;
-    let cursor = new TreeCursor(scope);
-    cursor.moveTo(pos, side);
-    CachedNode.set(this, cursor._tree);
-    return cursor;
-  }
-  /// Get a [syntax node](#common.SyntaxNode) object for the top of the
-  /// tree.
-  get topNode() {
-    return new TreeNode(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(pos, side = 0) {
-    let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
-    CachedNode.set(this, node);
-    return node;
-  }
-  /// 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(pos, side = 0) {
-    let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
-    CachedInnerNode.set(this, node);
-    return node;
-  }
-  /// 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(spec) {
-    let { enter, leave, from = 0, to = this.length } = spec;
-    let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0;
-    for (let c = this.cursor(mode | IterMode.IncludeAnonymous); ; ) {
-      let entered = false;
-      if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== false)) {
-        if (c.firstChild())
-          continue;
-        entered = true;
-      }
-      for (; ; ) {
-        if (entered && leave && (anon || !c.type.isAnonymous))
-          leave(c);
-        if (c.nextSibling())
-          break;
-        if (!c.parent())
-          return;
-        entered = true;
-      }
-    }
-  }
-  /// Get the value of the given [node prop](#common.NodeProp) for this
-  /// node. Works with both per-node and per-type props.
-  prop(prop) {
-    return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : void 0;
-  }
-  /// 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 result = [];
-    if (this.props)
-      for (let id in this.props)
-        result.push([+id, this.props[id]]);
-    return result;
-  }
-  /// 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(config = {}) {
-    return this.children.length <= 8 ? this : balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length2) => new _Tree(this.type, children, positions, length2, this.propValues), config.makeTree || ((children, positions, length2) => new _Tree(NodeType.none, children, positions, length2)));
-  }
-  /// Build a tree from a postfix-ordered buffer of node information,
-  /// or a cursor over such a buffer.
-  static build(data) {
-    return buildTree(data);
-  }
-};
-Tree.empty = new Tree(NodeType.none, [], [], 0);
-var FlatBufferCursor = class _FlatBufferCursor {
-  constructor(buffer, index) {
-    this.buffer = buffer;
-    this.index = index;
-  }
-  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 _FlatBufferCursor(this.buffer, this.index);
-  }
-};
-var TreeBuffer = class _TreeBuffer {
-  /// Create a tree buffer.
-  constructor(buffer, length2, set) {
-    this.buffer = buffer;
-    this.length = length2;
-    this.set = set;
-  }
-  /// @internal
-  get type() {
-    return NodeType.none;
-  }
-  /// @internal
-  toString() {
-    let result = [];
-    for (let index = 0; index < this.buffer.length; ) {
-      result.push(this.childString(index));
-      index = this.buffer[index + 3];
-    }
-    return result.join(",");
-  }
-  /// @internal
-  childString(index) {
-    let id = this.buffer[index], endIndex = this.buffer[index + 3];
-    let type = this.set.types[id], result = type.name;
-    if (/\W/.test(result) && !type.isError)
-      result = JSON.stringify(result);
-    index += 4;
-    if (endIndex == index)
-      return result;
-    let children = [];
-    while (index < endIndex) {
-      children.push(this.childString(index));
-      index = this.buffer[index + 3];
-    }
-    return result + "(" + children.join(",") + ")";
-  }
-  /// @internal
-  findChild(startIndex, endIndex, dir, pos, side) {
-    let { buffer } = this, pick = -1;
-    for (let i = startIndex; i != endIndex; i = buffer[i + 3]) {
-      if (checkSide(side, pos, buffer[i + 1], buffer[i + 2])) {
-        pick = i;
-        if (dir > 0)
-          break;
-      }
-    }
-    return pick;
-  }
-  /// @internal
-  slice(startI, endI, from) {
-    let b = this.buffer;
-    let copy = new Uint16Array(endI - startI), len = 0;
-    for (let i = startI, j = 0; i < endI; ) {
-      copy[j++] = b[i++];
-      copy[j++] = b[i++] - from;
-      let to = copy[j++] = b[i++] - from;
-      copy[j++] = b[i++] - startI;
-      len = Math.max(len, to);
-    }
-    return new _TreeBuffer(copy, len, this.set);
-  }
-};
-function checkSide(side, pos, from, to) {
-  switch (side) {
-    case -2:
-      return from < pos;
-    case -1:
-      return to >= pos && from < pos;
-    case 0:
-      return from < pos && to > pos;
-    case 1:
-      return from <= pos && to > pos;
-    case 2:
-      return to > pos;
-    case 4:
-      return true;
-  }
-}
-function enterUnfinishedNodesBefore(node, pos) {
-  let scan = node.childBefore(pos);
-  while (scan) {
-    let last2 = scan.lastChild;
-    if (!last2 || last2.to != scan.to)
-      break;
-    if (last2.type.isError && last2.from == last2.to) {
-      node = scan;
-      scan = last2.prevSibling;
-    } else {
-      scan = last2;
-    }
-  }
-  return node;
-}
-function resolveNode(node, pos, side, overlays) {
-  var _a;
-  while (node.from == node.to || (side < 1 ? node.from >= pos : node.from > pos) || (side > -1 ? node.to <= pos : node.to < pos)) {
-    let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
-    if (!parent)
-      return node;
-    node = parent;
-  }
-  let mode = overlays ? 0 : IterMode.IgnoreOverlays;
-  if (overlays)
-    for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
-      if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
-        node = parent;
-    }
-  for (; ; ) {
-    let inner = node.enter(pos, side, mode);
-    if (!inner)
-      return node;
-    node = inner;
-  }
-}
-var TreeNode = class _TreeNode {
-  constructor(_tree, from, index, _parent) {
-    this._tree = _tree;
-    this.from = from;
-    this.index = index;
-    this._parent = _parent;
-  }
-  get type() {
-    return this._tree.type;
-  }
-  get name() {
-    return this._tree.type.name;
-  }
-  get to() {
-    return this.from + this._tree.length;
-  }
-  nextChild(i, dir, pos, side, mode = 0) {
-    for (let parent = this; ; ) {
-      for (let { children, positions } = parent._tree, e = dir > 0 ? children.length : -1; i != e; i += dir) {
-        let next = children[i], start = positions[i] + parent.from;
-        if (!checkSide(side, pos, start, start + next.length))
-          continue;
-        if (next instanceof TreeBuffer) {
-          if (mode & IterMode.ExcludeBuffers)
-            continue;
-          let index = next.findChild(0, next.buffer.length, dir, pos - start, side);
-          if (index > -1)
-            return new BufferNode(new BufferContext(parent, next, i, start), null, index);
-        } else if (mode & IterMode.IncludeAnonymous || (!next.type.isAnonymous || hasChild(next))) {
-          let mounted;
-          if (!(mode & IterMode.IgnoreMounts) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
-            return new _TreeNode(mounted.tree, start, i, parent);
-          let inner = new _TreeNode(next, start, i, parent);
-          return mode & IterMode.IncludeAnonymous || !inner.type.isAnonymous ? inner : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
-        }
-      }
-      if (mode & IterMode.IncludeAnonymous || !parent.type.isAnonymous)
-        return null;
-      if (parent.index >= 0)
-        i = parent.index + dir;
-      else
-        i = dir < 0 ? -1 : parent._parent._tree.children.length;
-      parent = parent._parent;
-      if (!parent)
-        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(pos) {
-    return this.nextChild(
-      0,
-      1,
-      pos,
-      2
-      /* Side.After */
-    );
-  }
-  childBefore(pos) {
-    return this.nextChild(
-      this._tree.children.length - 1,
-      -1,
-      pos,
-      -2
-      /* Side.Before */
-    );
-  }
-  enter(pos, side, mode = 0) {
-    let mounted;
-    if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {
-      let rPos = pos - this.from;
-      for (let { from, to } of mounted.overlay) {
-        if ((side > 0 ? from <= rPos : from < rPos) && (side < 0 ? to >= rPos : to > rPos))
-          return new _TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);
-      }
-    }
-    return this.nextChild(0, 1, pos, side, mode);
-  }
-  nextSignificantParent() {
-    let val = this;
-    while (val.type.isAnonymous && val._parent)
-      val = val._parent;
-    return val;
-  }
-  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;
-  }
-  cursor(mode = 0) {
-    return new TreeCursor(this, mode);
-  }
-  get tree() {
-    return this._tree;
-  }
-  toTree() {
-    return this._tree;
-  }
-  resolve(pos, side = 0) {
-    return resolveNode(this, pos, side, false);
-  }
-  resolveInner(pos, side = 0) {
-    return resolveNode(this, pos, side, true);
-  }
-  enterUnfinishedNodesBefore(pos) {
-    return enterUnfinishedNodesBefore(this, pos);
-  }
-  getChild(type, before = null, after = null) {
-    let r = getChildren(this, type, before, after);
-    return r.length ? r[0] : null;
-  }
-  getChildren(type, before = null, after = null) {
-    return getChildren(this, type, before, after);
-  }
-  /// @internal
-  toString() {
-    return this._tree.toString();
-  }
-  get node() {
-    return this;
-  }
-  matchContext(context) {
-    return matchNodeContext(this, context);
-  }
-};
-function getChildren(node, type, before, after) {
-  let cur = node.cursor(), result = [];
-  if (!cur.firstChild())
-    return result;
-  if (before != null) {
-    while (!cur.type.is(before))
-      if (!cur.nextSibling())
-        return result;
-  }
-  for (; ; ) {
-    if (after != null && cur.type.is(after))
-      return result;
-    if (cur.type.is(type))
-      result.push(cur.node);
-    if (!cur.nextSibling())
-      return after == null ? result : [];
-  }
-}
-function matchNodeContext(node, context, i = context.length - 1) {
-  for (let p = node.parent; i >= 0; p = p.parent) {
-    if (!p)
-      return false;
-    if (!p.type.isAnonymous) {
-      if (context[i] && context[i] != p.name)
-        return false;
-      i--;
-    }
-  }
-  return true;
-}
-var BufferContext = class {
-  constructor(parent, buffer, index, start) {
-    this.parent = parent;
-    this.buffer = buffer;
-    this.index = index;
-    this.start = start;
-  }
-};
-var BufferNode = class _BufferNode {
-  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(context, _parent, index) {
-    this.context = context;
-    this._parent = _parent;
-    this.index = index;
-    this.type = context.buffer.set.types[context.buffer.buffer[index]];
-  }
-  child(dir, pos, side) {
-    let { buffer } = this.context;
-    let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.context.start, side);
-    return index < 0 ? null : new _BufferNode(this.context, this, index);
-  }
-  get firstChild() {
-    return this.child(
-      1,
-      0,
-      4
-      /* Side.DontCare */
-    );
-  }
-  get lastChild() {
-    return this.child(
-      -1,
-      0,
-      4
-      /* Side.DontCare */
-    );
-  }
-  childAfter(pos) {
-    return this.child(
-      1,
-      pos,
-      2
-      /* Side.After */
-    );
-  }
-  childBefore(pos) {
-    return this.child(
-      -1,
-      pos,
-      -2
-      /* Side.Before */
-    );
-  }
-  enter(pos, side, mode = 0) {
-    if (mode & IterMode.ExcludeBuffers)
-      return null;
-    let { buffer } = this.context;
-    let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);
-    return index < 0 ? null : new _BufferNode(this.context, this, index);
-  }
-  get parent() {
-    return this._parent || this.context.parent.nextSignificantParent();
-  }
-  externalSibling(dir) {
-    return this._parent ? null : this.context.parent.nextChild(
-      this.context.index + dir,
-      dir,
-      0,
-      4
-      /* Side.DontCare */
-    );
-  }
-  get nextSibling() {
-    let { buffer } = this.context;
-    let after = buffer.buffer[this.index + 3];
-    if (after < (this._parent ? buffer.buffer[this._parent.index + 3] : buffer.buffer.length))
-      return new _BufferNode(this.context, this._parent, after);
-    return this.externalSibling(1);
-  }
-  get prevSibling() {
-    let { buffer } = this.context;
-    let parentStart = this._parent ? this._parent.index + 4 : 0;
-    if (this.index == parentStart)
-      return this.externalSibling(-1);
-    return new _BufferNode(this.context, this._parent, buffer.findChild(
-      parentStart,
-      this.index,
-      -1,
-      0,
-      4
-      /* Side.DontCare */
-    ));
-  }
-  cursor(mode = 0) {
-    return new TreeCursor(this, mode);
-  }
-  get tree() {
-    return null;
-  }
-  toTree() {
-    let children = [], positions = [];
-    let { buffer } = this.context;
-    let startI = this.index + 4, endI = buffer.buffer[this.index + 3];
-    if (endI > startI) {
-      let from = buffer.buffer[this.index + 1];
-      children.push(buffer.slice(startI, endI, from));
-      positions.push(0);
-    }
-    return new Tree(this.type, children, positions, this.to - this.from);
-  }
-  resolve(pos, side = 0) {
-    return resolveNode(this, pos, side, false);
-  }
-  resolveInner(pos, side = 0) {
-    return resolveNode(this, pos, side, true);
-  }
-  enterUnfinishedNodesBefore(pos) {
-    return enterUnfinishedNodesBefore(this, pos);
-  }
-  /// @internal
-  toString() {
-    return this.context.buffer.childString(this.index);
-  }
-  getChild(type, before = null, after = null) {
-    let r = getChildren(this, type, before, after);
-    return r.length ? r[0] : null;
-  }
-  getChildren(type, before = null, after = null) {
-    return getChildren(this, type, before, after);
-  }
-  get node() {
-    return this;
-  }
-  matchContext(context) {
-    return matchNodeContext(this, context);
-  }
-};
-var TreeCursor = class {
-  /// Shorthand for `.type.name`.
-  get name() {
-    return this.type.name;
-  }
-  /// @internal
-  constructor(node, mode = 0) {
-    this.mode = mode;
-    this.buffer = null;
-    this.stack = [];
-    this.index = 0;
-    this.bufferNode = null;
-    if (node instanceof TreeNode) {
-      this.yieldNode(node);
-    } else {
-      this._tree = node.context.parent;
-      this.buffer = node.context;
-      for (let n = node._parent; n; n = n._parent)
-        this.stack.unshift(n.index);
-      this.bufferNode = node;
-      this.yieldBuf(node.index);
-    }
-  }
-  yieldNode(node) {
-    if (!node)
-      return false;
-    this._tree = node;
-    this.type = node.type;
-    this.from = node.from;
-    this.to = node.to;
-    return true;
-  }
-  yieldBuf(index, type) {
-    this.index = index;
-    let { start, buffer } = this.buffer;
-    this.type = type || buffer.set.types[buffer.buffer[index]];
-    this.from = start + buffer.buffer[index + 1];
-    this.to = start + buffer.buffer[index + 2];
-    return true;
-  }
-  yield(node) {
-    if (!node)
-      return false;
-    if (node instanceof TreeNode) {
-      this.buffer = null;
-      return this.yieldNode(node);
-    }
-    this.buffer = node.context;
-    return this.yieldBuf(node.index, node.type);
-  }
-  /// @internal
-  toString() {
-    return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
-  }
-  /// @internal
-  enterChild(dir, pos, side) {
-    if (!this.buffer)
-      return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode));
-    let { buffer } = this.buffer;
-    let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);
-    if (index < 0)
-      return false;
-    this.stack.push(this.index);
-    return this.yieldBuf(index);
-  }
-  /// 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(pos) {
-    return this.enterChild(
-      1,
-      pos,
-      2
-      /* Side.After */
-    );
-  }
-  /// Move to the last child that starts before `pos`.
-  childBefore(pos) {
-    return this.enterChild(
-      -1,
-      pos,
-      -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(pos, side, mode = this.mode) {
-    if (!this.buffer)
-      return this.yield(this._tree.enter(pos, side, mode));
-    return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);
-  }
-  /// Move to the node's parent node, if this isn't the top node.
-  parent() {
-    if (!this.buffer)
-      return this.yieldNode(this.mode & IterMode.IncludeAnonymous ? this._tree._parent : this._tree.parent);
-    if (this.stack.length)
-      return this.yieldBuf(this.stack.pop());
-    let parent = this.mode & IterMode.IncludeAnonymous ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
-    this.buffer = null;
-    return this.yieldNode(parent);
-  }
-  /// @internal
-  sibling(dir) {
-    if (!this.buffer)
-      return !this._tree._parent ? false : this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4, this.mode));
-    let { buffer } = this.buffer, d = this.stack.length - 1;
-    if (dir < 0) {
-      let parentStart = d < 0 ? 0 : this.stack[d] + 4;
-      if (this.index != parentStart)
-        return this.yieldBuf(buffer.findChild(
-          parentStart,
-          this.index,
-          -1,
-          0,
-          4
-          /* Side.DontCare */
-        ));
-    } else {
-      let after = buffer.buffer[this.index + 3];
-      if (after < (d < 0 ? buffer.buffer.length : buffer.buffer[this.stack[d] + 3]))
-        return this.yieldBuf(after);
-    }
-    return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4, this.mode)) : false;
-  }
-  /// 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(dir) {
-    let index, parent, { buffer } = this;
-    if (buffer) {
-      if (dir > 0) {
-        if (this.index < buffer.buffer.buffer.length)
-          return false;
-      } else {
-        for (let i = 0; i < this.index; i++)
-          if (buffer.buffer.buffer[i + 3] < this.index)
-            return false;
-      }
-      ({ index, parent } = buffer);
-    } else {
-      ({ index, _parent: parent } = this._tree);
-    }
-    for (; parent; { index, _parent: parent } = parent) {
-      if (index > -1)
-        for (let i = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i != e; i += dir) {
-          let child = parent._tree.children[i];
-          if (this.mode & IterMode.IncludeAnonymous || child instanceof TreeBuffer || !child.type.isAnonymous || hasChild(child))
-            return false;
-        }
-    }
-    return true;
-  }
-  move(dir, enter) {
-    if (enter && this.enterChild(
-      dir,
-      0,
-      4
-      /* Side.DontCare */
-    ))
-      return true;
-    for (; ; ) {
-      if (this.sibling(dir))
-        return true;
-      if (this.atLastNode(dir) || !this.parent())
-        return false;
-    }
-  }
-  /// 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(enter = true) {
-    return this.move(1, enter);
-  }
-  /// Move to the next node in a last-to-first pre-order traveral. 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(enter = true) {
-    return this.move(-1, enter);
-  }
-  /// 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(pos, side = 0) {
-    while (this.from == this.to || (side < 1 ? this.from >= pos : this.from > pos) || (side > -1 ? this.to <= pos : this.to < pos))
-      if (!this.parent())
-        break;
-    while (this.enterChild(1, pos, side)) {
-    }
-    return this;
-  }
-  /// Get a [syntax node](#common.SyntaxNode) at the cursor's current
-  /// position.
-  get node() {
-    if (!this.buffer)
-      return this._tree;
-    let cache = this.bufferNode, result = null, depth = 0;
-    if (cache && cache.context == this.buffer) {
-      scan:
-        for (let index = this.index, d = this.stack.length; d >= 0; ) {
-          for (let c = cache; c; c = c._parent)
-            if (c.index == index) {
-              if (index == this.index)
-                return c;
-              result = c;
-              depth = d + 1;
-              break scan;
-            }
-          index = this.stack[--d];
-        }
-    }
-    for (let i = depth; i < this.stack.length; i++)
-      result = new BufferNode(this.buffer, result, this.stack[i]);
-    return this.bufferNode = new BufferNode(this.buffer, result, 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(enter, leave) {
-    for (let depth = 0; ; ) {
-      let mustLeave = false;
-      if (this.type.isAnonymous || enter(this) !== false) {
-        if (this.firstChild()) {
-          depth++;
-          continue;
-        }
-        if (!this.type.isAnonymous)
-          mustLeave = true;
-      }
-      for (; ; ) {
-        if (mustLeave && leave)
-          leave(this);
-        mustLeave = this.type.isAnonymous;
-        if (this.nextSibling())
-          break;
-        if (!depth)
-          return;
-        this.parent();
-        depth--;
-        mustLeave = true;
-      }
-    }
-  }
-  /// 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(context) {
-    if (!this.buffer)
-      return matchNodeContext(this.node, context);
-    let { buffer } = this.buffer, { types } = buffer.set;
-    for (let i = context.length - 1, d = this.stack.length - 1; i >= 0; d--) {
-      if (d < 0)
-        return matchNodeContext(this.node, context, i);
-      let type = types[buffer.buffer[this.stack[d]]];
-      if (!type.isAnonymous) {
-        if (context[i] && context[i] != type.name)
-          return false;
-        i--;
-      }
-    }
-    return true;
-  }
-};
-function hasChild(tree) {
-  return tree.children.some((ch) => ch instanceof TreeBuffer || !ch.type.isAnonymous || hasChild(ch));
-}
-function buildTree(data) {
-  var _a;
-  let { buffer, nodeSet, maxBufferLength = DefaultBufferLength, reused = [], minRepeatType = nodeSet.types.length } = data;
-  let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;
-  let types = nodeSet.types;
-  let contextHash = 0, lookAhead = 0;
-  function takeNode(parentStart, minPos, children2, positions2, inRepeat) {
-    let { id, start, end, size } = cursor;
-    let lookAheadAtStart = lookAhead;
-    while (size < 0) {
-      cursor.next();
-      if (size == -1) {
-        let node2 = reused[id];
-        children2.push(node2);
-        positions2.push(start - parentStart);
-        return;
-      } else if (size == -3) {
-        contextHash = id;
-        return;
-      } else if (size == -4) {
-        lookAhead = id;
-        return;
-      } else {
-        throw new RangeError(`Unrecognized record size: ${size}`);
-      }
-    }
-    let type = types[id], node, buffer2;
-    let startPos = start - parentStart;
-    if (end - start <= maxBufferLength && (buffer2 = findBufferSize(cursor.pos - minPos, inRepeat))) {
-      let data2 = new Uint16Array(buffer2.size - buffer2.skip);
-      let endPos = cursor.pos - buffer2.size, index = data2.length;
-      while (cursor.pos > endPos)
-        index = copyToBuffer(buffer2.start, data2, index);
-      node = new TreeBuffer(data2, end - buffer2.start, nodeSet);
-      startPos = buffer2.start - parentStart;
-    } else {
-      let endPos = cursor.pos - size;
-      cursor.next();
-      let localChildren = [], localPositions = [];
-      let localInRepeat = id >= minRepeatType ? id : -1;
-      let lastGroup = 0, lastEnd = end;
-      while (cursor.pos > endPos) {
-        if (localInRepeat >= 0 && cursor.id == localInRepeat && cursor.size >= 0) {
-          if (cursor.end <= lastEnd - maxBufferLength) {
-            makeRepeatLeaf(localChildren, localPositions, start, lastGroup, cursor.end, lastEnd, localInRepeat, lookAheadAtStart);
-            lastGroup = localChildren.length;
-            lastEnd = cursor.end;
-          }
-          cursor.next();
-        } else {
-          takeNode(start, endPos, localChildren, localPositions, localInRepeat);
-        }
-      }
-      if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)
-        makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart);
-      localChildren.reverse();
-      localPositions.reverse();
-      if (localInRepeat > -1 && lastGroup > 0) {
-        let make = makeBalanced(type);
-        node = balanceRange(type, localChildren, localPositions, 0, localChildren.length, 0, end - start, make, make);
-      } else {
-        node = makeTree(type, localChildren, localPositions, end - start, lookAheadAtStart - end);
-      }
-    }
-    children2.push(node);
-    positions2.push(startPos);
-  }
-  function makeBalanced(type) {
-    return (children2, positions2, length3) => {
-      let lookAhead2 = 0, lastI = children2.length - 1, last2, lookAheadProp;
-      if (lastI >= 0 && (last2 = children2[lastI]) instanceof Tree) {
-        if (!lastI && last2.type == type && last2.length == length3)
-          return last2;
-        if (lookAheadProp = last2.prop(NodeProp.lookAhead))
-          lookAhead2 = positions2[lastI] + last2.length + lookAheadProp;
-      }
-      return makeTree(type, children2, positions2, length3, lookAhead2);
-    };
-  }
-  function makeRepeatLeaf(children2, positions2, base, i, from, to, type, lookAhead2) {
-    let localChildren = [], localPositions = [];
-    while (children2.length > i) {
-      localChildren.push(children2.pop());
-      localPositions.push(positions2.pop() + base - from);
-    }
-    children2.push(makeTree(nodeSet.types[type], localChildren, localPositions, to - from, lookAhead2 - to));
-    positions2.push(from - base);
-  }
-  function makeTree(type, children2, positions2, length3, lookAhead2 = 0, props) {
-    if (contextHash) {
-      let pair2 = [NodeProp.contextHash, contextHash];
-      props = props ? [pair2].concat(props) : [pair2];
-    }
-    if (lookAhead2 > 25) {
-      let pair2 = [NodeProp.lookAhead, lookAhead2];
-      props = props ? [pair2].concat(props) : [pair2];
-    }
-    return new Tree(type, children2, positions2, length3, props);
-  }
-  function findBufferSize(maxSize, inRepeat) {
-    let fork = cursor.fork();
-    let size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength;
-    let result = { size: 0, start: 0, skip: 0 };
-    scan:
-      for (let minPos = fork.pos - maxSize; fork.pos > minPos; ) {
-        let nodeSize2 = fork.size;
-        if (fork.id == inRepeat && nodeSize2 >= 0) {
-          result.size = size;
-          result.start = start;
-          result.skip = skip;
-          skip += 4;
-          size += 4;
-          fork.next();
-          continue;
-        }
-        let startPos = fork.pos - nodeSize2;
-        if (nodeSize2 < 0 || startPos < minPos || fork.start < minStart)
-          break;
-        let localSkipped = fork.id >= minRepeatType ? 4 : 0;
-        let nodeStart = fork.start;
-        fork.next();
-        while (fork.pos > startPos) {
-          if (fork.size < 0) {
-            if (fork.size == -3)
-              localSkipped += 4;
-            else
-              break scan;
-          } else if (fork.id >= minRepeatType) {
-            localSkipped += 4;
-          }
-          fork.next();
-        }
-        start = nodeStart;
-        size += nodeSize2;
-        skip += localSkipped;
-      }
-    if (inRepeat < 0 || size == maxSize) {
-      result.size = size;
-      result.start = start;
-      result.skip = skip;
-    }
-    return result.size > 4 ? result : void 0;
-  }
-  function copyToBuffer(bufferStart, buffer2, index) {
-    let { id, start, end, size } = cursor;
-    cursor.next();
-    if (size >= 0 && id < minRepeatType) {
-      let startIndex = index;
-      if (size > 4) {
-        let endPos = cursor.pos - (size - 4);
-        while (cursor.pos > endPos)
-          index = copyToBuffer(bufferStart, buffer2, index);
-      }
-      buffer2[--index] = startIndex;
-      buffer2[--index] = end - bufferStart;
-      buffer2[--index] = start - bufferStart;
-      buffer2[--index] = id;
-    } else if (size == -3) {
-      contextHash = id;
-    } else if (size == -4) {
-      lookAhead = id;
-    }
-    return index;
-  }
-  let children = [], positions = [];
-  while (cursor.pos > 0)
-    takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);
-  let length2 = (_a = data.length) !== null && _a !== void 0 ? _a : children.length ? positions[0] + children[0].length : 0;
-  return new Tree(types[data.topID], children.reverse(), positions.reverse(), length2);
-}
-var nodeSizeCache = /* @__PURE__ */ new WeakMap();
-function nodeSize(balanceType, node) {
-  if (!balanceType.isAnonymous || node instanceof TreeBuffer || node.type != balanceType)
-    return 1;
-  let size = nodeSizeCache.get(node);
-  if (size == null) {
-    size = 1;
-    for (let child of node.children) {
-      if (child.type != balanceType || !(child instanceof Tree)) {
-        size = 1;
-        break;
-      }
-      size += nodeSize(balanceType, child);
-    }
-    nodeSizeCache.set(node, size);
-  }
-  return size;
-}
-function balanceRange(balanceType, children, positions, from, to, start, length2, mkTop, mkTree) {
-  let total = 0;
-  for (let i = from; i < to; i++)
-    total += nodeSize(balanceType, children[i]);
-  let maxChild = Math.ceil(
-    total * 1.5 / 8
-    /* Balance.BranchFactor */
-  );
-  let localChildren = [], localPositions = [];
-  function divide(children2, positions2, from2, to2, offset) {
-    for (let i = from2; i < to2; ) {
-      let groupFrom = i, groupStart = positions2[i], groupSize = nodeSize(balanceType, children2[i]);
-      i++;
-      for (; i < to2; i++) {
-        let nextSize = nodeSize(balanceType, children2[i]);
-        if (groupSize + nextSize >= maxChild)
-          break;
-        groupSize += nextSize;
-      }
-      if (i == groupFrom + 1) {
-        if (groupSize > maxChild) {
-          let only = children2[groupFrom];
-          divide(only.children, only.positions, 0, only.children.length, positions2[groupFrom] + offset);
-          continue;
-        }
-        localChildren.push(children2[groupFrom]);
-      } else {
-        let length3 = positions2[i - 1] + children2[i - 1].length - groupStart;
-        localChildren.push(balanceRange(balanceType, children2, positions2, groupFrom, i, groupStart, length3, null, mkTree));
-      }
-      localPositions.push(groupStart + offset - start);
-    }
-  }
-  divide(children, positions, from, to, 0);
-  return (mkTop || mkTree)(localChildren, localPositions, length2);
-}
-var Parser = class {
-  /// 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(input, fragments, ranges) {
-    if (typeof input == "string")
-      input = new StringInput(input);
-    ranges = !ranges ? [new Range(0, input.length)] : ranges.length ? ranges.map((r) => new Range(r.from, r.to)) : [new Range(0, 0)];
-    return this.createParse(input, fragments || [], ranges);
-  }
-  /// Run a full parse, returning the resulting tree.
-  parse(input, fragments, ranges) {
-    let parse = this.startParse(input, fragments, ranges);
-    for (; ; ) {
-      let done = parse.advance();
-      if (done)
-        return done;
-    }
-  }
-};
-var StringInput = class {
-  constructor(string) {
-    this.string = string;
-  }
-  get length() {
-    return this.string.length;
-  }
-  chunk(from) {
-    return this.string.slice(from);
-  }
-  get lineChunks() {
-    return false;
-  }
-  read(from, to) {
-    return this.string.slice(from, to);
-  }
-};
-var stoppedInner = new NodeProp({ perNode: true });
-
-// ../../node_modules/@lezer/lr/dist/index.js
-var Stack = class _Stack {
-  /// @internal
-  constructor(p, stack, state, reducePos, pos, score, buffer, bufferBase, curContext, lookAhead = 0, parent) {
-    this.p = p;
-    this.stack = stack;
-    this.state = state;
-    this.reducePos = reducePos;
-    this.pos = pos;
-    this.score = score;
-    this.buffer = buffer;
-    this.bufferBase = bufferBase;
-    this.curContext = curContext;
-    this.lookAhead = lookAhead;
-    this.parent = parent;
-  }
-  /// @internal
-  toString() {
-    return `[${this.stack.filter((_, i) => i % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? "!" + this.score : ""}`;
-  }
-  // Start an empty stack
-  /// @internal
-  static start(p, state, pos = 0) {
-    let cx = p.parser.context;
-    return new _Stack(p, [], state, pos, pos, 0, [], 0, cx ? new StackContext(cx, cx.start) : null, 0, null);
-  }
-  /// The stack's current [context](#lr.ContextTracker) value, if
-  /// any. Its type will depend on the context tracker's type
-  /// parameter, or it will be `null` if there is no context
-  /// tracker.
-  get context() {
-    return this.curContext ? this.curContext.context : null;
-  }
-  // Push a state onto the stack, tracking its start position as well
-  // as the buffer base at that point.
-  /// @internal
-  pushState(state, start) {
-    this.stack.push(this.state, start, this.bufferBase + this.buffer.length);
-    this.state = state;
-  }
-  // Apply a reduce action
-  /// @internal
-  reduce(action) {
-    var _a;
-    let depth = action >> 19, type = action & 65535;
-    let { parser: parser2 } = this.p;
-    let dPrec = parser2.dynamicPrecedence(type);
-    if (dPrec)
-      this.score += dPrec;
-    if (depth == 0) {
-      this.pushState(parser2.getGoto(this.state, type, true), this.reducePos);
-      if (type < parser2.minRepeatTerm)
-        this.storeNode(type, this.reducePos, this.reducePos, 4, true);
-      this.reduceContext(type, this.reducePos);
-      return;
-    }
-    let base = this.stack.length - (depth - 1) * 3 - (action & 262144 ? 6 : 0);
-    let start = base ? this.stack[base - 2] : this.p.ranges[0].from, size = this.reducePos - start;
-    if (size >= 2e3 && !((_a = this.p.parser.nodeSet.types[type]) === null || _a === void 0 ? void 0 : _a.isAnonymous)) {
-      if (start == this.p.lastBigReductionStart) {
-        this.p.bigReductionCount++;
-        this.p.lastBigReductionSize = size;
-      } else if (this.p.lastBigReductionSize < size) {
-        this.p.bigReductionCount = 1;
-        this.p.lastBigReductionStart = start;
-        this.p.lastBigReductionSize = size;
-      }
-    }
-    let bufferBase = base ? this.stack[base - 1] : 0, count = this.bufferBase + this.buffer.length - bufferBase;
-    if (type < parser2.minRepeatTerm || action & 131072) {
-      let pos = parser2.stateFlag(
-        this.state,
-        1
-        /* StateFlag.Skipped */
-      ) ? this.pos : this.reducePos;
-      this.storeNode(type, start, pos, count + 4, true);
-    }
-    if (action & 262144) {
-      this.state = this.stack[base];
-    } else {
-      let baseStateID = this.stack[base - 3];
-      this.state = parser2.getGoto(baseStateID, type, true);
-    }
-    while (this.stack.length > base)
-      this.stack.pop();
-    this.reduceContext(type, start);
-  }
-  // Shift a value into the buffer
-  /// @internal
-  storeNode(term, start, end, size = 4, isReduce = false) {
-    if (term == 0 && (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
-      let cur = this, top = this.buffer.length;
-      if (top == 0 && cur.parent) {
-        top = cur.bufferBase - cur.parent.bufferBase;
-        cur = cur.parent;
-      }
-      if (top > 0 && cur.buffer[top - 4] == 0 && cur.buffer[top - 1] > -1) {
-        if (start == end)
-          return;
-        if (cur.buffer[top - 2] >= start) {
-          cur.buffer[top - 2] = end;
-          return;
-        }
-      }
-    }
-    if (!isReduce || this.pos == end) {
-      this.buffer.push(term, start, end, size);
-    } else {
-      let index = this.buffer.length;
-      if (index > 0 && this.buffer[index - 4] != 0)
-        while (index > 0 && this.buffer[index - 2] > end) {
-          this.buffer[index] = this.buffer[index - 4];
-          this.buffer[index + 1] = this.buffer[index - 3];
-          this.buffer[index + 2] = this.buffer[index - 2];
-          this.buffer[index + 3] = this.buffer[index - 1];
-          index -= 4;
-          if (size > 4)
-            size -= 4;
-        }
-      this.buffer[index] = term;
-      this.buffer[index + 1] = start;
-      this.buffer[index + 2] = end;
-      this.buffer[index + 3] = size;
-    }
-  }
-  // Apply a shift action
-  /// @internal
-  shift(action, next, nextEnd) {
-    let start = this.pos;
-    if (action & 131072) {
-      this.pushState(action & 65535, this.pos);
-    } else if ((action & 262144) == 0) {
-      let nextState = action, { parser: parser2 } = this.p;
-      if (nextEnd > this.pos || next <= parser2.maxNode) {
-        this.pos = nextEnd;
-        if (!parser2.stateFlag(
-          nextState,
-          1
-          /* StateFlag.Skipped */
-        ))
-          this.reducePos = nextEnd;
-      }
-      this.pushState(nextState, start);
-      this.shiftContext(next, start);
-      if (next <= parser2.maxNode)
-        this.buffer.push(next, start, nextEnd, 4);
-    } else {
-      this.pos = nextEnd;
-      this.shiftContext(next, start);
-      if (next <= this.p.parser.maxNode)
-        this.buffer.push(next, start, nextEnd, 4);
-    }
-  }
-  // Apply an action
-  /// @internal
-  apply(action, next, nextEnd) {
-    if (action & 65536)
-      this.reduce(action);
-    else
-      this.shift(action, next, nextEnd);
-  }
-  // Add a prebuilt (reused) node into the buffer.
-  /// @internal
-  useNode(value, next) {
-    let index = this.p.reused.length - 1;
-    if (index < 0 || this.p.reused[index] != value) {
-      this.p.reused.push(value);
-      index++;
-    }
-    let start = this.pos;
-    this.reducePos = this.pos = start + value.length;
-    this.pushState(next, start);
-    this.buffer.push(
-      index,
-      start,
-      this.reducePos,
-      -1
-      /* size == -1 means this is a reused value */
-    );
-    if (this.curContext)
-      this.updateContext(this.curContext.tracker.reuse(this.curContext.context, value, this, this.p.stream.reset(this.pos - value.length)));
-  }
-  // Split the stack. Due to the buffer sharing and the fact
-  // that `this.stack` tends to stay quite shallow, this isn't very
-  // expensive.
-  /// @internal
-  split() {
-    let parent = this;
-    let off = parent.buffer.length;
-    while (off > 0 && parent.buffer[off - 2] > parent.reducePos)
-      off -= 4;
-    let buffer = parent.buffer.slice(off), base = parent.bufferBase + off;
-    while (parent && base == parent.bufferBase)
-      parent = parent.parent;
-    return new _Stack(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, buffer, base, this.curContext, this.lookAhead, parent);
-  }
-  // Try to recover from an error by 'deleting' (ignoring) one token.
-  /// @internal
-  recoverByDelete(next, nextEnd) {
-    let isNode = next <= this.p.parser.maxNode;
-    if (isNode)
-      this.storeNode(next, this.pos, nextEnd, 4);
-    this.storeNode(0, this.pos, nextEnd, isNode ? 8 : 4);
-    this.pos = this.reducePos = nextEnd;
-    this.score -= 190;
-  }
-  /// Check if the given term would be able to be shifted (optionally
-  /// after some reductions) on this stack. This can be useful for
-  /// external tokenizers that want to make sure they only provide a
-  /// given token when it applies.
-  canShift(term) {
-    for (let sim = new SimulatedStack(this); ; ) {
-      let action = this.p.parser.stateSlot(
-        sim.state,
-        4
-        /* ParseState.DefaultReduce */
-      ) || this.p.parser.hasAction(sim.state, term);
-      if (action == 0)
-        return false;
-      if ((action & 65536) == 0)
-        return true;
-      sim.reduce(action);
-    }
-  }
-  // Apply up to Recover.MaxNext recovery actions that conceptually
-  // inserts some missing token or rule.
-  /// @internal
-  recoverByInsert(next) {
-    if (this.stack.length >= 300)
-      return [];
-    let nextStates = this.p.parser.nextStates(this.state);
-    if (nextStates.length > 4 << 1 || this.stack.length >= 120) {
-      let best = [];
-      for (let i = 0, s; i < nextStates.length; i += 2) {
-        if ((s = nextStates[i + 1]) != this.state && this.p.parser.hasAction(s, next))
-          best.push(nextStates[i], s);
-      }
-      if (this.stack.length < 120)
-        for (let i = 0; best.length < 4 << 1 && i < nextStates.length; i += 2) {
-          let s = nextStates[i + 1];
-          if (!best.some((v, i2) => i2 & 1 && v == s))
-            best.push(nextStates[i], s);
-        }
-      nextStates = best;
-    }
-    let result = [];
-    for (let i = 0; i < nextStates.length && result.length < 4; i += 2) {
-      let s = nextStates[i + 1];
-      if (s == this.state)
-        continue;
-      let stack = this.split();
-      stack.pushState(s, this.pos);
-      stack.storeNode(0, stack.pos, stack.pos, 4, true);
-      stack.shiftContext(nextStates[i], this.pos);
-      stack.score -= 200;
-      result.push(stack);
-    }
-    return result;
-  }
-  // Force a reduce, if possible. Return false if that can't
-  // be done.
-  /// @internal
-  forceReduce() {
-    let { parser: parser2 } = this.p;
-    let reduce = parser2.stateSlot(
-      this.state,
-      5
-      /* ParseState.ForcedReduce */
-    );
-    if ((reduce & 65536) == 0)
-      return false;
-    if (!parser2.validAction(this.state, reduce)) {
-      let depth = reduce >> 19, term = reduce & 65535;
-      let target = this.stack.length - depth * 3;
-      if (target < 0 || parser2.getGoto(this.stack[target], term, false) < 0) {
-        let backup = this.findForcedReduction();
-        if (backup == null)
-          return false;
-        reduce = backup;
-      }
-      this.storeNode(0, this.pos, this.pos, 4, true);
-      this.score -= 100;
-    }
-    this.reducePos = this.pos;
-    this.reduce(reduce);
-    return true;
-  }
-  /// Try to scan through the automaton to find some kind of reduction
-  /// that can be applied. Used when the regular ForcedReduce field
-  /// isn't a valid action. @internal
-  findForcedReduction() {
-    let { parser: parser2 } = this.p, seen = [];
-    let explore = (state, depth) => {
-      if (seen.includes(state))
-        return;
-      seen.push(state);
-      return parser2.allActions(state, (action) => {
-        if (action & (262144 | 131072))
-          ;
-        else if (action & 65536) {
-          let rDepth = (action >> 19) - depth;
-          if (rDepth > 1) {
-            let term = action & 65535, target = this.stack.length - rDepth * 3;
-            if (target >= 0 && parser2.getGoto(this.stack[target], term, false) >= 0)
-              return rDepth << 19 | 65536 | term;
-          }
-        } else {
-          let found = explore(action, depth + 1);
-          if (found != null)
-            return found;
-        }
-      });
-    };
-    return explore(this.state, 0);
-  }
-  /// @internal
-  forceAll() {
-    while (!this.p.parser.stateFlag(
-      this.state,
-      2
-      /* StateFlag.Accepting */
-    )) {
-      if (!this.forceReduce()) {
-        this.storeNode(0, this.pos, this.pos, 4, true);
-        break;
-      }
-    }
-    return this;
-  }
-  /// Check whether this state has no further actions (assumed to be a direct descendant of the
-  /// top state, since any other states must be able to continue
-  /// somehow). @internal
-  get deadEnd() {
-    if (this.stack.length != 3)
-      return false;
-    let { parser: parser2 } = this.p;
-    return parser2.data[parser2.stateSlot(
-      this.state,
-      1
-      /* ParseState.Actions */
-    )] == 65535 && !parser2.stateSlot(
-      this.state,
-      4
-      /* ParseState.DefaultReduce */
-    );
-  }
-  /// Restart the stack (put it back in its start state). Only safe
-  /// when this.stack.length == 3 (state is directly below the top
-  /// state). @internal
-  restart() {
-    this.state = this.stack[0];
-    this.stack.length = 0;
-  }
-  /// @internal
-  sameState(other) {
-    if (this.state != other.state || this.stack.length != other.stack.length)
-      return false;
-    for (let i = 0; i < this.stack.length; i += 3)
-      if (this.stack[i] != other.stack[i])
-        return false;
-    return true;
-  }
-  /// Get the parser used by this stack.
-  get parser() {
-    return this.p.parser;
-  }
-  /// Test whether a given dialect (by numeric ID, as exported from
-  /// the terms file) is enabled.
-  dialectEnabled(dialectID) {
-    return this.p.parser.dialect.flags[dialectID];
-  }
-  shiftContext(term, start) {
-    if (this.curContext)
-      this.updateContext(this.curContext.tracker.shift(this.curContext.context, term, this, this.p.stream.reset(start)));
-  }
-  reduceContext(term, start) {
-    if (this.curContext)
-      this.updateContext(this.curContext.tracker.reduce(this.curContext.context, term, this, this.p.stream.reset(start)));
-  }
-  /// @internal
-  emitContext() {
-    let last2 = this.buffer.length - 1;
-    if (last2 < 0 || this.buffer[last2] != -3)
-      this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);
-  }
-  /// @internal
-  emitLookAhead() {
-    let last2 = this.buffer.length - 1;
-    if (last2 < 0 || this.buffer[last2] != -4)
-      this.buffer.push(this.lookAhead, this.pos, this.pos, -4);
-  }
-  updateContext(context) {
-    if (context != this.curContext.context) {
-      let newCx = new StackContext(this.curContext.tracker, context);
-      if (newCx.hash != this.curContext.hash)
-        this.emitContext();
-      this.curContext = newCx;
-    }
-  }
-  /// @internal
-  setLookAhead(lookAhead) {
-    if (lookAhead > this.lookAhead) {
-      this.emitLookAhead();
-      this.lookAhead = lookAhead;
-    }
-  }
-  /// @internal
-  close() {
-    if (this.curContext && this.curContext.tracker.strict)
-      this.emitContext();
-    if (this.lookAhead > 0)
-      this.emitLookAhead();
-  }
-};
-var StackContext = class {
-  constructor(tracker, context) {
-    this.tracker = tracker;
-    this.context = context;
-    this.hash = tracker.strict ? tracker.hash(context) : 0;
-  }
-};
-var Recover;
-(function(Recover2) {
-  Recover2[Recover2["Insert"] = 200] = "Insert";
-  Recover2[Recover2["Delete"] = 190] = "Delete";
-  Recover2[Recover2["Reduce"] = 100] = "Reduce";
-  Recover2[Recover2["MaxNext"] = 4] = "MaxNext";
-  Recover2[Recover2["MaxInsertStackDepth"] = 300] = "MaxInsertStackDepth";
-  Recover2[Recover2["DampenInsertStackDepth"] = 120] = "DampenInsertStackDepth";
-  Recover2[Recover2["MinBigReduction"] = 2e3] = "MinBigReduction";
-})(Recover || (Recover = {}));
-var SimulatedStack = class {
-  constructor(start) {
-    this.start = start;
-    this.state = start.state;
-    this.stack = start.stack;
-    this.base = this.stack.length;
-  }
-  reduce(action) {
-    let term = action & 65535, depth = action >> 19;
-    if (depth == 0) {
-      if (this.stack == this.start.stack)
-        this.stack = this.stack.slice();
-      this.stack.push(this.state, 0, 0);
-      this.base += 3;
-    } else {
-      this.base -= (depth - 1) * 3;
-    }
-    let goto = this.start.p.parser.getGoto(this.stack[this.base - 3], term, true);
-    this.state = goto;
-  }
-};
-var StackBufferCursor = class _StackBufferCursor {
-  constructor(stack, pos, index) {
-    this.stack = stack;
-    this.pos = pos;
-    this.index = index;
-    this.buffer = stack.buffer;
-    if (this.index == 0)
-      this.maybeNext();
-  }
-  static create(stack, pos = stack.bufferBase + stack.buffer.length) {
-    return new _StackBufferCursor(stack, pos, pos - stack.bufferBase);
-  }
-  maybeNext() {
-    let next = this.stack.parent;
-    if (next != null) {
-      this.index = this.stack.bufferBase - next.bufferBase;
-      this.stack = next;
-      this.buffer = next.buffer;
-    }
-  }
-  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];
-  }
-  next() {
-    this.index -= 4;
-    this.pos -= 4;
-    if (this.index == 0)
-      this.maybeNext();
-  }
-  fork() {
-    return new _StackBufferCursor(this.stack, this.pos, this.index);
-  }
-};
-function decodeArray(input, Type = Uint16Array) {
-  if (typeof input != "string")
-    return input;
-  let array = null;
-  for (let pos = 0, out = 0; pos < input.length; ) {
-    let value = 0;
-    for (; ; ) {
-      let next = input.charCodeAt(pos++), stop = false;
-      if (next == 126) {
-        value = 65535;
-        break;
-      }
-      if (next >= 92)
-        next--;
-      if (next >= 34)
-        next--;
-      let digit = next - 32;
-      if (digit >= 46) {
-        digit -= 46;
-        stop = true;
-      }
-      value += digit;
-      if (stop)
-        break;
-      value *= 46;
-    }
-    if (array)
-      array[out++] = value;
-    else
-      array = new Type(value);
-  }
-  return array;
-}
-var CachedToken = class {
-  constructor() {
-    this.start = -1;
-    this.value = -1;
-    this.end = -1;
-    this.extended = -1;
-    this.lookAhead = 0;
-    this.mask = 0;
-    this.context = 0;
-  }
-};
-var nullToken = new CachedToken();
-var InputStream = class {
-  /// @internal
-  constructor(input, ranges) {
-    this.input = input;
-    this.ranges = ranges;
-    this.chunk = "";
-    this.chunkOff = 0;
-    this.chunk2 = "";
-    this.chunk2Pos = 0;
-    this.next = -1;
-    this.token = nullToken;
-    this.rangeIndex = 0;
-    this.pos = this.chunkPos = ranges[0].from;
-    this.range = ranges[0];
-    this.end = ranges[ranges.length - 1].to;
-    this.readNext();
-  }
-  /// @internal
-  resolveOffset(offset, assoc) {
-    let range = this.range, index = this.rangeIndex;
-    let pos = this.pos + offset;
-    while (pos < range.from) {
-      if (!index)
-        return null;
-      let next = this.ranges[--index];
-      pos -= range.from - next.to;
-      range = next;
-    }
-    while (assoc < 0 ? pos > range.to : pos >= range.to) {
-      if (index == this.ranges.length - 1)
-        return null;
-      let next = this.ranges[++index];
-      pos += next.from - range.to;
-      range = next;
-    }
-    return pos;
-  }
-  /// @internal
-  clipPos(pos) {
-    if (pos >= this.range.from && pos < this.range.to)
-      return pos;
-    for (let range of this.ranges)
-      if (range.to > pos)
-        return Math.max(pos, range.from);
-    return this.end;
-  }
-  /// Look at a code unit near the stream position. `.peek(0)` equals
-  /// `.next`, `.peek(-1)` gives you the previous character, and so
-  /// on.
-  ///
-  /// Note that looking around during tokenizing creates dependencies
-  /// on potentially far-away content, which may reduce the
-  /// effectiveness incremental parsing—when looking forward—or even
-  /// cause invalid reparses when looking backward more than 25 code
-  /// units, since the library does not track lookbehind.
-  peek(offset) {
-    let idx = this.chunkOff + offset, pos, result;
-    if (idx >= 0 && idx < this.chunk.length) {
-      pos = this.pos + offset;
-      result = this.chunk.charCodeAt(idx);
-    } else {
-      let resolved = this.resolveOffset(offset, 1);
-      if (resolved == null)
-        return -1;
-      pos = resolved;
-      if (pos >= this.chunk2Pos && pos < this.chunk2Pos + this.chunk2.length) {
-        result = this.chunk2.charCodeAt(pos - this.chunk2Pos);
-      } else {
-        let i = this.rangeIndex, range = this.range;
-        while (range.to <= pos)
-          range = this.ranges[++i];
-        this.chunk2 = this.input.chunk(this.chunk2Pos = pos);
-        if (pos + this.chunk2.length > range.to)
-          this.chunk2 = this.chunk2.slice(0, range.to - pos);
-        result = this.chunk2.charCodeAt(0);
-      }
-    }
-    if (pos >= this.token.lookAhead)
-      this.token.lookAhead = pos + 1;
-    return result;
-  }
-  /// Accept a token. By default, the end of the token is set to the
-  /// current stream position, but you can pass an offset (relative to
-  /// the stream position) to change that.
-  acceptToken(token, endOffset = 0) {
-    let end = endOffset ? this.resolveOffset(endOffset, -1) : this.pos;
-    if (end == null || end < this.token.start)
-      throw new RangeError("Token end out of bounds");
-    this.token.value = token;
-    this.token.end = end;
-  }
-  getChunk() {
-    if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {
-      let { chunk, chunkPos } = this;
-      this.chunk = this.chunk2;
-      this.chunkPos = this.chunk2Pos;
-      this.chunk2 = chunk;
-      this.chunk2Pos = chunkPos;
-      this.chunkOff = this.pos - this.chunkPos;
-    } else {
-      this.chunk2 = this.chunk;
-      this.chunk2Pos = this.chunkPos;
-      let nextChunk = this.input.chunk(this.pos);
-      let end = this.pos + nextChunk.length;
-      this.chunk = end > this.range.to ? nextChunk.slice(0, this.range.to - this.pos) : nextChunk;
-      this.chunkPos = this.pos;
-      this.chunkOff = 0;
-    }
-  }
-  readNext() {
-    if (this.chunkOff >= this.chunk.length) {
-      this.getChunk();
-      if (this.chunkOff == this.chunk.length)
-        return this.next = -1;
-    }
-    return this.next = this.chunk.charCodeAt(this.chunkOff);
-  }
-  /// Move the stream forward N (defaults to 1) code units. Returns
-  /// the new value of [`next`](#lr.InputStream.next).
-  advance(n = 1) {
-    this.chunkOff += n;
-    while (this.pos + n >= this.range.to) {
-      if (this.rangeIndex == this.ranges.length - 1)
-        return this.setDone();
-      n -= this.range.to - this.pos;
-      this.range = this.ranges[++this.rangeIndex];
-      this.pos = this.range.from;
-    }
-    this.pos += n;
-    if (this.pos >= this.token.lookAhead)
-      this.token.lookAhead = this.pos + 1;
-    return this.readNext();
-  }
-  setDone() {
-    this.pos = this.chunkPos = this.end;
-    this.range = this.ranges[this.rangeIndex = this.ranges.length - 1];
-    this.chunk = "";
-    return this.next = -1;
-  }
-  /// @internal
-  reset(pos, token) {
-    if (token) {
-      this.token = token;
-      token.start = pos;
-      token.lookAhead = pos + 1;
-      token.value = token.extended = -1;
-    } else {
-      this.token = nullToken;
-    }
-    if (this.pos != pos) {
-      this.pos = pos;
-      if (pos == this.end) {
-        this.setDone();
-        return this;
-      }
-      while (pos < this.range.from)
-        this.range = this.ranges[--this.rangeIndex];
-      while (pos >= this.range.to)
-        this.range = this.ranges[++this.rangeIndex];
-      if (pos >= this.chunkPos && pos < this.chunkPos + this.chunk.length) {
-        this.chunkOff = pos - this.chunkPos;
-      } else {
-        this.chunk = "";
-        this.chunkOff = 0;
-      }
-      this.readNext();
-    }
-    return this;
-  }
-  /// @internal
-  read(from, to) {
-    if (from >= this.chunkPos && to <= this.chunkPos + this.chunk.length)
-      return this.chunk.slice(from - this.chunkPos, to - this.chunkPos);
-    if (from >= this.chunk2Pos && to <= this.chunk2Pos + this.chunk2.length)
-      return this.chunk2.slice(from - this.chunk2Pos, to - this.chunk2Pos);
-    if (from >= this.range.from && to <= this.range.to)
-      return this.input.read(from, to);
-    let result = "";
-    for (let r of this.ranges) {
-      if (r.from >= to)
-        break;
-      if (r.to > from)
-        result += this.input.read(Math.max(r.from, from), Math.min(r.to, to));
-    }
-    return result;
-  }
-};
-var TokenGroup = class {
-  constructor(data, id) {
-    this.data = data;
-    this.id = id;
-  }
-  token(input, stack) {
-    let { parser: parser2 } = stack.p;
-    readToken(this.data, input, stack, this.id, parser2.data, parser2.tokenPrecTable);
-  }
-};
-TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
-var LocalTokenGroup = class {
-  constructor(data, precTable, elseToken) {
-    this.precTable = precTable;
-    this.elseToken = elseToken;
-    this.data = typeof data == "string" ? decodeArray(data) : data;
-  }
-  token(input, stack) {
-    let start = input.pos, skipped = 0;
-    for (; ; ) {
-      let atEof = input.next < 0, nextPos = input.resolveOffset(1, 1);
-      readToken(this.data, input, stack, 0, this.data, this.precTable);
-      if (input.token.value > -1)
-        break;
-      if (this.elseToken == null)
-        return;
-      if (!atEof)
-        skipped++;
-      if (nextPos == null)
-        break;
-      input.reset(nextPos, input.token);
-    }
-    if (skipped) {
-      input.reset(start, input.token);
-      input.acceptToken(this.elseToken, skipped);
-    }
-  }
-};
-LocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
-function readToken(data, input, stack, group, precTable, precOffset) {
-  let state = 0, groupMask = 1 << group, { dialect } = stack.p.parser;
-  scan:
-    for (; ; ) {
-      if ((groupMask & data[state]) == 0)
-        break;
-      let accEnd = data[state + 1];
-      for (let i = state + 3; i < accEnd; i += 2)
-        if ((data[i + 1] & groupMask) > 0) {
-          let term = data[i];
-          if (dialect.allows(term) && (input.token.value == -1 || input.token.value == term || overrides(term, input.token.value, precTable, precOffset))) {
-            input.acceptToken(term);
-            break;
-          }
-        }
-      let next = input.next, low = 0, high = data[state + 2];
-      if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 && data[accEnd + high * 3 - 3] == 65535) {
-        state = data[accEnd + high * 3 - 1];
-        continue scan;
-      }
-      for (; low < high; ) {
-        let mid = low + high >> 1;
-        let index = accEnd + mid + (mid << 1);
-        let from = data[index], to = data[index + 1] || 65536;
-        if (next < from)
-          high = mid;
-        else if (next >= to)
-          low = mid + 1;
-        else {
-          state = data[index + 2];
-          input.advance();
-          continue scan;
-        }
-      }
-      break;
-    }
-}
-function findOffset(data, start, term) {
-  for (let i = start, next; (next = data[i]) != 65535; i++)
-    if (next == term)
-      return i - start;
-  return -1;
-}
-function overrides(token, prev, tableData, tableOffset) {
-  let iPrev = findOffset(tableData, tableOffset, prev);
-  return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev;
-}
-var verbose = typeof process != "undefined" && process.env && /\bparse\b/.test(process.env.LOG);
-var stackIDs = null;
-var Safety;
-(function(Safety2) {
-  Safety2[Safety2["Margin"] = 25] = "Margin";
-})(Safety || (Safety = {}));
-function cutAt(tree, pos, side) {
-  let cursor = tree.cursor(IterMode.IncludeAnonymous);
-  cursor.moveTo(pos);
-  for (; ; ) {
-    if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos)))
-      for (; ; ) {
-        if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError)
-          return side < 0 ? Math.max(0, Math.min(
-            cursor.to - 1,
-            pos - 25
-            /* Safety.Margin */
-          )) : Math.min(tree.length, Math.max(
-            cursor.from + 1,
-            pos + 25
-            /* Safety.Margin */
-          ));
-        if (side < 0 ? cursor.prevSibling() : cursor.nextSibling())
-          break;
-        if (!cursor.parent())
-          return side < 0 ? 0 : tree.length;
-      }
-  }
-}
-var FragmentCursor = class {
-  constructor(fragments, nodeSet) {
-    this.fragments = fragments;
-    this.nodeSet = nodeSet;
-    this.i = 0;
-    this.fragment = null;
-    this.safeFrom = -1;
-    this.safeTo = -1;
-    this.trees = [];
-    this.start = [];
-    this.index = [];
-    this.nextFragment();
-  }
-  nextFragment() {
-    let fr = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];
-    if (fr) {
-      this.safeFrom = fr.openStart ? cutAt(fr.tree, fr.from + fr.offset, 1) - fr.offset : fr.from;
-      this.safeTo = fr.openEnd ? cutAt(fr.tree, fr.to + fr.offset, -1) - fr.offset : fr.to;
-      while (this.trees.length) {
-        this.trees.pop();
-        this.start.pop();
-        this.index.pop();
-      }
-      this.trees.push(fr.tree);
-      this.start.push(-fr.offset);
-      this.index.push(0);
-      this.nextStart = this.safeFrom;
-    } else {
-      this.nextStart = 1e9;
-    }
-  }
-  // `pos` must be >= any previously given `pos` for this cursor
-  nodeAt(pos) {
-    if (pos < this.nextStart)
-      return null;
-    while (this.fragment && this.safeTo <= pos)
-      this.nextFragment();
-    if (!this.fragment)
-      return null;
-    for (; ; ) {
-      let last2 = this.trees.length - 1;
-      if (last2 < 0) {
-        this.nextFragment();
-        return null;
-      }
-      let top = this.trees[last2], index = this.index[last2];
-      if (index == top.children.length) {
-        this.trees.pop();
-        this.start.pop();
-        this.index.pop();
-        continue;
-      }
-      let next = top.children[index];
-      let start = this.start[last2] + top.positions[index];
-      if (start > pos) {
-        this.nextStart = start;
-        return null;
-      }
-      if (next instanceof Tree) {
-        if (start == pos) {
-          if (start < this.safeFrom)
-            return null;
-          let end = start + next.length;
-          if (end <= this.safeTo) {
-            let lookAhead = next.prop(NodeProp.lookAhead);
-            if (!lookAhead || end + lookAhead < this.fragment.to)
-              return next;
-          }
-        }
-        this.index[last2]++;
-        if (start + next.length >= Math.max(this.safeFrom, pos)) {
-          this.trees.push(next);
-          this.start.push(start);
-          this.index.push(0);
-        }
-      } else {
-        this.index[last2]++;
-        this.nextStart = start + next.length;
-      }
-    }
-  }
-};
-var TokenCache = class {
-  constructor(parser2, stream) {
-    this.stream = stream;
-    this.tokens = [];
-    this.mainToken = null;
-    this.actions = [];
-    this.tokens = parser2.tokenizers.map((_) => new CachedToken());
-  }
-  getActions(stack) {
-    let actionIndex = 0;
-    let main = null;
-    let { parser: parser2 } = stack.p, { tokenizers } = parser2;
-    let mask = parser2.stateSlot(
-      stack.state,
-      3
-      /* ParseState.TokenizerMask */
-    );
-    let context = stack.curContext ? stack.curContext.hash : 0;
-    let lookAhead = 0;
-    for (let i = 0; i < tokenizers.length; i++) {
-      if ((1 << i & mask) == 0)
-        continue;
-      let tokenizer = tokenizers[i], token = this.tokens[i];
-      if (main && !tokenizer.fallback)
-        continue;
-      if (tokenizer.contextual || token.start != stack.pos || token.mask != mask || token.context != context) {
-        this.updateCachedToken(token, tokenizer, stack);
-        token.mask = mask;
-        token.context = context;
-      }
-      if (token.lookAhead > token.end + 25)
-        lookAhead = Math.max(token.lookAhead, lookAhead);
-      if (token.value != 0) {
-        let startIndex = actionIndex;
-        if (token.extended > -1)
-          actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);
-        actionIndex = this.addActions(stack, token.value, token.end, actionIndex);
-        if (!tokenizer.extend) {
-          main = token;
-          if (actionIndex > startIndex)
-            break;
-        }
-      }
-    }
-    while (this.actions.length > actionIndex)
-      this.actions.pop();
-    if (lookAhead)
-      stack.setLookAhead(lookAhead);
-    if (!main && stack.pos == this.stream.end) {
-      main = new CachedToken();
-      main.value = stack.p.parser.eofTerm;
-      main.start = main.end = stack.pos;
-      actionIndex = this.addActions(stack, main.value, main.end, actionIndex);
-    }
-    this.mainToken = main;
-    return this.actions;
-  }
-  getMainToken(stack) {
-    if (this.mainToken)
-      return this.mainToken;
-    let main = new CachedToken(), { pos, p } = stack;
-    main.start = pos;
-    main.end = Math.min(pos + 1, p.stream.end);
-    main.value = pos == p.stream.end ? p.parser.eofTerm : 0;
-    return main;
-  }
-  updateCachedToken(token, tokenizer, stack) {
-    let start = this.stream.clipPos(stack.pos);
-    tokenizer.token(this.stream.reset(start, token), stack);
-    if (token.value > -1) {
-      let { parser: parser2 } = stack.p;
-      for (let i = 0; i < parser2.specialized.length; i++)
-        if (parser2.specialized[i] == token.value) {
-          let result = parser2.specializers[i](this.stream.read(token.start, token.end), stack);
-          if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {
-            if ((result & 1) == 0)
-              token.value = result >> 1;
-            else
-              token.extended = result >> 1;
-            break;
-          }
-        }
-    } else {
-      token.value = 0;
-      token.end = this.stream.clipPos(start + 1);
-    }
-  }
-  putAction(action, token, end, index) {
-    for (let i = 0; i < index; i += 3)
-      if (this.actions[i] == action)
-        return index;
-    this.actions[index++] = action;
-    this.actions[index++] = token;
-    this.actions[index++] = end;
-    return index;
-  }
-  addActions(stack, token, end, index) {
-    let { state } = stack, { parser: parser2 } = stack.p, { data } = parser2;
-    for (let set = 0; set < 2; set++) {
-      for (let i = parser2.stateSlot(
-        state,
-        set ? 2 : 1
-        /* ParseState.Actions */
-      ); ; i += 3) {
-        if (data[i] == 65535) {
-          if (data[i + 1] == 1) {
-            i = pair(data, i + 2);
-          } else {
-            if (index == 0 && data[i + 1] == 2)
-              index = this.putAction(pair(data, i + 2), token, end, index);
-            break;
-          }
-        }
-        if (data[i] == token)
-          index = this.putAction(pair(data, i + 1), token, end, index);
-      }
-    }
-    return index;
-  }
-};
-var Rec;
-(function(Rec2) {
-  Rec2[Rec2["Distance"] = 5] = "Distance";
-  Rec2[Rec2["MaxRemainingPerStep"] = 3] = "MaxRemainingPerStep";
-  Rec2[Rec2["MinBufferLengthPrune"] = 500] = "MinBufferLengthPrune";
-  Rec2[Rec2["ForceReduceLimit"] = 10] = "ForceReduceLimit";
-  Rec2[Rec2["CutDepth"] = 15e3] = "CutDepth";
-  Rec2[Rec2["CutTo"] = 9e3] = "CutTo";
-  Rec2[Rec2["MaxLeftAssociativeReductionCount"] = 300] = "MaxLeftAssociativeReductionCount";
-  Rec2[Rec2["MaxStackCount"] = 12] = "MaxStackCount";
-})(Rec || (Rec = {}));
-var Parse = class {
-  constructor(parser2, input, fragments, ranges) {
-    this.parser = parser2;
-    this.input = input;
-    this.ranges = ranges;
-    this.recovering = 0;
-    this.nextStackID = 9812;
-    this.minStackPos = 0;
-    this.reused = [];
-    this.stoppedAt = null;
-    this.lastBigReductionStart = -1;
-    this.lastBigReductionSize = 0;
-    this.bigReductionCount = 0;
-    this.stream = new InputStream(input, ranges);
-    this.tokens = new TokenCache(parser2, this.stream);
-    this.topTerm = parser2.top[1];
-    let { from } = ranges[0];
-    this.stacks = [Stack.start(this, parser2.top[0], from)];
-    this.fragments = fragments.length && this.stream.end - from > parser2.bufferLength * 4 ? new FragmentCursor(fragments, parser2.nodeSet) : null;
-  }
-  get parsedPos() {
-    return this.minStackPos;
-  }
-  // Move the parser forward. This will process all parse stacks at
-  // `this.pos` and try to advance them to a further position. If no
-  // stack for such a position is found, it'll start error-recovery.
-  //
-  // When the parse is finished, this will return a syntax tree. When
-  // not, it returns `null`.
-  advance() {
-    let stacks = this.stacks, pos = this.minStackPos;
-    let newStacks = this.stacks = [];
-    let stopped, stoppedTokens;
-    if (this.bigReductionCount > 300 && stacks.length == 1) {
-      let [s] = stacks;
-      while (s.forceReduce() && s.stack.length && s.stack[s.stack.length - 2] >= this.lastBigReductionStart) {
-      }
-      this.bigReductionCount = this.lastBigReductionSize = 0;
-    }
-    for (let i = 0; i < stacks.length; i++) {
-      let stack = stacks[i];
-      for (; ; ) {
-        this.tokens.mainToken = null;
-        if (stack.pos > pos) {
-          newStacks.push(stack);
-        } else if (this.advanceStack(stack, newStacks, stacks)) {
-          continue;
-        } else {
-          if (!stopped) {
-            stopped = [];
-            stoppedTokens = [];
-          }
-          stopped.push(stack);
-          let tok = this.tokens.getMainToken(stack);
-          stoppedTokens.push(tok.value, tok.end);
-        }
-        break;
-      }
-    }
-    if (!newStacks.length) {
-      let finished = stopped && findFinished(stopped);
-      if (finished)
-        return this.stackToTree(finished);
-      if (this.parser.strict) {
-        if (verbose && stopped)
-          console.log("Stuck with token " + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : "none"));
-        throw new SyntaxError("No parse at " + pos);
-      }
-      if (!this.recovering)
-        this.recovering = 5;
-    }
-    if (this.recovering && stopped) {
-      let finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0] : this.runRecovery(stopped, stoppedTokens, newStacks);
-      if (finished)
-        return this.stackToTree(finished.forceAll());
-    }
-    if (this.recovering) {
-      let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3;
-      if (newStacks.length > maxRemaining) {
-        newStacks.sort((a, b) => b.score - a.score);
-        while (newStacks.length > maxRemaining)
-          newStacks.pop();
-      }
-      if (newStacks.some((s) => s.reducePos > pos))
-        this.recovering--;
-    } else if (newStacks.length > 1) {
-      outer:
-        for (let i = 0; i < newStacks.length - 1; i++) {
-          let stack = newStacks[i];
-          for (let j = i + 1; j < newStacks.length; j++) {
-            let other = newStacks[j];
-            if (stack.sameState(other) || stack.buffer.length > 500 && other.buffer.length > 500) {
-              if ((stack.score - other.score || stack.buffer.length - other.buffer.length) > 0) {
-                newStacks.splice(j--, 1);
-              } else {
-                newStacks.splice(i--, 1);
-                continue outer;
-              }
-            }
-          }
-        }
-      if (newStacks.length > 12)
-        newStacks.splice(
-          12,
-          newStacks.length - 12
-          /* Rec.MaxStackCount */
-        );
-    }
-    this.minStackPos = newStacks[0].pos;
-    for (let i = 1; i < newStacks.length; i++)
-      if (newStacks[i].pos < this.minStackPos)
-        this.minStackPos = newStacks[i].pos;
-    return null;
-  }
-  stopAt(pos) {
-    if (this.stoppedAt != null && this.stoppedAt < pos)
-      throw new RangeError("Can't move stoppedAt forward");
-    this.stoppedAt = pos;
-  }
-  // Returns an updated version of the given stack, or null if the
-  // stack can't advance normally. When `split` and `stacks` are
-  // given, stacks split off by ambiguous operations will be pushed to
-  // `split`, or added to `stacks` if they move `pos` forward.
-  advanceStack(stack, stacks, split) {
-    let start = stack.pos, { parser: parser2 } = this;
-    let base = verbose ? this.stackID(stack) + " -> " : "";
-    if (this.stoppedAt != null && start > this.stoppedAt)
-      return stack.forceReduce() ? stack : null;
-    if (this.fragments) {
-      let strictCx = stack.curContext && stack.curContext.tracker.strict, cxHash = strictCx ? stack.curContext.hash : 0;
-      for (let cached = this.fragments.nodeAt(start); cached; ) {
-        let match = this.parser.nodeSet.types[cached.type.id] == cached.type ? parser2.getGoto(stack.state, cached.type.id) : -1;
-        if (match > -1 && cached.length && (!strictCx || (cached.prop(NodeProp.contextHash) || 0) == cxHash)) {
-          stack.useNode(cached, match);
-          if (verbose)
-            console.log(base + this.stackID(stack) + ` (via reuse of ${parser2.getName(cached.type.id)})`);
-          return true;
-        }
-        if (!(cached instanceof Tree) || cached.children.length == 0 || cached.positions[0] > 0)
-          break;
-        let inner = cached.children[0];
-        if (inner instanceof Tree && cached.positions[0] == 0)
-          cached = inner;
-        else
-          break;
-      }
-    }
-    let defaultReduce = parser2.stateSlot(
-      stack.state,
-      4
-      /* ParseState.DefaultReduce */
-    );
-    if (defaultReduce > 0) {
-      stack.reduce(defaultReduce);
-      if (verbose)
-        console.log(base + this.stackID(stack) + ` (via always-reduce ${parser2.getName(
-          defaultReduce & 65535
-          /* Action.ValueMask */
-        )})`);
-      return true;
-    }
-    if (stack.stack.length >= 15e3) {
-      while (stack.stack.length > 9e3 && stack.forceReduce()) {
-      }
-    }
-    let actions = this.tokens.getActions(stack);
-    for (let i = 0; i < actions.length; ) {
-      let action = actions[i++], term = actions[i++], end = actions[i++];
-      let last2 = i == actions.length || !split;
-      let localStack = last2 ? stack : stack.split();
-      localStack.apply(action, term, end);
-      if (verbose)
-        console.log(base + this.stackID(localStack) + ` (via ${(action & 65536) == 0 ? "shift" : `reduce of ${parser2.getName(
-          action & 65535
-          /* Action.ValueMask */
-        )}`} for ${parser2.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`);
-      if (last2)
-        return true;
-      else if (localStack.pos > start)
-        stacks.push(localStack);
-      else
-        split.push(localStack);
-    }
-    return false;
-  }
-  // Advance a given stack forward as far as it will go. Returns the
-  // (possibly updated) stack if it got stuck, or null if it moved
-  // forward and was given to `pushStackDedup`.
-  advanceFully(stack, newStacks) {
-    let pos = stack.pos;
-    for (; ; ) {
-      if (!this.advanceStack(stack, null, null))
-        return false;
-      if (stack.pos > pos) {
-        pushStackDedup(stack, newStacks);
-        return true;
-      }
-    }
-  }
-  runRecovery(stacks, tokens, newStacks) {
-    let finished = null, restarted = false;
-    for (let i = 0; i < stacks.length; i++) {
-      let stack = stacks[i], token = tokens[i << 1], tokenEnd = tokens[(i << 1) + 1];
-      let base = verbose ? this.stackID(stack) + " -> " : "";
-      if (stack.deadEnd) {
-        if (restarted)
-          continue;
-        restarted = true;
-        stack.restart();
-        if (verbose)
-          console.log(base + this.stackID(stack) + " (restarted)");
-        let done = this.advanceFully(stack, newStacks);
-        if (done)
-          continue;
-      }
-      let force = stack.split(), forceBase = base;
-      for (let j = 0; force.forceReduce() && j < 10; j++) {
-        if (verbose)
-          console.log(forceBase + this.stackID(force) + " (via force-reduce)");
-        let done = this.advanceFully(force, newStacks);
-        if (done)
-          break;
-        if (verbose)
-          forceBase = this.stackID(force) + " -> ";
-      }
-      for (let insert of stack.recoverByInsert(token)) {
-        if (verbose)
-          console.log(base + this.stackID(insert) + " (via recover-insert)");
-        this.advanceFully(insert, newStacks);
-      }
-      if (this.stream.end > stack.pos) {
-        if (tokenEnd == stack.pos) {
-          tokenEnd++;
-          token = 0;
-        }
-        stack.recoverByDelete(token, tokenEnd);
-        if (verbose)
-          console.log(base + this.stackID(stack) + ` (via recover-delete ${this.parser.getName(token)})`);
-        pushStackDedup(stack, newStacks);
-      } else if (!finished || finished.score < stack.score) {
-        finished = stack;
-      }
-    }
-    return finished;
-  }
-  // Convert the stack's buffer to a syntax tree.
-  stackToTree(stack) {
-    stack.close();
-    return Tree.build({
-      buffer: StackBufferCursor.create(stack),
-      nodeSet: this.parser.nodeSet,
-      topID: this.topTerm,
-      maxBufferLength: this.parser.bufferLength,
-      reused: this.reused,
-      start: this.ranges[0].from,
-      length: stack.pos - this.ranges[0].from,
-      minRepeatType: this.parser.minRepeatTerm
-    });
-  }
-  stackID(stack) {
-    let id = (stackIDs || (stackIDs = /* @__PURE__ */ new WeakMap())).get(stack);
-    if (!id)
-      stackIDs.set(stack, id = String.fromCodePoint(this.nextStackID++));
-    return id + stack;
-  }
-};
-function pushStackDedup(stack, newStacks) {
-  for (let i = 0; i < newStacks.length; i++) {
-    let other = newStacks[i];
-    if (other.pos == stack.pos && other.sameState(stack)) {
-      if (newStacks[i].score < stack.score)
-        newStacks[i] = stack;
-      return;
-    }
-  }
-  newStacks.push(stack);
-}
-var Dialect = class {
-  constructor(source, flags, disabled) {
-    this.source = source;
-    this.flags = flags;
-    this.disabled = disabled;
-  }
-  allows(term) {
-    return !this.disabled || this.disabled[term] == 0;
-  }
-};
-var LRParser = class _LRParser extends Parser {
-  /// @internal
-  constructor(spec) {
-    super();
-    this.wrappers = [];
-    if (spec.version != 14)
-      throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14})`);
-    let nodeNames = spec.nodeNames.split(" ");
-    this.minRepeatTerm = nodeNames.length;
-    for (let i = 0; i < spec.repeatNodeCount; i++)
-      nodeNames.push("");
-    let topTerms = Object.keys(spec.topRules).map((r) => spec.topRules[r][1]);
-    let nodeProps = [];
-    for (let i = 0; i < nodeNames.length; i++)
-      nodeProps.push([]);
-    function setProp(nodeID, prop, value) {
-      nodeProps[nodeID].push([prop, prop.deserialize(String(value))]);
-    }
-    if (spec.nodeProps)
-      for (let propSpec of spec.nodeProps) {
-        let prop = propSpec[0];
-        if (typeof prop == "string")
-          prop = NodeProp[prop];
-        for (let i = 1; i < propSpec.length; ) {
-          let next = propSpec[i++];
-          if (next >= 0) {
-            setProp(next, prop, propSpec[i++]);
-          } else {
-            let value = propSpec[i + -next];
-            for (let j = -next; j > 0; j--)
-              setProp(propSpec[i++], prop, value);
-            i++;
-          }
-        }
-      }
-    this.nodeSet = new NodeSet(nodeNames.map((name, i) => NodeType.define({
-      name: i >= this.minRepeatTerm ? void 0 : name,
-      id: i,
-      props: nodeProps[i],
-      top: topTerms.indexOf(i) > -1,
-      error: i == 0,
-      skipped: spec.skippedNodes && spec.skippedNodes.indexOf(i) > -1
-    })));
-    if (spec.propSources)
-      this.nodeSet = this.nodeSet.extend(...spec.propSources);
-    this.strict = false;
-    this.bufferLength = DefaultBufferLength;
-    let tokenArray = decodeArray(spec.tokenData);
-    this.context = spec.context;
-    this.specializerSpecs = spec.specialized || [];
-    this.specialized = new Uint16Array(this.specializerSpecs.length);
-    for (let i = 0; i < this.specializerSpecs.length; i++)
-      this.specialized[i] = this.specializerSpecs[i].term;
-    this.specializers = this.specializerSpecs.map(getSpecializer);
-    this.states = decodeArray(spec.states, Uint32Array);
-    this.data = decodeArray(spec.stateData);
-    this.goto = decodeArray(spec.goto);
-    this.maxTerm = spec.maxTerm;
-    this.tokenizers = spec.tokenizers.map((value) => typeof value == "number" ? new TokenGroup(tokenArray, value) : value);
-    this.topRules = spec.topRules;
-    this.dialects = spec.dialects || {};
-    this.dynamicPrecedences = spec.dynamicPrecedences || null;
-    this.tokenPrecTable = spec.tokenPrec;
-    this.termNames = spec.termNames || null;
-    this.maxNode = this.nodeSet.types.length - 1;
-    this.dialect = this.parseDialect();
-    this.top = this.topRules[Object.keys(this.topRules)[0]];
-  }
-  createParse(input, fragments, ranges) {
-    let parse = new Parse(this, input, fragments, ranges);
-    for (let w of this.wrappers)
-      parse = w(parse, input, fragments, ranges);
-    return parse;
-  }
-  /// Get a goto table entry @internal
-  getGoto(state, term, loose = false) {
-    let table = this.goto;
-    if (term >= table[0])
-      return -1;
-    for (let pos = table[term + 1]; ; ) {
-      let groupTag = table[pos++], last2 = groupTag & 1;
-      let target = table[pos++];
-      if (last2 && loose)
-        return target;
-      for (let end = pos + (groupTag >> 1); pos < end; pos++)
-        if (table[pos] == state)
-          return target;
-      if (last2)
-        return -1;
-    }
-  }
-  /// Check if this state has an action for a given terminal @internal
-  hasAction(state, terminal) {
-    let data = this.data;
-    for (let set = 0; set < 2; set++) {
-      for (let i = this.stateSlot(
-        state,
-        set ? 2 : 1
-        /* ParseState.Actions */
-      ), next; ; i += 3) {
-        if ((next = data[i]) == 65535) {
-          if (data[i + 1] == 1)
-            next = data[i = pair(data, i + 2)];
-          else if (data[i + 1] == 2)
-            return pair(data, i + 2);
-          else
-            break;
-        }
-        if (next == terminal || next == 0)
-          return pair(data, i + 1);
-      }
-    }
-    return 0;
-  }
-  /// @internal
-  stateSlot(state, slot) {
-    return this.states[state * 6 + slot];
-  }
-  /// @internal
-  stateFlag(state, flag) {
-    return (this.stateSlot(
-      state,
-      0
-      /* ParseState.Flags */
-    ) & flag) > 0;
-  }
-  /// @internal
-  validAction(state, action) {
-    return !!this.allActions(state, (a) => a == action ? true : null);
-  }
-  /// @internal
-  allActions(state, action) {
-    let deflt = this.stateSlot(
-      state,
-      4
-      /* ParseState.DefaultReduce */
-    );
-    let result = deflt ? action(deflt) : void 0;
-    for (let i = this.stateSlot(
-      state,
-      1
-      /* ParseState.Actions */
-    ); result == null; i += 3) {
-      if (this.data[i] == 65535) {
-        if (this.data[i + 1] == 1)
-          i = pair(this.data, i + 2);
-        else
-          break;
-      }
-      result = action(pair(this.data, i + 1));
-    }
-    return result;
-  }
-  /// Get the states that can follow this one through shift actions or
-  /// goto jumps. @internal
-  nextStates(state) {
-    let result = [];
-    for (let i = this.stateSlot(
-      state,
-      1
-      /* ParseState.Actions */
-    ); ; i += 3) {
-      if (this.data[i] == 65535) {
-        if (this.data[i + 1] == 1)
-          i = pair(this.data, i + 2);
-        else
-          break;
-      }
-      if ((this.data[i + 2] & 65536 >> 16) == 0) {
-        let value = this.data[i + 1];
-        if (!result.some((v, i2) => i2 & 1 && v == value))
-          result.push(this.data[i], value);
-      }
-    }
-    return result;
-  }
-  /// Configure the parser. Returns a new parser instance that has the
-  /// given settings modified. Settings not provided in `config` are
-  /// kept from the original parser.
-  configure(config) {
-    let copy = Object.assign(Object.create(_LRParser.prototype), this);
-    if (config.props)
-      copy.nodeSet = this.nodeSet.extend(...config.props);
-    if (config.top) {
-      let info = this.topRules[config.top];
-      if (!info)
-        throw new RangeError(`Invalid top rule name ${config.top}`);
-      copy.top = info;
-    }
-    if (config.tokenizers)
-      copy.tokenizers = this.tokenizers.map((t) => {
-        let found = config.tokenizers.find((r) => r.from == t);
-        return found ? found.to : t;
-      });
-    if (config.specializers) {
-      copy.specializers = this.specializers.slice();
-      copy.specializerSpecs = this.specializerSpecs.map((s, i) => {
-        let found = config.specializers.find((r) => r.from == s.external);
-        if (!found)
-          return s;
-        let spec = Object.assign(Object.assign({}, s), { external: found.to });
-        copy.specializers[i] = getSpecializer(spec);
-        return spec;
-      });
-    }
-    if (config.contextTracker)
-      copy.context = config.contextTracker;
-    if (config.dialect)
-      copy.dialect = this.parseDialect(config.dialect);
-    if (config.strict != null)
-      copy.strict = config.strict;
-    if (config.wrap)
-      copy.wrappers = copy.wrappers.concat(config.wrap);
-    if (config.bufferLength != null)
-      copy.bufferLength = config.bufferLength;
-    return copy;
-  }
-  /// Tells you whether any [parse wrappers](#lr.ParserConfig.wrap)
-  /// are registered for this parser.
-  hasWrappers() {
-    return this.wrappers.length > 0;
-  }
-  /// Returns the name associated with a given term. This will only
-  /// work for all terms when the parser was generated with the
-  /// `--names` option. By default, only the names of tagged terms are
-  /// stored.
-  getName(term) {
-    return this.termNames ? this.termNames[term] : String(term <= this.maxNode && this.nodeSet.types[term].name || term);
-  }
-  /// The eof term id is always allocated directly after the node
-  /// types. @internal
-  get eofTerm() {
-    return this.maxNode + 1;
-  }
-  /// The type of top node produced by the parser.
-  get topNode() {
-    return this.nodeSet.types[this.top[1]];
-  }
-  /// @internal
-  dynamicPrecedence(term) {
-    let prec = this.dynamicPrecedences;
-    return prec == null ? 0 : prec[term] || 0;
-  }
-  /// @internal
-  parseDialect(dialect) {
-    let values = Object.keys(this.dialects), flags = values.map(() => false);
-    if (dialect)
-      for (let part of dialect.split(" ")) {
-        let id = values.indexOf(part);
-        if (id >= 0)
-          flags[id] = true;
-      }
-    let disabled = null;
-    for (let i = 0; i < values.length; i++)
-      if (!flags[i]) {
-        for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535; )
-          (disabled || (disabled = new Uint8Array(this.maxTerm + 1)))[id] = 1;
-      }
-    return new Dialect(dialect, flags, disabled);
-  }
-  /// Used by the output of the parser generator. Not available to
-  /// user code. @hide
-  static deserialize(spec) {
-    return new _LRParser(spec);
-  }
-};
-function pair(data, off) {
-  return data[off] | data[off + 1] << 16;
-}
-function findFinished(stacks) {
-  let best = null;
-  for (let stack of stacks) {
-    let stopped = stack.p.stoppedAt;
-    if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) && stack.p.parser.stateFlag(
-      stack.state,
-      2
-      /* StateFlag.Accepting */
-    ) && (!best || best.score < stack.score))
-      best = stack;
-  }
-  return best;
-}
-function getSpecializer(spec) {
-  if (spec.external) {
-    let mask = spec.extend ? 1 : 0;
-    return (value, stack) => spec.external(value, stack) << 1 | mask;
-  }
-  return spec.get;
-}
-
-// ../vuu-filter-parser/src/generated/filter-parser.js
-var parser = LRParser.deserialize({
-  version: 14,
-  states: "%QOVQPOOOOQO'#C_'#C_O_QQO'#C^OOQO'#DO'#DOOvQQO'#C|OOQO'#DR'#DROVQPO'#CuOOQO'#C}'#C}QOQPOOOOQO'#C`'#C`O!UQQO,58xO!dQPO,59VOVQPO,59]OVQPO,59_O!iQPO,59hO!nQQO,59aOOQO'#DQ'#DQOOQO1G.d1G.dO!UQQO1G.qO!yQQO1G.wOOQO1G.y1G.yOOQO'#Cw'#CwOOQO1G/S1G/SOOQO1G.{1G.{O#[QPO'#CnO#dQPO7+$]O!UQQO'#CxO#iQPO,59YOOQO<<Gw<<GwOOQO,59d,59dOOQO-E6v-E6v",
-  stateData: "#q~OoOS~OsPOvUO~OTXOUXOVXOWXOXXOYXO`ZO~Of[Oh]Oj^OmpX~OZ`O[`O]`O^`O~OabO~OseO~Of[Oh]OwgO~Oh]Ofeijeimeiwei~OcjOdbX~OdlO~OcjOdba~O",
-  goto: "#YvPPw}!TPPPPPPPPPPwPP!WPP!ZP!ZP!aP!g!jPPP!p!s!aP#P!aXROU[]XQOU[]RYQRibXTOU[]XVOU[]Rf^QkhRnkRWOQSOQ_UQc[Rd]QaYQhbRmj",
-  nodeNames: "\u26A0 Filter ColumnValueExpression Column Operator Eq NotEq Gt Lt Starts Ends Number String True False ColumnSetExpression In LBrack Values Comma RBrack AndExpression And OrExpression Or ParenthesizedExpression As FilterName",
-  maxTerm: 39,
-  skippedNodes: [0],
-  repeatNodeCount: 1,
-  tokenData: "6p~RnXY#PYZ#P]^#Ppq#Pqr#brs#mxy$eyz$j|}$o!O!P$t!Q![%S!^!_%_!_!`%d!`!a%i!c!}%n!}#O&V#P#Q&[#R#S%n#T#U&a#U#X%n#X#Y(w#Y#Z+]#Z#]%n#]#^.]#^#c%n#c#d/e#d#g%n#g#h0m#h#i4[#i#o%n~#USo~XY#PYZ#P]^#Ppq#P~#eP!_!`#h~#mOU~~#pWOX#mZ]#m^r#mrs$Ys#O#m#P;'S#m;'S;=`$_<%lO#m~$_O[~~$bP;=`<%l#m~$jOv~~$oOw~~$tOc~~$wP!Q![$z~%PPZ~!Q![$z~%XQZ~!O!P$t!Q![%S~%dOW~~%iOT~~%nOV~P%sUsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%n~&[Oa~~&aOd~R&fYsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c'U#c#g%n#g#h(^#h#o%nR'ZWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#W%n#W#X's#X#o%nR'zUfQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR(eUjQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR(|WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c)f#c#o%nR)kWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#W%n#W#X*T#X#o%nR*YWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h*r#h#o%nR*yUYQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR+bVsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#U+w#U#o%nR+|WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#`%n#`#a,f#a#o%nR,kWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h-T#h#o%nR-YWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#X%n#X#Y-r#Y#o%nR-yU^QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR.bWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c.z#c#o%nR/RU`QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR/jWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g0S#g#o%nR0ZUhQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR0rWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#h%n#h#i1[#i#o%nR1aVsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#U1v#U#o%nR1{WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g2e#g#o%nR2jWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#h%n#h#i3S#i#o%nR3XWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h3q#h#o%nR3xUXQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR4aWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g4y#g#o%nR5OWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#i%n#i#j5h#j#o%nR5mWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#X%n#X#Y6V#Y#o%nR6^U]QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%n",
-  tokenizers: [0, 1],
-  topRules: { "Filter": [0, 1] },
-  tokenPrec: 0
-});
-
-// ../vuu-utils/src/array-utils.ts
-var getAddedItems = (values, newValues) => {
-  const isNew = (v) => !(values == null ? void 0 : values.includes(v));
-  if (values === void 0) {
-    return newValues;
-  } else if (newValues.some(isNew)) {
-    return newValues.filter(isNew);
-  } else {
-    return [];
-  }
-};
-var getMissingItems = (sourceItems, items, identity) => items.filter((i) => sourceItems.findIndex((s) => identity(s) === i) === -1);
-
-// ../vuu-utils/src/filter-utils.ts
-var singleValueFilterOps = /* @__PURE__ */ new Set([
-  "=",
-  "!=",
-  ">",
-  ">=",
-  "<",
-  "<=",
-  "starts",
-  "ends"
-]);
-var isSingleValueFilter = (f) => f !== void 0 && singleValueFilterOps.has(f.op);
-var isMultiValueFilter = (f) => f !== void 0 && f.op === "in";
-function isMultiClauseFilter(f) {
-  return f !== void 0 && (f.op === "and" || f.op === "or");
-}
-
-// ../vuu-utils/src/column-utils.ts
-var isKeyedColumn = (column) => {
-  return typeof column.key === "number";
-};
-var EMPTY_COLUMN_MAP = {};
-function buildColumnMap(columns) {
-  const start = metadataKeys.count;
-  if (columns) {
-    return columns.reduce((map, column, i) => {
-      if (typeof column === "string") {
-        map[column] = start + i;
-      } else if (isKeyedColumn(column)) {
-        map[column.name] = column.key;
-      } else {
-        map[column.name] = start + i;
-      }
-      return map;
-    }, {});
-  } else {
-    return EMPTY_COLUMN_MAP;
-  }
-}
-var metadataKeys = {
-  IDX: 0,
-  RENDER_IDX: 1,
-  IS_LEAF: 2,
-  IS_EXPANDED: 3,
-  DEPTH: 4,
-  COUNT: 5,
-  KEY: 6,
-  SELECTED: 7,
-  count: 8,
-  // TODO following only used in datamodel
-  PARENT_IDX: "parent_idx",
-  IDX_POINTER: "idx_pointer",
-  FILTER_COUNT: "filter_count",
-  NEXT_FILTER_IDX: "next_filter_idx"
-};
-var { DEPTH, IS_LEAF } = metadataKeys;
-
-// ../vuu-utils/src/cookie-utils.ts
-var getCookieValue = (name) => {
-  var _a, _b;
-  if (((_a = globalThis.document) == null ? void 0 : _a.cookie) !== void 0) {
-    return (_b = globalThis.document.cookie.split("; ").find((row) => row.startsWith(`${name}=`))) == null ? void 0 : _b.split("=")[1];
-  }
-};
-
-// ../vuu-utils/src/range-utils.ts
-var NULL_RANGE = { from: 0, to: 0 };
-function resetRange({ from, to, bufferSize = 0 }) {
-  return {
-    from: 0,
-    to: to - from,
-    bufferSize,
-    reset: true
-  };
-}
-var rangeNewItems = ({ from: from1, to: to1 }, newRange) => {
-  const { from: from2, to: to2 } = newRange;
-  const noOverlap = from2 >= to1 || to2 <= from1;
-  const newFullySubsumesOld = from2 < from1 && to2 > to1;
-  return noOverlap || newFullySubsumesOld ? newRange : to2 > to1 ? { from: to1, to: to2 } : { from: from2, to: from1 };
-};
-
-// ../vuu-utils/src/datasource-utils.ts
-var NoFilter = { filter: "" };
-var NoSort = { sortDefs: [] };
-var vanillaConfig = {
-  aggregations: [],
-  columns: [],
-  filter: NoFilter,
-  groupBy: [],
-  sort: NoSort
-};
-var equivalentAggregations = ({ aggregations: agg1 }, { aggregations: agg2 }) => agg1 === void 0 && (agg2 == null ? void 0 : agg2.length) === 0 || agg2 === void 0 && (agg1 == null ? void 0 : agg1.length) === 0;
-var equivalentColumns = ({ columns: cols1 }, { columns: cols2 }) => cols1 === void 0 && (cols2 == null ? void 0 : cols2.length) === 0 || cols2 === void 0 && (cols1 == null ? void 0 : cols1.length) === 0;
-var equivalentFilter = ({ filter: f1 }, { filter: f2 }) => f1 === void 0 && (f2 == null ? void 0 : f2.filter) === "" || f2 === void 0 && (f1 == null ? void 0 : f1.filter) === "";
-var equivalentGroupBy = ({ groupBy: val1 }, { groupBy: val2 }) => val1 === void 0 && (val2 == null ? void 0 : val2.length) === 0 || val2 === void 0 && (val1 == null ? void 0 : val1.length) === 0;
-var equivalentSort = ({ sort: s1 }, { sort: s2 }) => s1 === void 0 && (s2 == null ? void 0 : s2.sortDefs.length) === 0 || s2 === void 0 && (s1 == null ? void 0 : s1.sortDefs.length) === 0;
-var exactlyTheSame = (a, b) => {
-  if (a === b) {
-    return true;
-  } else if (a === void 0 && b === void 0) {
-    return true;
-  } else {
-    return false;
-  }
-};
-var aggregationsChanged = (config, newConfig) => {
-  const { aggregations: agg1 } = config;
-  const { aggregations: agg2 } = newConfig;
-  if (exactlyTheSame(agg1, agg2) || equivalentAggregations(config, newConfig)) {
-    return false;
-  } else if (agg1 === void 0 || agg2 === void 0) {
-    return true;
-  } else if (agg1.length !== agg2.length) {
-    return true;
-  }
-  return agg1.some(
-    ({ column, aggType }, i) => column !== agg2[i].column || aggType !== agg2[i].aggType
-  );
-};
-var columnsChanged = (config, newConfig) => {
-  const { columns: cols1 } = config;
-  const { columns: cols2 } = newConfig;
-  if (exactlyTheSame(cols1, cols2) || equivalentColumns(config, newConfig)) {
-    return false;
-  } else if (cols1 === void 0 || cols2 === void 0) {
-    return true;
-  } else if ((cols1 == null ? void 0 : cols1.length) !== (cols2 == null ? void 0 : cols2.length)) {
-    return true;
-  }
-  return cols1.some((column, i) => column !== (cols2 == null ? void 0 : cols2[i]));
-};
-var filterChanged = (c1, c2) => {
-  var _a, _b;
-  if (equivalentFilter(c1, c2)) {
-    return false;
-  } else {
-    return ((_a = c1.filter) == null ? void 0 : _a.filter) !== ((_b = c2.filter) == null ? void 0 : _b.filter);
-  }
-};
-var groupByChanged = (config, newConfig) => {
-  const { groupBy: g1 } = config;
-  const { groupBy: g2 } = newConfig;
-  if (exactlyTheSame(g1, g2) || equivalentGroupBy(config, newConfig)) {
-    return false;
-  } else if (g1 === void 0 || g2 === void 0) {
-    return true;
-  } else if ((g1 == null ? void 0 : g1.length) !== (g2 == null ? void 0 : g2.length)) {
-    return true;
-  }
-  return g1.some((column, i) => column !== (g2 == null ? void 0 : g2[i]));
-};
-var sortChanged = (config, newConfig) => {
-  const { sort: s1 } = config;
-  const { sort: s2 } = newConfig;
-  if (exactlyTheSame(s1, s2) || equivalentSort(config, newConfig)) {
-    return false;
-  } else if (s1 === void 0 || s2 === void 0) {
-    return true;
-  } else if ((s1 == null ? void 0 : s1.sortDefs.length) !== (s2 == null ? void 0 : s2.sortDefs.length)) {
-    return true;
-  }
-  return s1.sortDefs.some(
-    ({ column, sortType }, i) => column !== s2.sortDefs[i].column || sortType !== s2.sortDefs[i].sortType
-  );
-};
-var visualLinkChanged = () => {
-  return false;
-};
-var configChanged = (config, newConfig) => {
-  if (exactlyTheSame(config, newConfig)) {
-    return false;
-  }
-  if (config === void 0 || newConfig === void 0) {
-    return true;
-  }
-  return aggregationsChanged(config, newConfig) || columnsChanged(config, newConfig) || filterChanged(config, newConfig) || groupByChanged(config, newConfig) || sortChanged(config, newConfig) || visualLinkChanged(config, newConfig);
-};
-var hasGroupBy = (config) => config !== void 0 && config.groupBy !== void 0 && config.groupBy.length > 0;
-var hasFilter = (config) => (config == null ? void 0 : config.filter) !== void 0 && config.filter.filter.length > 0;
-var hasSort = (config) => {
-  var _a;
-  return (config == null ? void 0 : config.sort) !== void 0 && Array.isArray((_a = config.sort) == null ? void 0 : _a.sortDefs) && config.sort.sortDefs.length > 0;
-};
-var withConfigDefaults = (config) => {
-  if (config.aggregations && config.columns && config.filter && config.groupBy && config.sort) {
-    return config;
-  } else {
-    const {
-      aggregations = [],
-      columns = [],
-      filter = { filter: "" },
-      groupBy = [],
-      sort = { sortDefs: [] },
-      visualLink
-    } = config;
-    return {
-      aggregations,
-      columns,
-      filter,
-      groupBy,
-      sort,
-      visualLink
-    };
-  }
-};
-
-// ../vuu-utils/src/logging-utils.ts
-var logLevels = ["error", "warn", "info", "debug"];
-var isValidLogLevel = (value) => typeof value === "string" && logLevels.includes(value);
-var DEFAULT_LOG_LEVEL = "error";
-var NO_OP = () => void 0;
-var DEFAULT_DEBUG_LEVEL = false ? "error" : "info";
-var { loggingLevel = DEFAULT_DEBUG_LEVEL } = getLoggingSettings();
-var logger = (category) => {
-  const debugEnabled = loggingLevel === "debug";
-  const infoEnabled = debugEnabled || loggingLevel === "info";
-  const warnEnabled = infoEnabled || loggingLevel === "warn";
-  const errorEnabled = warnEnabled || loggingLevel === "error";
-  const info = infoEnabled ? (message) => console.info(`[${category}] ${message}`) : NO_OP;
-  const warn = warnEnabled ? (message) => console.warn(`[${category}] ${message}`) : NO_OP;
-  const debug2 = debugEnabled ? (message) => console.debug(`[${category}] ${message}`) : NO_OP;
-  const error = errorEnabled ? (message) => console.error(`[${category}] ${message}`) : NO_OP;
-  if (false) {
-    return {
-      errorEnabled,
-      error
-    };
-  } else {
-    return {
-      debugEnabled,
-      infoEnabled,
-      warnEnabled,
-      errorEnabled,
-      info,
-      warn,
-      debug: debug2,
-      error
-    };
-  }
-};
-function getLoggingSettings() {
-  if (typeof loggingSettings !== "undefined") {
-    return loggingSettings;
-  } else {
-    return {
-      loggingLevel: getLoggingLevelFromCookie()
-    };
-  }
-}
-function getLoggingLevelFromCookie() {
-  const value = getCookieValue("vuu-logging-level");
-  if (isValidLogLevel(value)) {
-    return value;
-  } else {
-    return DEFAULT_LOG_LEVEL;
-  }
-}
-
-// ../vuu-utils/src/event-emitter.ts
-function isArrayOfListeners(listeners) {
-  return Array.isArray(listeners);
-}
-function isOnlyListener(listeners) {
-  return !Array.isArray(listeners);
-}
-var _events;
-var EventEmitter = class {
-  constructor() {
-    __privateAdd(this, _events, /* @__PURE__ */ new Map());
-  }
-  addListener(event, listener) {
-    const listeners = __privateGet(this, _events).get(event);
-    if (!listeners) {
-      __privateGet(this, _events).set(event, listener);
-    } else if (isArrayOfListeners(listeners)) {
-      listeners.push(listener);
-    } else if (isOnlyListener(listeners)) {
-      __privateGet(this, _events).set(event, [listeners, listener]);
-    }
-  }
-  removeListener(event, listener) {
-    if (!__privateGet(this, _events).has(event)) {
-      return;
-    }
-    const listenerOrListeners = __privateGet(this, _events).get(event);
-    let position = -1;
-    if (listenerOrListeners === listener) {
-      __privateGet(this, _events).delete(event);
-    } else if (Array.isArray(listenerOrListeners)) {
-      for (let i = length; i-- > 0; ) {
-        if (listenerOrListeners[i] === listener) {
-          position = i;
-          break;
-        }
-      }
-      if (position < 0) {
-        return;
-      }
-      if (listenerOrListeners.length === 1) {
-        listenerOrListeners.length = 0;
-        __privateGet(this, _events).delete(event);
-      } else {
-        listenerOrListeners.splice(position, 1);
-      }
-    }
-  }
-  removeAllListeners(event) {
-    if (event && __privateGet(this, _events).has(event)) {
-      __privateGet(this, _events).delete(event);
-    } else if (event === void 0) {
-      __privateGet(this, _events).clear();
-    }
-  }
-  emit(event, ...args) {
-    if (__privateGet(this, _events)) {
-      const handler = __privateGet(this, _events).get(event);
-      if (handler) {
-        this.invokeHandler(handler, args);
-      }
-    }
-  }
-  once(event, listener) {
-    const handler = (...args) => {
-      this.removeListener(event, handler);
-      listener(...args);
-    };
-    this.on(event, handler);
-  }
-  on(event, listener) {
-    this.addListener(event, listener);
-  }
-  hasListener(event, listener) {
-    const listeners = __privateGet(this, _events).get(event);
-    if (Array.isArray(listeners)) {
-      return listeners.includes(listener);
-    } else {
-      return listeners === listener;
-    }
-  }
-  invokeHandler(handler, args) {
-    if (isArrayOfListeners(handler)) {
-      handler.slice().forEach((listener) => this.invokeHandler(listener, args));
-    } else {
-      switch (args.length) {
-        case 0:
-          handler();
-          break;
-        case 1:
-          handler(args[0]);
-          break;
-        case 2:
-          handler(args[0], args[1]);
-          break;
-        default:
-          handler.call(null, ...args);
-      }
-    }
-  }
-};
-_events = new WeakMap();
-
-// ../vuu-utils/src/keyset.ts
-var KeySet = class {
-  constructor(range) {
-    this.keys = /* @__PURE__ */ new Map();
-    this.free = [];
-    this.nextKeyValue = 0;
-    this.reset(range);
-  }
-  next() {
-    if (this.free.length > 0) {
-      return this.free.pop();
-    } else {
-      return this.nextKeyValue++;
-    }
-  }
-  reset({ from, to }) {
-    this.keys.forEach((keyValue, rowIndex) => {
-      if (rowIndex < from || rowIndex >= to) {
-        this.free.push(keyValue);
-        this.keys.delete(rowIndex);
-      }
-    });
-    const size = to - from;
-    if (this.keys.size + this.free.length > size) {
-      this.free.length = Math.max(0, size - this.keys.size);
-    }
-    for (let rowIndex = from; rowIndex < to; rowIndex++) {
-      if (!this.keys.has(rowIndex)) {
-        const nextKeyValue = this.next();
-        this.keys.set(rowIndex, nextKeyValue);
-      }
-    }
-    if (this.nextKeyValue > this.keys.size) {
-      this.nextKeyValue = this.keys.size;
-    }
-  }
-  keyFor(rowIndex) {
-    const key = this.keys.get(rowIndex);
-    if (key === void 0) {
-      console.log(`key not found
-        keys: ${this.toDebugString()}
-        free : ${this.free.join(",")}  
-      `);
-      throw Error(`KeySet, no key found for rowIndex ${rowIndex}`);
-    }
-    return key;
-  }
-  toDebugString() {
-    return Array.from(this.keys.entries()).map((k, v) => `${k}=>${v}`).join(",");
-  }
-};
-
-// ../vuu-utils/src/nanoid/index.ts
-var uuid = (size = 21) => {
-  let id = "";
-  const bytes = crypto.getRandomValues(new Uint8Array(size));
-  while (size--) {
-    const byte = bytes[size] & 63;
-    if (byte < 36) {
-      id += byte.toString(36);
-    } else if (byte < 62) {
-      id += (byte - 26).toString(36).toUpperCase();
-    } else if (byte < 63) {
-      id += "_";
-    } else {
-      id += "-";
-    }
-  }
-  return id;
-};
-
-// ../vuu-utils/src/selection-utils.ts
-var { SELECTED } = metadataKeys;
-var RowSelected = {
-  False: 0,
-  True: 1,
-  First: 2,
-  Last: 4
-};
-var rangeIncludes = (range, index) => index >= range[0] && index <= range[1];
-var SINGLE_SELECTED_ROW = RowSelected.True + RowSelected.First + RowSelected.Last;
-var FIRST_SELECTED_ROW_OF_BLOCK = RowSelected.True + RowSelected.First;
-var LAST_SELECTED_ROW_OF_BLOCK = RowSelected.True + RowSelected.Last;
-var getSelectionStatus = (selected, itemIndex) => {
-  for (const item of selected) {
-    if (typeof item === "number") {
-      if (item === itemIndex) {
-        return SINGLE_SELECTED_ROW;
-      }
-    } else if (rangeIncludes(item, itemIndex)) {
-      if (itemIndex === item[0]) {
-        return FIRST_SELECTED_ROW_OF_BLOCK;
-      } else if (itemIndex === item[1]) {
-        return LAST_SELECTED_ROW_OF_BLOCK;
-      } else {
-        return RowSelected.True;
-      }
-    }
-  }
-  return RowSelected.False;
-};
-
-// ../vuu-filter-parser/src/FilterTreeWalker.ts
-var _filter;
-var FilterExpression = class {
-  constructor() {
-    __privateAdd(this, _filter, void 0);
-  }
-  setFilterCombinatorOp(op, filter = __privateGet(this, _filter)) {
-    if (isMultiClauseFilter(filter) && filter.op === op) {
-      return;
-    } else {
-      __privateSet(this, _filter, {
-        op,
-        filters: [__privateGet(this, _filter)]
-      });
-    }
-  }
-  add(filter) {
-    if (__privateGet(this, _filter) === void 0) {
-      __privateSet(this, _filter, filter);
-    } else if (isMultiClauseFilter(__privateGet(this, _filter))) {
-      __privateGet(this, _filter).filters.push(filter);
-    } else {
-      throw Error(`Invalid filter passed to FilterExpression`);
-    }
-  }
-  setColumn(column, filter = __privateGet(this, _filter)) {
-    if (isMultiClauseFilter(filter)) {
-      const target = filter.filters.at(-1);
-      if (target) {
-        this.setColumn(column, target);
-      }
-    } else if (filter) {
-      filter.column = column;
-    }
-  }
-  setOp(value, filter = __privateGet(this, _filter)) {
-    if (isMultiClauseFilter(filter)) {
-      const target = filter.filters.at(-1);
-      if (target) {
-        this.setOp(value, target);
-      }
-    } else if (filter) {
-      filter.op = value;
-    }
-  }
-  setValue(value, filter = __privateGet(this, _filter)) {
-    var _a;
-    if (isMultiClauseFilter(filter)) {
-      const target = filter.filters.at(-1);
-      if (target) {
-        this.setValue(value, target);
-      }
-    } else if (isMultiValueFilter(filter)) {
-      (_a = filter.values) != null ? _a : filter.values = [];
-      filter.values.push(value);
-    } else if (isSingleValueFilter(filter)) {
-      filter.value = value;
-    }
-  }
-  toJSON(filter = __privateGet(this, _filter)) {
-    if (this.name) {
-      return {
-        ...filter,
-        name: this.name
-      };
-    } else {
-      return filter;
-    }
-  }
-};
-_filter = new WeakMap();
-var walkTree = (tree, source) => {
-  const filterExpression = new FilterExpression();
-  const cursor = tree.cursor();
-  do {
-    const { name, from, to } = cursor;
-    switch (name) {
-      case "ColumnValueExpression":
-        filterExpression.add({});
-        break;
-      case "ColumnSetExpression":
-        filterExpression.add({ op: "in" });
-        break;
-      case "Or":
-      case "And":
-        filterExpression.setFilterCombinatorOp(source.substring(from, to));
-        break;
-      case "Column":
-        filterExpression.setColumn(source.substring(from, to));
-        break;
-      case "Operator":
-        filterExpression.setOp(source.substring(from, to));
-        break;
-      case "String":
-        filterExpression.setValue(source.substring(from + 1, to - 1));
-        break;
-      case "Number":
-        filterExpression.setValue(parseFloat(source.substring(from, to)));
-        break;
-      case "True":
-        filterExpression.setValue(true);
-        break;
-      case "False":
-        filterExpression.setValue(false);
-        break;
-      case "FilterName":
-        filterExpression.name = source.substring(from, to);
-        break;
-      default:
-    }
-  } while (cursor.next());
-  return filterExpression.toJSON();
-};
-
-// ../vuu-filter-parser/src/FilterParser.ts
-var strictParser = parser.configure({ strict: true });
-var parseFilter = (filterQuery) => {
-  const parseTree = strictParser.parse(filterQuery);
-  const filter = walkTree(parseTree, filterQuery);
-  return filter;
-};
-
-// ../vuu-filter-parser/src/filter-evaluation-utils.ts
-function filterPredicate(columnMap, filter) {
-  switch (filter.op) {
-    case "in":
-      return testInclude(columnMap, filter);
-    case "=":
-      return testEQ(columnMap, filter);
-    case ">":
-      return testGT(columnMap, filter);
-    case ">=":
-      return testGE(columnMap, filter);
-    case "<":
-      return testLT(columnMap, filter);
-    case "<=":
-      return testLE(columnMap, filter);
-    case "starts":
-      return testSW(columnMap, filter);
-    case "and":
-      return testAND(columnMap, filter);
-    case "or":
-      return testOR(columnMap, filter);
-    default:
-      console.log(`unrecognized filter type ${filter.op}`);
-      return () => true;
-  }
-}
-var testInclude = (columnMap, filter) => {
-  return (row) => filter.values.indexOf(row[columnMap[filter.column]]) !== -1;
-};
-var testEQ = (columnMap, filter) => {
-  return (row) => row[columnMap[filter.column]] === filter.value;
-};
-var testGT = (columnMap, filter) => {
-  return (row) => row[columnMap[filter.column]] > filter.value;
-};
-var testGE = (columnMap, filter) => {
-  return (row) => row[columnMap[filter.column]] >= filter.value;
-};
-var testLT = (columnMap, filter) => {
-  return (row) => row[columnMap[filter.column]] < filter.value;
-};
-var testLE = (columnMap, filter) => {
-  return (row) => row[columnMap[filter.column]] <= filter.value;
-};
-var testSW = (columnMap, filter) => {
-  const filterValue = filter.value;
-  if (typeof filterValue !== "string") {
-    throw Error("string filter applied to value of wrong type");
-  }
-  return (row) => {
-    const rowValue = row[columnMap[filter.column]];
-    if (typeof rowValue !== "string") {
-      throw Error("string filter applied to value of wrong type");
-    }
-    return rowValue.toLowerCase().startsWith(filterValue.toLowerCase());
-  };
-};
-var testAND = (columnMap, filter) => {
-  const filters = filter.filters.map((f1) => filterPredicate(columnMap, f1));
-  return (row) => filters.every((fn) => fn(row));
-};
-function testOR(columnMap, filter) {
-  const filters = filter.filters.map((f1) => filterPredicate(columnMap, f1));
-  return (row) => filters.some((fn) => fn(row));
-}
-
-// ../vuu-data-local/src/array-data-source/aggregate-utils.ts
-var aggregateData = (aggregations, targetData, groupBy, leafData, columnMap, groupMap) => {
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  const aggType = aggregations[aggregations.length - 1].aggType;
-  const groupIndices = groupBy.map((column) => columnMap[column]);
-  switch (aggType) {
-    case 1:
-      return aggregateSum(
-        groupMap,
-        leafData,
-        columnMap,
-        aggregations,
-        targetData,
-        groupIndices
-      );
-    case 2:
-      return aggregateAverage(
-        groupMap,
-        leafData,
-        columnMap,
-        aggregations,
-        targetData,
-        groupIndices
-      );
-    case 3:
-      return aggregateCount(
-        groupMap,
-        columnMap,
-        aggregations,
-        targetData,
-        groupIndices
-      );
-    case 4:
-      return aggregateHigh(
-        groupMap,
-        leafData,
-        columnMap,
-        aggregations,
-        targetData,
-        groupIndices
-      );
-    case 5:
-      return aggregateLow(
-        groupMap,
-        leafData,
-        columnMap,
-        aggregations,
-        targetData,
-        groupIndices
-      );
-    case 6:
-      return aggregateDistinct(
-        groupMap,
-        leafData,
-        columnMap,
-        aggregations,
-        targetData,
-        groupIndices
-      );
-  }
-};
-function aggregateCount(groupMap, columnMap, aggregations, targetData, groupIndices) {
-  const counts = {};
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  function countRecursive(map) {
-    if (Array.isArray(map)) {
-      return map.length;
-    } else {
-      let count = 0;
-      for (const key in map) {
-        count += 1 + countRecursive(map[key]);
-      }
-      return count;
-    }
-  }
-  for (const key in groupMap) {
-    const count = countRecursive(groupMap[key]);
-    counts[key] = count;
-  }
-  for (let index = 0; index < targetData.length; index++) {
-    for (const key in counts) {
-      if (targetData[index][groupIndices[0]] === key) {
-        targetData[index][aggColumn] = counts[key];
-      }
-    }
-  }
-  console.log("!!!! targetData", targetData);
-  console.log("!!!! counts", counts);
-  return counts;
-}
-function getAggColumn(columnMap, aggregations) {
-  console.log("!!!! aggregation length", aggregations.length);
-  const columnName = aggregations[aggregations.length - 1].column;
-  const columnNumber = columnMap[columnName];
-  return columnNumber;
-}
-function aggregateSum(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
-  const sums = {};
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  function sumRecursive(map, leafData2, aggColumn2) {
-    if (Array.isArray(map)) {
-      let sum = 0;
-      for (const key of map) {
-        sum += Number(leafData2[key][aggColumn2]);
-      }
-      return sum;
-    } else {
-      let sum = 0;
-      for (const key in map) {
-        sum += sumRecursive(map[key], leafData2, aggColumn2);
-      }
-      return sum;
-    }
-  }
-  for (const key in groupMap) {
-    console.log(key);
-    const sum = Number(sumRecursive(groupMap[key], leafData, aggColumn));
-    sums[key] = sum;
-  }
-  for (let index = 0; index < targetData.length; index++) {
-    for (const key in sums) {
-      if (targetData[index][groupIndices[0]] === key) {
-        targetData[index][aggColumn] = sums[key];
-      }
-    }
-  }
-  console.log("!!!! targetData", targetData);
-  console.log("!!!! sums", sums);
-  return sums;
-}
-function aggregateAverage(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
-  const averages = {};
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  const count = aggregateCount(
-    groupMap,
-    columnMap,
-    aggregations,
-    targetData,
-    groupIndices
-  );
-  const sum = aggregateSum(
-    groupMap,
-    leafData,
-    columnMap,
-    aggregations,
-    targetData,
-    groupIndices
-  );
-  for (const key in count) {
-    let average = 0;
-    average = sum[key] / count[key];
-    averages[key] = average;
-  }
-  for (let index = 0; index < targetData.length; index++) {
-    for (const key in averages) {
-      if (targetData[index][groupIndices[0]] === key) {
-        targetData[index][aggColumn] = averages[key];
-      }
-    }
-  }
-  console.log("!!!! targetData", targetData);
-  console.log("!!!! averages", averages);
-  return averages;
-}
-function getLeafColumnData(map, leafData, aggColumn) {
-  const data = [];
-  if (Array.isArray(map)) {
-    for (const key of map) {
-      data.push(leafData[key][aggColumn]);
-    }
-  } else {
-    for (const key in map) {
-      data.push(...getLeafColumnData(map[key], leafData, aggColumn));
-    }
-  }
-  return data;
-}
-function aggregateDistinct(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
-  const distincts = {};
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  for (const key in groupMap) {
-    const leafColumnData = getLeafColumnData(
-      groupMap[key],
-      leafData,
-      aggColumn
-    );
-    const distinct = [...new Set(leafColumnData)];
-    distincts[key] = distinct;
-  }
-  for (let index = 0; index < targetData.length; index++) {
-    for (const key in distincts) {
-      if (targetData[index][groupIndices[0]] === key) {
-        targetData[index][aggColumn] = distincts[key];
-      }
-    }
-  }
-  return distincts;
-}
-function aggregateHigh(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
-  const highs = {};
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  for (const key in groupMap) {
-    const leafColumnData = getLeafColumnData(
-      groupMap[key],
-      leafData,
-      aggColumn
-    );
-    const maxNumber = Math.max(...leafColumnData);
-    highs[key] = maxNumber;
-  }
-  for (let index = 0; index < targetData.length; index++) {
-    for (const key in highs) {
-      if (targetData[index][groupIndices[0]] === key) {
-        targetData[index][aggColumn] = highs[key];
-      }
-    }
-  }
-  return highs;
-}
-function aggregateLow(groupMap, leafData, columnMap, aggregations, targetData, groupIndices) {
-  const mins = {};
-  const aggColumn = getAggColumn(columnMap, aggregations);
-  for (const key in groupMap) {
-    const leafColumnData = getLeafColumnData(
-      groupMap[key],
-      leafData,
-      aggColumn
-    );
-    const minNumber = Math.min(...leafColumnData);
-    mins[key] = minNumber;
-  }
-  for (let index = 0; index < targetData.length; index++) {
-    for (const key in mins) {
-      if (targetData[index][groupIndices[0]] === key) {
-        targetData[index][aggColumn] = mins[key];
-      }
-    }
-  }
-  return mins;
-}
+// src/TickingArrayDataSource.ts
+import {
+  ArrayDataSource
+} from "@vuu-ui/vuu-data-local";
 
-// ../vuu-data-local/src/array-data-source/array-data-utils.ts
-var { RENDER_IDX, SELECTED: SELECTED2 } = metadataKeys;
-var toClientRow = (row, keys, selection, dataIndices) => {
-  const [rowIndex] = row;
-  let clientRow;
-  if (dataIndices) {
-    const { count } = metadataKeys;
-    clientRow = row.slice(0, count).concat(dataIndices.map((idx) => row[idx]));
-  } else {
-    clientRow = row.slice();
-  }
-  clientRow[RENDER_IDX] = keys.keyFor(rowIndex);
-  clientRow[SELECTED2] = getSelectionStatus(selection, rowIndex);
-  return clientRow;
-};
-var divergentMaps = (columnMap, dataMap) => {
-  if (dataMap) {
-    const { count: mapOffset } = metadataKeys;
-    for (const [columnName, index] of Object.entries(columnMap)) {
-      const dataIdx = dataMap[columnName];
-      if (dataIdx === void 0) {
-        throw Error(
-          `ArrayDataSource column ${columnName} is not in underlying data set`
-        );
-      } else if (dataIdx !== index - mapOffset) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-var getDataIndices = (columnMap, dataMap) => {
-  const { count: mapOffset } = metadataKeys;
-  const result = [];
-  Object.entries(columnMap).forEach(([columnName]) => {
-    result.push(dataMap[columnName] + mapOffset);
-  });
-  return result;
-};
-var buildDataToClientMap = (columnMap, dataMap) => {
-  if (dataMap && divergentMaps(columnMap, dataMap)) {
-    return getDataIndices(columnMap, dataMap);
-  }
-  return void 0;
+// ../vuu-utils/src/column-utils.ts
+var metadataKeys = {
+  IDX: 0,
+  RENDER_IDX: 1,
+  IS_LEAF: 2,
+  IS_EXPANDED: 3,
+  DEPTH: 4,
+  COUNT: 5,
+  KEY: 6,
+  SELECTED: 7,
+  count: 8,
+  // TODO following only used in datamodel
+  PARENT_IDX: "parent_idx",
+  IDX_POINTER: "idx_pointer",
+  FILTER_COUNT: "filter_count",
+  NEXT_FILTER_IDX: "next_filter_idx"
 };
+var { DEPTH, IS_LEAF } = metadataKeys;
 
-// ../vuu-data-local/src/array-data-source/group-utils.ts
-var { DEPTH: DEPTH2, IS_EXPANDED, KEY } = metadataKeys;
-var collapseGroup = (key, groupedRows) => {
-  const rows = [];
-  for (let i = 0, idx = 0, collapsed = false, len = groupedRows.length; i < len; i++) {
-    const row = groupedRows[i];
-    const { [DEPTH2]: depth, [KEY]: rowKey } = row;
-    if (rowKey === key) {
-      const collapsedRow = row.slice();
-      collapsedRow[IS_EXPANDED] = false;
-      rows.push(collapsedRow);
-      idx += 1;
-      collapsed = true;
-      while (i < len - 1 && groupedRows[i + 1][DEPTH2] > depth) {
-        i += 1;
-      }
-    } else if (collapsed) {
-      const newRow = row.slice();
-      newRow[0] = idx;
-      newRow[1] = idx;
-      rows.push(newRow);
-      idx += 1;
-    } else {
-      rows.push(row);
-      idx += 1;
-    }
-  }
-  return rows;
-};
-var expandGroup = (keys, sourceRows, groupBy, columnMap, groupMap, processedData) => {
-  const groupIndices = groupBy.map((column) => columnMap[column]);
-  return dataRowsFromGroups2(
-    groupMap,
-    groupIndices,
-    keys,
-    sourceRows,
-    void 0,
-    void 0,
-    void 0,
-    processedData
-  );
-};
-var dataRowsFromGroups2 = (groupMap, groupIndices, openKeys, sourceRows = [], root = "$root", depth = 1, rows = [], processedData) => {
-  console.log(`dataRowsFromGroups2 1)`);
-  const keys = Object.keys(groupMap).sort();
-  for (const key of keys) {
-    const idx = rows.length;
-    const groupKey = `${root}|${key}`;
-    const row = [idx, idx, false, false, depth, 0, groupKey, 0];
-    row[groupIndices[depth - 1]] = key;
-    rows.push(row);
-    if (openKeys.includes(groupKey)) {
-      row[IS_EXPANDED] = true;
-      if (Array.isArray(groupMap[key])) {
-        pushChildren(
-          rows,
-          groupMap[key],
-          sourceRows,
-          groupKey,
-          depth + 1
-        );
-      } else {
-        dataRowsFromGroups2(
-          groupMap[key],
-          groupIndices,
-          openKeys,
-          sourceRows,
-          groupKey,
-          depth + 1,
-          rows,
-          processedData
-        );
-      }
-    }
-  }
-  console.log(`dataRowsFromGroups2 2)`);
-  for (const key in rows) {
-    for (const index in rows) {
-      if (rows[key][2] === false && processedData[index] != void 0) {
-        if (rows[key][groupIndices[0]] === processedData[index][groupIndices[0]]) {
-          rows[key] = rows[key].splice(0, 8).concat(
-            processedData[index].slice(
-              8,
-              // groupIndices[0] + 1,
-              processedData[index].length
-            )
-          );
-          break;
-        }
-      }
-    }
-  }
-  console.log(`dataRowsFromGroups2 3)`);
-  return rows;
-};
-var pushChildren = (rows, tree, sourceRows, parentKey, depth) => {
-  for (const rowIdx of tree) {
-    const idx = rows.length;
-    const sourceRow = sourceRows[rowIdx].slice();
-    sourceRow[0] = idx;
-    sourceRow[1] = idx;
-    sourceRow[DEPTH2] = depth;
-    sourceRow[KEY] = `${parentKey}|${sourceRow[KEY]}`;
-    rows.push(sourceRow);
-  }
-};
-var groupRows = (rows, groupBy, columnMap) => {
-  const groupIndices = groupBy.map((column) => columnMap[column]);
-  const groupTree = groupLeafRows(rows, groupIndices);
-  const groupedDataRows = dataRowsFromGroups(groupTree, groupIndices);
-  return [groupedDataRows, groupTree];
-};
-var dataRowsFromGroups = (groupTree, groupIndices) => {
-  const depth = 0;
-  const rows = [];
-  let idx = 0;
-  const keys = Object.keys(groupTree).sort();
-  for (const key of keys) {
-    const row = [
-      idx,
-      idx,
-      false,
-      false,
-      1,
-      0,
-      `$root|${key}`,
-      0
-    ];
-    row[groupIndices[depth]] = key;
-    rows.push(row);
-    idx += 1;
-  }
-  return rows;
-};
-function groupLeafRows(leafRows, groupby) {
-  const groups = {};
-  const levels = groupby.length;
-  const lastLevel = levels - 1;
-  for (let i = 0, len = leafRows.length; i < len; i++) {
-    const leafRow = leafRows[i];
-    let target = groups;
-    let targetNode;
-    let key;
-    for (let level = 0; level < levels; level++) {
-      const colIdx = groupby[level];
-      key = leafRow[colIdx].toString();
-      targetNode = target[key];
-      if (targetNode && level === lastLevel) {
-        targetNode.push(i);
-      } else if (targetNode) {
-        target = targetNode;
-      } else if (!targetNode && level < lastLevel) {
-        target = target[key] = {};
-      } else if (!targetNode) {
-        target[key] = [i];
-      }
-    }
-  }
-  console.log("!! groups", groups);
-  return groups;
+// ../vuu-utils/src/event-emitter.ts
+function isArrayOfListeners(listeners) {
+  return Array.isArray(listeners);
 }
-
-// ../vuu-data-local/src/array-data-source/sort-utils.ts
-var defaultSortPredicate = (r1, r2, [i, direction]) => {
-  const val1 = direction === "D" ? r2[i] : r1[i];
-  const val2 = direction === "D" ? r1[i] : r2[i];
-  if (val1 === val2) {
-    return 0;
-  } else if (val2 === null || val1 > val2) {
-    return 1;
-  } else {
-    return -1;
-  }
-};
-var sortComparator = (sortDefs) => {
-  if (sortDefs.length === 1) {
-    return singleColComparator(sortDefs);
-  } else if (sortDefs.length === 2) {
-    return twoColComparator(sortDefs);
-  } else {
-    return multiColComparator(sortDefs);
+function isOnlyListener(listeners) {
+  return !Array.isArray(listeners);
+}
+var _events;
+var EventEmitter = class {
+  constructor() {
+    __privateAdd(this, _events, /* @__PURE__ */ new Map());
   }
-};
-var singleColComparator = ([[i, direction]]) => (r1, r2) => {
-  const v1 = direction === "D" ? r2[i] : r1[i];
-  const v2 = direction === "D" ? r1[i] : r2[i];
-  return v1 > v2 ? 1 : v2 > v1 ? -1 : 0;
-};
-var twoColComparator = ([[idx1, direction1], [idx2, direction2]]) => (r1, r2) => {
-  const v1 = direction1 === "D" ? r2[idx1] : r1[idx1];
-  const v2 = direction1 === "D" ? r1[idx1] : r2[idx1];
-  const v3 = direction2 === "D" ? r2[idx2] : r1[idx2];
-  const v4 = direction2 === "D" ? r1[idx2] : r2[idx2];
-  return v1 > v2 ? 1 : v2 > v1 ? -1 : v3 > v4 ? 1 : v4 > v3 ? -1 : 0;
-};
-var multiColComparator = (sortDefs, test = defaultSortPredicate) => (r1, r2) => {
-  for (const sortDef of sortDefs) {
-    const result = test(r1, r2, sortDef);
-    if (result !== 0) {
-      return result;
+  addListener(event, listener) {
+    const listeners = __privateGet(this, _events).get(event);
+    if (!listeners) {
+      __privateGet(this, _events).set(event, listener);
+    } else if (isArrayOfListeners(listeners)) {
+      listeners.push(listener);
+    } else if (isOnlyListener(listeners)) {
+      __privateGet(this, _events).set(event, [listeners, listener]);
     }
   }
-  return 0;
-};
-var sortRows = (rows, { sortDefs }, columnMap) => {
-  const indexedSortDefs = sortDefs.map(({ column, sortType }) => [
-    columnMap[column],
-    sortType
-  ]);
-  const comparator = sortComparator(indexedSortDefs);
-  return rows.slice().sort(comparator);
-};
-
-// ../vuu-data-local/src/array-data-source/array-data-source.ts
-var { KEY: KEY2 } = metadataKeys;
-var { debug } = logger("ArrayDataSource");
-var toDataSourceRow = (key) => (data, index) => {
-  return [index, index, true, false, 1, 0, String(data[key]), 0, ...data];
-};
-var buildTableSchema = (columns, keyColumn) => {
-  const schema = {
-    columns: columns.map(({ name, serverDataType = "string" }) => ({
-      name,
-      serverDataType
-    })),
-    key: keyColumn != null ? keyColumn : columns[0].name,
-    table: { module: "", table: "Array" }
-  };
-  return schema;
-};
-var _columnMap, _config, _data, _links, _range, _selectedRowsCount, _size, _status, _title;
-var ArrayDataSource = class extends EventEmitter {
-  constructor({
-    aggregations,
-    // different from RemoteDataSource
-    columnDescriptors,
-    data,
-    dataMap,
-    filter,
-    groupBy,
-    keyColumn,
-    rangeChangeRowset = "delta",
-    sort,
-    title,
-    viewport
-  }) {
-    super();
-    this.lastRangeServed = { from: 0, to: 0 };
-    this.openTreeNodes = [];
-    /** Map reflecting positions of columns in client data sent to user */
-    __privateAdd(this, _columnMap, void 0);
-    __privateAdd(this, _config, vanillaConfig);
-    __privateAdd(this, _data, void 0);
-    __privateAdd(this, _links, void 0);
-    __privateAdd(this, _range, NULL_RANGE);
-    __privateAdd(this, _selectedRowsCount, 0);
-    __privateAdd(this, _size, 0);
-    __privateAdd(this, _status, "initialising");
-    __privateAdd(this, _title, void 0);
-    this.selectedRows = [];
-    this.keys = new KeySet(__privateGet(this, _range));
-    this.processedData = void 0;
-    this.insert = (row) => {
-      const dataSourceRow = toDataSourceRow(this.key)(row, this.size);
-      __privateGet(this, _data).push(dataSourceRow);
-      const { from, to } = __privateGet(this, _range);
-      const [rowIdx] = dataSourceRow;
-      if (rowIdx >= from && rowIdx < to) {
-        this.sendRowsToClient();
-      }
-    };
-    this.update = (row, columnName) => {
-      var _a;
-      const keyValue = row[this.key];
-      const colIndex = __privateGet(this, _columnMap)[columnName];
-      const dataColIndex = (_a = this.dataMap) == null ? void 0 : _a[columnName];
-      const dataIndex = __privateGet(this, _data).findIndex((row2) => row2[KEY2] === keyValue);
-      if (dataIndex !== -1 && dataColIndex !== void 0) {
-        const dataSourceRow = __privateGet(this, _data)[dataIndex];
-        dataSourceRow[colIndex] = row[dataColIndex];
-        const { from, to } = __privateGet(this, _range);
-        const [rowIdx] = dataSourceRow;
-        if (rowIdx >= from && rowIdx < to) {
-          this.sendRowsToClient(false, dataSourceRow);
-        }
-      }
-    };
-    this.updateRow = (row) => {
-      const keyValue = row[this.key];
-      const dataIndex = __privateGet(this, _data).findIndex((row2) => row2[KEY2] === keyValue);
-      if (dataIndex !== -1) {
-        const dataSourceRow = toDataSourceRow(this.key)(row, dataIndex);
-        __privateGet(this, _data)[dataIndex] = dataSourceRow;
-        const { from, to } = __privateGet(this, _range);
-        if (dataIndex >= from && dataIndex < to) {
-          this.sendRowsToClient(false, dataSourceRow);
+  removeListener(event, listener) {
+    if (!__privateGet(this, _events).has(event)) {
+      return;
+    }
+    const listenerOrListeners = __privateGet(this, _events).get(event);
+    let position = -1;
+    if (listenerOrListeners === listener) {
+      __privateGet(this, _events).delete(event);
+    } else if (Array.isArray(listenerOrListeners)) {
+      for (let i = length; i-- > 0; ) {
+        if (listenerOrListeners[i] === listener) {
+          position = i;
+          break;
         }
       }
-    };
-    if (!data || !columnDescriptors) {
-      throw Error(
-        "ArrayDataSource constructor called without data or without columnDescriptors"
-      );
-    }
-    this.columnDescriptors = columnDescriptors;
-    this.dataMap = dataMap;
-    this.key = keyColumn ? this.columnDescriptors.findIndex((col) => col.name === keyColumn) : 0;
-    this.rangeChangeRowset = rangeChangeRowset;
-    this.tableSchema = buildTableSchema(columnDescriptors, keyColumn);
-    this.viewport = viewport || uuid();
-    __privateSet(this, _size, data.length);
-    __privateSet(this, _title, title);
-    const columns = columnDescriptors.map((col) => col.name);
-    __privateSet(this, _columnMap, buildColumnMap(columns));
-    this.dataIndices = buildDataToClientMap(__privateGet(this, _columnMap), this.dataMap);
-    __privateSet(this, _data, data.map(toDataSourceRow(this.key)));
-    this.config = {
-      ...__privateGet(this, _config),
-      aggregations: aggregations || __privateGet(this, _config).aggregations,
-      columns,
-      filter: filter || __privateGet(this, _config).filter,
-      groupBy: groupBy || __privateGet(this, _config).groupBy,
-      sort: sort || __privateGet(this, _config).sort
-    };
-    debug == null ? void 0 : debug(`columnMap: ${JSON.stringify(__privateGet(this, _columnMap))}`);
-  }
-  async subscribe({
-    viewport = ((_a) => (_a = this.viewport) != null ? _a : uuid())(),
-    columns,
-    aggregations,
-    range,
-    sort,
-    groupBy,
-    filter
-  }, callback) {
-    var _a2;
-    this.clientCallback = callback;
-    this.viewport = viewport;
-    __privateSet(this, _status, "subscribed");
-    this.lastRangeServed = { from: 0, to: 0 };
-    let config = __privateGet(this, _config);
-    const hasConfigProps = aggregations || columns || filter || groupBy || sort;
-    if (hasConfigProps) {
-      if (range) {
-        __privateSet(this, _range, range);
+      if (position < 0) {
+        return;
       }
-      config = {
-        ...config,
-        aggregations: aggregations || __privateGet(this, _config).aggregations,
-        columns: columns || __privateGet(this, _config).columns,
-        filter: filter || __privateGet(this, _config).filter,
-        groupBy: groupBy || __privateGet(this, _config).groupBy,
-        sort: sort || __privateGet(this, _config).sort
-      };
-    }
-    (_a2 = this.clientCallback) == null ? void 0 : _a2.call(this, {
-      ...config,
-      type: "subscribed",
-      clientViewportId: this.viewport,
-      range: __privateGet(this, _range),
-      tableSchema: this.tableSchema
-    });
-    if (hasConfigProps) {
-      this.config = config;
-    } else {
-      this.clientCallback({
-        clientViewportId: this.viewport,
-        mode: "size-only",
-        type: "viewport-update",
-        size: __privateGet(this, _data).length
-      });
-      if (range) {
-        this.range = range;
-      } else if (__privateGet(this, _range) !== NULL_RANGE) {
-        this.sendRowsToClient();
+      if (listenerOrListeners.length === 1) {
+        listenerOrListeners.length = 0;
+        __privateGet(this, _events).delete(event);
+      } else {
+        listenerOrListeners.splice(position, 1);
       }
     }
   }
-  unsubscribe() {
-    console.log("unsubscribe noop");
-  }
-  suspend() {
-    return this;
-  }
-  resume() {
-    return this;
-  }
-  disable() {
-    return this;
-  }
-  enable() {
-    return this;
-  }
-  select(selected) {
-    __privateSet(this, _selectedRowsCount, selected.length);
-    debug == null ? void 0 : debug(`select ${JSON.stringify(selected)}`);
-    this.selectedRows = selected;
-    this.setRange(resetRange(__privateGet(this, _range)), true);
-  }
-  openTreeNode(key) {
-    this.openTreeNodes.push(key);
-    this.processedData = expandGroup(
-      this.openTreeNodes,
-      __privateGet(this, _data),
-      __privateGet(this, _config).groupBy,
-      __privateGet(this, _columnMap),
-      this.groupMap,
-      this.processedData
-    );
-    this.setRange(resetRange(__privateGet(this, _range)), true);
-  }
-  closeTreeNode(key) {
-    this.openTreeNodes = this.openTreeNodes.filter((value) => value !== key);
-    if (this.processedData) {
-      this.processedData = collapseGroup(key, this.processedData);
-      this.setRange(resetRange(__privateGet(this, _range)), true);
-    }
-  }
-  get links() {
-    return __privateGet(this, _links);
-  }
-  get menu() {
-    return this._menu;
-  }
-  get status() {
-    return __privateGet(this, _status);
-  }
-  get data() {
-    return __privateGet(this, _data);
-  }
-  // Only used by the UpdateGenerator
-  get currentData() {
-    var _a;
-    return (_a = this.processedData) != null ? _a : __privateGet(this, _data);
-  }
-  get table() {
-    return this.tableSchema.table;
-  }
-  get config() {
-    return __privateGet(this, _config);
-  }
-  set config(config) {
-    var _a;
-    if (this.applyConfig(config)) {
-      if (config) {
-        const originalConfig = __privateGet(this, _config);
-        const newConfig = ((_a = config == null ? void 0 : config.filter) == null ? void 0 : _a.filter) && (config == null ? void 0 : config.filter.filterStruct) === void 0 ? {
-          ...config,
-          filter: {
-            filter: config.filter.filter,
-            filterStruct: parseFilter(config.filter.filter)
-          }
-        } : config;
-        __privateSet(this, _config, withConfigDefaults(newConfig));
-        let processedData;
-        if (hasFilter(config)) {
-          const { filter, filterStruct = parseFilter(filter) } = config.filter;
-          if (filterStruct) {
-            const fn = filterPredicate(__privateGet(this, _columnMap), filterStruct);
-            processedData = __privateGet(this, _data).filter(fn);
-          } else {
-            throw Error("filter must include filterStruct");
-          }
-        }
-        if (hasSort(config)) {
-          processedData = sortRows(
-            processedData != null ? processedData : __privateGet(this, _data),
-            config.sort,
-            __privateGet(this, _columnMap)
-          );
-        }
-        if (this.openTreeNodes.length > 0 && groupByChanged(originalConfig, config)) {
-          if (__privateGet(this, _config).groupBy.length === 0) {
-            this.openTreeNodes.length = 0;
-          } else {
-            console.log("adjust the openTReeNodes groupBy changed ", {
-              originalGroupBy: originalConfig.groupBy,
-              newGroupBy: newConfig.groupBy
-            });
-          }
-        }
-        if (hasGroupBy(config)) {
-          const [groupedData, groupMap] = groupRows(
-            processedData != null ? processedData : __privateGet(this, _data),
-            config.groupBy,
-            __privateGet(this, _columnMap)
-          );
-          this.groupMap = groupMap;
-          processedData = groupedData;
-          if (this.openTreeNodes.length > 0) {
-            processedData = expandGroup(
-              this.openTreeNodes,
-              __privateGet(this, _data),
-              __privateGet(this, _config).groupBy,
-              __privateGet(this, _columnMap),
-              this.groupMap,
-              processedData
-            );
-          }
-        }
-        this.processedData = processedData == null ? void 0 : processedData.map((row, i) => {
-          const dolly = row.slice();
-          dolly[0] = i;
-          dolly[1] = i;
-          return dolly;
-        });
-      }
-      this.setRange(resetRange(__privateGet(this, _range)), true);
-      this.emit("config", __privateGet(this, _config));
+  removeAllListeners(event) {
+    if (event && __privateGet(this, _events).has(event)) {
+      __privateGet(this, _events).delete(event);
+    } else if (event === void 0) {
+      __privateGet(this, _events).clear();
     }
   }
-  applyConfig(config) {
-    var _a;
-    if (configChanged(__privateGet(this, _config), config)) {
-      if (config) {
-        const newConfig = ((_a = config == null ? void 0 : config.filter) == null ? void 0 : _a.filter) && (config == null ? void 0 : config.filter.filterStruct) === void 0 ? {
-          ...config,
-          filter: {
-            filter: config.filter.filter,
-            filterStruct: parseFilter(config.filter.filter)
-          }
-        } : config;
-        __privateSet(this, _config, withConfigDefaults(newConfig));
-        return true;
+  emit(event, ...args) {
+    if (__privateGet(this, _events)) {
+      const handler = __privateGet(this, _events).get(event);
+      if (handler) {
+        this.invokeHandler(handler, args);
       }
     }
   }
-  get selectedRowsCount() {
-    return __privateGet(this, _selectedRowsCount);
-  }
-  get size() {
-    var _a, _b;
-    return (_b = (_a = this.processedData) == null ? void 0 : _a.length) != null ? _b : __privateGet(this, _data).length;
-  }
-  get range() {
-    return __privateGet(this, _range);
-  }
-  set range(range) {
-    if (range.from !== __privateGet(this, _range).from || range.to !== __privateGet(this, _range).to) {
-      this.setRange(range);
-    }
-  }
-  delete(row) {
-    console.log(`delete row ${row.join(",")}`);
-  }
-  setRange(range, forceFullRefresh = false) {
-    __privateSet(this, _range, range);
-    this.keys.reset(range);
-    this.sendRowsToClient(forceFullRefresh);
-  }
-  sendRowsToClient(forceFullRefresh = false, row) {
-    var _a, _b, _c;
-    if (row) {
-      (_a = this.clientCallback) == null ? void 0 : _a.call(this, {
-        clientViewportId: this.viewport,
-        mode: "update",
-        rows: [
-          toClientRow(row, this.keys, this.selectedRows, this.dataIndices)
-        ],
-        type: "viewport-update"
-      });
-    } else {
-      const rowRange = this.rangeChangeRowset === "delta" && !forceFullRefresh ? rangeNewItems(this.lastRangeServed, __privateGet(this, _range)) : __privateGet(this, _range);
-      const data = (_b = this.processedData) != null ? _b : __privateGet(this, _data);
-      const rowsWithinViewport = data.slice(rowRange.from, rowRange.to).map(
-        (row2) => toClientRow(row2, this.keys, this.selectedRows, this.dataIndices)
-      );
-      (_c = this.clientCallback) == null ? void 0 : _c.call(this, {
-        clientViewportId: this.viewport,
-        mode: "batch",
-        rows: rowsWithinViewport,
-        size: data.length,
-        type: "viewport-update"
-      });
-      this.lastRangeServed = {
-        from: __privateGet(this, _range).from,
-        to: Math.min(
-          __privateGet(this, _range).to,
-          __privateGet(this, _range).from + rowsWithinViewport.length
-        )
-      };
-    }
-  }
-  get columns() {
-    return __privateGet(this, _config).columns;
-  }
-  set columns(columns) {
-    const addedColumns = getAddedItems(this.config.columns, columns);
-    if (addedColumns.length > 0) {
-      const columnsWithoutDescriptors = getMissingItems(
-        this.columnDescriptors,
-        addedColumns,
-        (col) => col.name
-      );
-      console.log(`columnsWithoutDescriptors`, {
-        columnsWithoutDescriptors
-      });
-    }
-    __privateSet(this, _columnMap, buildColumnMap(columns));
-    this.dataIndices = buildDataToClientMap(__privateGet(this, _columnMap), this.dataMap);
-    this.config = {
-      ...__privateGet(this, _config),
-      columns
-    };
-  }
-  get aggregations() {
-    return __privateGet(this, _config).aggregations;
-  }
-  set aggregations(aggregations) {
-    var _a;
-    __privateSet(this, _config, {
-      ...__privateGet(this, _config),
-      aggregations
-    });
-    const targetData = (_a = this.processedData) != null ? _a : __privateGet(this, _data);
-    const leafData = __privateGet(this, _data);
-    aggregateData(
-      aggregations,
-      targetData,
-      __privateGet(this, _config).groupBy,
-      leafData,
-      __privateGet(this, _columnMap),
-      this.groupMap
-    );
-    this.setRange(resetRange(__privateGet(this, _range)), true);
-    this.emit("config", __privateGet(this, _config));
-  }
-  get sort() {
-    return __privateGet(this, _config).sort;
-  }
-  set sort(sort) {
-    debug == null ? void 0 : debug(`sort ${JSON.stringify(sort)}`);
-    this.config = {
-      ...__privateGet(this, _config),
-      sort
-    };
-  }
-  get filter() {
-    return __privateGet(this, _config).filter;
-  }
-  set filter(filter) {
-    debug == null ? void 0 : debug(`filter ${JSON.stringify(filter)}`);
-    this.config = {
-      ...__privateGet(this, _config),
-      filter
-    };
-  }
-  get groupBy() {
-    return __privateGet(this, _config).groupBy;
-  }
-  set groupBy(groupBy) {
-    this.config = {
-      ...__privateGet(this, _config),
-      groupBy
+  once(event, listener) {
+    const handler = (...args) => {
+      this.removeListener(event, handler);
+      listener(...args);
     };
+    this.on(event, handler);
   }
-  get title() {
-    return __privateGet(this, _title);
-  }
-  set title(title) {
-    __privateSet(this, _title, title);
-  }
-  get _clientCallback() {
-    return this.clientCallback;
-  }
-  createLink({
-    parentVpId,
-    link: { fromColumn, toColumn }
-  }) {
-    console.log("create link", {
-      parentVpId,
-      fromColumn,
-      toColumn
-    });
-  }
-  removeLink() {
-    console.log("remove link");
+  on(event, listener) {
+    this.addListener(event, listener);
   }
-  findRow(rowKey) {
-    const row = __privateGet(this, _data)[rowKey];
-    if (row) {
-      return row;
+  hasListener(event, listener) {
+    const listeners = __privateGet(this, _events).get(event);
+    if (Array.isArray(listeners)) {
+      return listeners.includes(listener);
     } else {
-      throw `no row found for key ${rowKey}`;
+      return listeners === listener;
     }
   }
-  applyEdit(row, columnName, value) {
-    console.log(`ArrayDataSource applyEdit ${row[0]} ${columnName} ${value}`);
-    return Promise.resolve(true);
-  }
-  async menuRpcCall(rpcRequest) {
-    return new Promise((resolve) => {
-      const { type } = rpcRequest;
-      switch (type) {
-        case "VP_EDIT_CELL_RPC":
-          {
-          }
+  invokeHandler(handler, args) {
+    if (isArrayOfListeners(handler)) {
+      handler.slice().forEach((listener) => this.invokeHandler(listener, args));
+    } else {
+      switch (args.length) {
+        case 0:
+          handler();
+          break;
+        case 1:
+          handler(args[0]);
+          break;
+        case 2:
+          handler(args[0], args[1]);
           break;
         default:
-          resolve(void 0);
+          handler.call(null, ...args);
       }
-    });
+    }
   }
 };
-_columnMap = new WeakMap();
-_config = new WeakMap();
-_data = new WeakMap();
-_links = new WeakMap();
-_range = new WeakMap();
-_selectedRowsCount = new WeakMap();
-_size = new WeakMap();
-_status = new WeakMap();
-_title = new WeakMap();
-
-// ../vuu-data-local/src/json-data-source/json-data-source.ts
-var { DEPTH: DEPTH3, IDX, IS_EXPANDED: IS_EXPANDED2, IS_LEAF: IS_LEAF2, KEY: KEY3, SELECTED: SELECTED3 } = metadataKeys;
+_events = new WeakMap();
 
 // src/makeSuggestions.ts
 var cachedValues = /* @__PURE__ */ new Map();
@@ -5751,16 +1225,16 @@ var populateArray = (count, colGen, rowGen, columns) => {
 };
 
 // src/Table.ts
-var _data2, _dataMap, _indexOfKey, _index, _schema;
+var _data, _dataMap, _indexOfKey, _index, _schema;
 var Table = class extends EventEmitter {
   constructor(schema, data, dataMap, updateGenerator) {
     super();
-    __privateAdd(this, _data2, void 0);
+    __privateAdd(this, _data, void 0);
     __privateAdd(this, _dataMap, void 0);
     __privateAdd(this, _indexOfKey, void 0);
     __privateAdd(this, _index, /* @__PURE__ */ new Map());
     __privateAdd(this, _schema, void 0);
-    __privateSet(this, _data2, data);
+    __privateSet(this, _data, data);
     __privateSet(this, _dataMap, dataMap);
     __privateSet(this, _schema, schema);
     __privateSet(this, _indexOfKey, dataMap[schema.key]);
@@ -5769,13 +1243,13 @@ var Table = class extends EventEmitter {
     updateGenerator == null ? void 0 : updateGenerator.setRange({ from: 0, to: 100 });
   }
   buildIndex() {
-    for (let i = 0; i < __privateGet(this, _data2).length; i++) {
-      const key = __privateGet(this, _data2)[i][__privateGet(this, _indexOfKey)];
+    for (let i = 0; i < __privateGet(this, _data).length; i++) {
+      const key = __privateGet(this, _data)[i][__privateGet(this, _indexOfKey)];
       __privateGet(this, _index).set(key, i);
     }
   }
   get data() {
-    return __privateGet(this, _data2);
+    return __privateGet(this, _data);
   }
   get map() {
     return __privateGet(this, _dataMap);
@@ -5784,8 +1258,8 @@ var Table = class extends EventEmitter {
     return __privateGet(this, _schema);
   }
   insert(row) {
-    const index = __privateGet(this, _data2).length;
-    __privateGet(this, _data2).push(row);
+    const index = __privateGet(this, _data).length;
+    __privateGet(this, _data).push(row);
     const key = row[__privateGet(this, _indexOfKey)];
     __privateGet(this, _index).set(key, index);
     this.emit("insert", row);
@@ -5793,33 +1267,33 @@ var Table = class extends EventEmitter {
   findByKey(key) {
     var _a;
     const index = (_a = __privateGet(this, _index).get(key)) != null ? _a : -1;
-    return __privateGet(this, _data2)[index];
+    return __privateGet(this, _data)[index];
   }
   update(key, columnName, value) {
-    const rowIndex = __privateGet(this, _data2).findIndex(
+    const rowIndex = __privateGet(this, _data).findIndex(
       (row) => row[__privateGet(this, _indexOfKey)] === key
     );
     const colIndex = __privateGet(this, _dataMap)[columnName];
     if (rowIndex !== -1) {
-      const row = __privateGet(this, _data2)[rowIndex];
+      const row = __privateGet(this, _data)[rowIndex];
       const newRow = row.slice();
       newRow[colIndex] = value;
-      __privateGet(this, _data2)[rowIndex] = newRow;
+      __privateGet(this, _data)[rowIndex] = newRow;
       this.emit("update", newRow, columnName);
     }
   }
   updateRow(row) {
     const key = row[__privateGet(this, _indexOfKey)];
-    const rowIndex = __privateGet(this, _data2).findIndex(
+    const rowIndex = __privateGet(this, _data).findIndex(
       (row2) => row2[__privateGet(this, _indexOfKey)] === key
     );
     if (rowIndex !== -1) {
-      __privateGet(this, _data2)[rowIndex] = row;
+      __privateGet(this, _data)[rowIndex] = row;
       this.emit("update", row);
     }
   }
 };
-_data2 = new WeakMap();
+_data = new WeakMap();
 _dataMap = new WeakMap();
 _indexOfKey = new WeakMap();
 _index = new WeakMap();