@stream-mdx/react 0.5.0 → 1.0.0

package/dist/contexts/math-tracker.cjs

@@ -6,17 +6,14 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
     for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 
 // src/contexts/math-tracker.ts
 var math_tracker_exports = {};
@@ -27,19 +24,15 @@ __export(math_tracker_exports, {
 module.exports = __toCommonJS(math_tracker_exports);
 
 // ../../node_modules/@lezer/common/dist/index.js
-var DefaultBufferLength = 1024;
 var nextPropID = 0;
 var NodeProp = class {
   /**
   Create a new node prop type.
   */
   constructor(config = {}) {
-    this.id = nextPropID++;
-    this.perNode = !!config.perNode;
-    this.deserialize = config.deserialize || (() => {
+    this.id = nextPropID++, this.perNode = !!config.perNode, this.deserialize = config.deserialize || (() => {
       throw new Error("This node type doesn't define a deserialize function");
-    });
-    this.combine = config.combine || null;
+    }), this.combine = config.combine || null;
   }
   /**
   This is meant to be used with
@@ -53,9 +46,7 @@ var NodeProp = class {
   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) => {
+    return typeof match != "function" && (match = NodeType.match(match)), (type) => {
       let result = match(type);
       return result === void 0 ? null : [this, result];
     };
@@ -69,14 +60,12 @@ NodeProp.isolate = new NodeProp({ deserialize: (value) => {
     throw new RangeError("Invalid value for isolate: " + value);
   return value || "auto";
 } });
-NodeProp.contextHash = new NodeProp({ perNode: true });
-NodeProp.lookAhead = new NodeProp({ perNode: true });
-NodeProp.mounted = new NodeProp({ perNode: true });
+NodeProp.contextHash = new NodeProp({ perNode: !0 });
+NodeProp.lookAhead = new NodeProp({ perNode: !0 });
+NodeProp.mounted = new NodeProp({ perNode: !0 });
 var MountedTree = class {
   constructor(tree, overlay, parser) {
-    this.tree = tree;
-    this.overlay = overlay;
-    this.parser = parser;
+    this.tree = tree, this.overlay = overlay, this.parser = parser;
   }
   /**
   @internal
@@ -84,35 +73,26 @@ var MountedTree = class {
   static get(tree) {
     return tree && tree.props && tree.props[NodeProp.mounted.id];
   }
-};
-var noProps = /* @__PURE__ */ Object.create(null);
-var NodeType = class _NodeType {
+}, noProps = /* @__PURE__ */ Object.create(null), NodeType = class _NodeType {
   /**
   @internal
   */
   constructor(name, props, id2, flags = 0) {
-    this.name = name;
-    this.props = props;
-    this.id = id2;
-    this.flags = flags;
+    this.name = name, this.props = props, this.id = id2, 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) {
+    let props = spec.props && spec.props.length ? /* @__PURE__ */ Object.create(null) : noProps, flags = (spec.top ? 1 : 0) | (spec.skipped ? 2 : 0) | (spec.error ? 4 : 0) | (spec.name == null ? 8 : 0), 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)), 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;
   }
   /**
@@ -154,9 +134,9 @@ var NodeType = class _NodeType {
   is(name) {
     if (typeof name == "string") {
       if (this.name == name)
-        return true;
+        return !0;
       let group = this.prop(NodeProp.group);
-      return group ? group.indexOf(name) > -1 : false;
+      return group ? group.indexOf(name) > -1 : !1;
     }
     return this.id == name;
   }
@@ -189,26 +169,16 @@ NodeType.none = new NodeType(
   8
   /* NodeFlag.Anonymous */
 );
-var CachedNode = /* @__PURE__ */ new WeakMap();
-var CachedInnerNode = /* @__PURE__ */ new WeakMap();
-var IterMode;
+var CachedNode = /* @__PURE__ */ new WeakMap(), CachedInnerNode = /* @__PURE__ */ new WeakMap(), IterMode;
 (function(IterMode2) {
-  IterMode2[IterMode2["ExcludeBuffers"] = 1] = "ExcludeBuffers";
-  IterMode2[IterMode2["IncludeAnonymous"] = 2] = "IncludeAnonymous";
-  IterMode2[IterMode2["IgnoreMounts"] = 4] = "IgnoreMounts";
-  IterMode2[IterMode2["IgnoreOverlays"] = 8] = "IgnoreOverlays";
+  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, length, props) {
-    this.type = type;
-    this.children = children;
-    this.positions = positions;
-    this.length = length;
-    this.props = null;
-    if (props && props.length) {
+    if (this.type = type, this.children = children, this.positions = positions, this.length = length, this.props = null, props && props.length) {
       this.props = /* @__PURE__ */ Object.create(null);
       for (let [prop, value] of props)
         this.props[typeof prop == "number" ? prop : prop.id] = value;
@@ -224,13 +194,9 @@ var Tree = class _Tree {
     let children = "";
     for (let ch of this.children) {
       let str = ch.toString();
-      if (str) {
-        if (children)
-          children += ",";
-        children += str;
-      }
+      str && (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 + ")" : "");
+    return this.type.name ? (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (children.length ? "(" + children + ")" : "") : children;
   }
   /**
   Get a [tree cursor](#common.TreeCursor) positioned at the top of
@@ -246,11 +212,8 @@ var Tree = class _Tree {
   [`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;
+    let scope = CachedNode.get(this) || this.topNode, cursor = new TreeCursor(scope);
+    return cursor.moveTo(pos, side), CachedNode.set(this, cursor._tree), cursor;
   }
   /**
   Get a [syntax node](#common.SyntaxNode) object for the top of the
@@ -271,9 +234,8 @@ var Tree = class _Tree {
   [`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;
+    let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, !1);
+    return CachedNode.set(this, node), node;
   }
   /**
   Like [`resolve`](#common.Tree.resolve), but will enter
@@ -283,9 +245,8 @@ var Tree = class _Tree {
   the host trees).
   */
   resolveInner(pos, side = 0) {
-    let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
-    CachedInnerNode.set(this, node);
-    return node;
+    let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, !0);
+    return CachedInnerNode.set(this, node), node;
   }
   /**
   In some situations, it can be useful to iterate through all
@@ -305,23 +266,18 @@ var Tree = class _Tree {
   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;
+    let { enter, leave, from = 0, to = this.length } = spec, 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)) {
+      let entered = !1;
+      if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== !1)) {
         if (c.firstChild())
           continue;
-        entered = true;
+        entered = !0;
       }
-      for (; ; ) {
-        if (entered && leave && (anon || !c.type.isAnonymous))
-          leave(c);
-        if (c.nextSibling())
-          break;
+      for (; entered && leave && (anon || !c.type.isAnonymous) && leave(c), !c.nextSibling(); ) {
         if (!c.parent())
           return;
-        entered = true;
+        entered = !0;
       }
     }
   }
@@ -330,7 +286,7 @@ var Tree = class _Tree {
   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;
+    return prop.perNode ? this.props ? this.props[prop.id] : void 0 : this.type.prop(prop);
   }
   /**
   Returns the node's [per-node props](#common.NodeProp.perNode) in a
@@ -363,8 +319,7 @@ var Tree = class _Tree {
 Tree.empty = new Tree(NodeType.none, [], [], 0);
 var FlatBufferCursor = class _FlatBufferCursor {
   constructor(buffer, index) {
-    this.buffer = buffer;
-    this.index = index;
+    this.buffer = buffer, this.index = index;
   }
   get id() {
     return this.buffer[this.index - 4];
@@ -387,15 +342,12 @@ var FlatBufferCursor = class _FlatBufferCursor {
   fork() {
     return new _FlatBufferCursor(this.buffer, this.index);
   }
-};
-var TreeBuffer = class _TreeBuffer {
+}, TreeBuffer = class _TreeBuffer {
   /**
   Create a tree buffer.
   */
   constructor(buffer, length, set) {
-    this.buffer = buffer;
-    this.length = length;
-    this.set = set;
+    this.buffer = buffer, this.length = length, this.set = set;
   }
   /**
   @internal
@@ -408,28 +360,20 @@ var TreeBuffer = class _TreeBuffer {
   */
   toString() {
     let result = [];
-    for (let index = 0; index < this.buffer.length; ) {
-      result.push(this.childString(index));
-      index = this.buffer[index + 3];
-    }
+    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 id2 = this.buffer[index], endIndex = this.buffer[index + 3];
-    let type = this.set.types[id2], result = type.name;
-    if (/\W/.test(result) && !type.isError)
-      result = JSON.stringify(result);
-    index += 4;
-    if (endIndex == index)
+    let id2 = this.buffer[index], endIndex = this.buffer[index + 3], type = this.set.types[id2], result = type.name;
+    if (/\W/.test(result) && !type.isError && (result = JSON.stringify(result)), index += 4, endIndex == index)
       return result;
     let children = [];
-    while (index < endIndex) {
-      children.push(this.childString(index));
-      index = this.buffer[index + 3];
-    }
+    for (; index < endIndex; )
+      children.push(this.childString(index)), index = this.buffer[index + 3];
     return result + "(" + children.join(",") + ")";
   }
   /**
@@ -437,27 +381,19 @@ var TreeBuffer = class _TreeBuffer {
   */
   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;
-      }
-    }
+    for (let i = startIndex; i != endIndex && !(checkSide(side, pos, buffer[i + 1], buffer[i + 2]) && (pick = i, dir > 0)); i = buffer[i + 3])
+      ;
     return pick;
   }
   /**
   @internal
   */
   slice(startI, endI, from) {
-    let b = this.buffer;
-    let copy = new Uint16Array(endI - startI), len = 0;
+    let b = this.buffer, copy = new Uint16Array(endI - startI), len = 0;
     for (let i = startI, j = 0; i < endI; ) {
-      copy[j++] = b[i++];
-      copy[j++] = b[i++] - from;
+      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);
+      copy[j++] = b[i++] - startI, len = Math.max(len, to);
     }
     return new _TreeBuffer(copy, len, this.set);
   }
@@ -475,12 +411,11 @@ function checkSide(side, pos, from, to) {
     case 2:
       return to > pos;
     case 4:
-      return true;
+      return !0;
   }
 }
 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)) {
+  for (var _a; 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;
@@ -488,10 +423,8 @@ function resolveNode(node, pos, side, overlays) {
   }
   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 scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent)
+      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)
@@ -511,26 +444,21 @@ var BaseNode = class {
     return getChildren(this, type, before, after);
   }
   resolve(pos, side = 0) {
-    return resolveNode(this, pos, side, false);
+    return resolveNode(this, pos, side, !1);
   }
   resolveInner(pos, side = 0) {
-    return resolveNode(this, pos, side, true);
+    return resolveNode(this, pos, side, !0);
   }
   matchContext(context) {
     return matchNodeContext(this.parent, context);
   }
   enterUnfinishedNodesBefore(pos) {
     let scan = this.childBefore(pos), node = this;
-    while (scan) {
+    for (; scan; ) {
       let last = scan.lastChild;
       if (!last || last.to != scan.to)
         break;
-      if (last.type.isError && last.from == last.to) {
-        node = scan;
-        scan = last.prevSibling;
-      } else {
-        scan = last;
-      }
+      last.type.isError && last.from == last.to ? (node = scan, scan = last.prevSibling) : scan = last;
     }
     return node;
   }
@@ -540,14 +468,9 @@ var BaseNode = class {
   get next() {
     return this.parent;
   }
-};
-var TreeNode = class _TreeNode extends BaseNode {
+}, TreeNode = class _TreeNode extends BaseNode {
   constructor(_tree, from, index, _parent) {
-    super();
-    this._tree = _tree;
-    this.from = from;
-    this.index = index;
-    this._parent = _parent;
+    super(), this._tree = _tree, this.from = from, this.index = index, this._parent = _parent;
   }
   get type() {
     return this._tree.type;
@@ -562,30 +485,23 @@ var TreeNode = class _TreeNode extends BaseNode {
     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) && (mounted = MountedTree.get(next)) && !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 (checkSide(side, pos, start, start + next.length)) {
+          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) && (mounted = MountedTree.get(next)) && !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)
+      if (mode & IterMode.IncludeAnonymous || !parent.type.isAnonymous || (parent.index >= 0 ? i = parent.index + dir : i = dir < 0 ? -1 : parent._parent._tree.children.length, parent = parent._parent, !parent))
         return null;
     }
   }
@@ -632,16 +548,15 @@ var TreeNode = class _TreeNode extends BaseNode {
     let mounted;
     if (!(mode & IterMode.IgnoreOverlays) && (mounted = MountedTree.get(this._tree)) && mounted.overlay) {
       let rPos = pos - this.from;
-      for (let { from, to } of mounted.overlay) {
+      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)
+    for (; val.type.isAnonymous && val._parent; )
       val = val._parent;
     return val;
   }
@@ -683,42 +598,35 @@ function getChildren(node, type, before, after) {
   let cur = node.cursor(), result = [];
   if (!cur.firstChild())
     return result;
-  if (before != null)
-    for (let found = false; !found; ) {
-      found = cur.type.is(before);
-      if (!cur.nextSibling())
+  if (before != null) {
+    for (let found = !1; !found; )
+      if (found = cur.type.is(before), !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())
+    if (cur.type.is(type) && result.push(cur.node), !cur.nextSibling())
       return after == null ? result : [];
   }
 }
 function matchNodeContext(node, context, i = context.length - 1) {
   for (let p = node; i >= 0; p = p.parent) {
     if (!p)
-      return false;
+      return !1;
     if (!p.type.isAnonymous) {
       if (context[i] && context[i] != p.name)
-        return false;
+        return !1;
       i--;
     }
   }
-  return true;
+  return !0;
 }
 var BufferContext = class {
   constructor(parent, buffer, index, start) {
-    this.parent = parent;
-    this.buffer = buffer;
-    this.index = index;
-    this.start = start;
+    this.parent = parent, this.buffer = buffer, this.index = index, this.start = start;
   }
-};
-var BufferNode = class _BufferNode extends BaseNode {
+}, BufferNode = class _BufferNode extends BaseNode {
   get name() {
     return this.type.name;
   }
@@ -729,15 +637,10 @@ var BufferNode = class _BufferNode extends BaseNode {
     return this.context.start + this.context.buffer.buffer[this.index + 2];
   }
   constructor(context, _parent, index) {
-    super();
-    this.context = context;
-    this._parent = _parent;
-    this.index = index;
-    this.type = context.buffer.set.types[context.buffer.buffer[index]];
+    super(), 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);
+    let { buffer } = this.context, 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() {
@@ -778,8 +681,7 @@ var BufferNode = class _BufferNode extends BaseNode {
   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);
+    let { buffer } = this.context, 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() {
@@ -795,18 +697,12 @@ var BufferNode = class _BufferNode extends BaseNode {
     );
   }
   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);
+    let { buffer } = this.context, after = buffer.buffer[this.index + 3];
+    return after < (this._parent ? buffer.buffer[this._parent.index + 3] : buffer.buffer.length) ? new _BufferNode(this.context, this._parent, after) : 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(
+    let { buffer } = this.context, parentStart = this._parent ? this._parent.index + 4 : 0;
+    return this.index == parentStart ? this.externalSibling(-1) : new _BufferNode(this.context, this._parent, buffer.findChild(
       parentStart,
       this.index,
       -1,
@@ -819,13 +715,10 @@ var BufferNode = class _BufferNode extends BaseNode {
     return null;
   }
   toTree() {
-    let children = [], positions = [];
-    let { buffer } = this.context;
-    let startI = this.index + 4, endI = buffer.buffer[this.index + 3];
+    let children = [], positions = [], { buffer } = this.context, 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);
+      children.push(buffer.slice(startI, endI, from)), positions.push(0);
     }
     return new Tree(this.type, children, positions, this.to - this.from);
   }
@@ -842,23 +735,14 @@ function iterStack(heads) {
   let pick = 0, picked = heads[0];
   for (let i = 1; i < heads.length; i++) {
     let node = heads[i];
-    if (node.from > picked.from || node.to < picked.to) {
-      picked = node;
-      pick = i;
-    }
+    (node.from > picked.from || node.to < picked.to) && (picked = node, pick = i);
   }
-  let next = picked instanceof TreeNode && picked.index < 0 ? null : picked.parent;
-  let newHeads = heads.slice();
-  if (next)
-    newHeads[pick] = next;
-  else
-    newHeads.splice(pick, 1);
-  return new StackIterator(newHeads, picked);
+  let next = picked instanceof TreeNode && picked.index < 0 ? null : picked.parent, newHeads = heads.slice();
+  return next ? newHeads[pick] = next : newHeads.splice(pick, 1), new StackIterator(newHeads, picked);
 }
 var StackIterator = class {
   constructor(heads, node) {
-    this.heads = heads;
-    this.node = node;
+    this.heads = heads, this.node = node;
   }
   get next() {
     return iterStack(this.heads);
@@ -866,19 +750,17 @@ var StackIterator = class {
 };
 function stackIterator(tree, pos, side) {
   let inner = tree.resolveInner(pos, side), layers = null;
-  for (let scan = inner instanceof TreeNode ? inner : inner.context.parent; scan; scan = scan.parent) {
+  for (let scan = inner instanceof TreeNode ? inner : inner.context.parent; scan; scan = scan.parent)
     if (scan.index < 0) {
       let parent = scan.parent;
-      (layers || (layers = [inner])).push(parent.resolve(pos, side));
-      scan = parent;
+      (layers || (layers = [inner])).push(parent.resolve(pos, side)), scan = parent;
     } else {
       let mount = MountedTree.get(scan.tree);
       if (mount && mount.overlay && mount.overlay[0].from <= pos && mount.overlay[mount.overlay.length - 1].to >= pos) {
         let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, -1, scan);
-        (layers || (layers = [inner])).push(resolveNode(root, pos, side, false));
+        (layers || (layers = [inner])).push(resolveNode(root, pos, side, !1));
       }
     }
-  }
   return layers ? iterStack(layers) : inner;
 }
 var TreeCursor = class {
@@ -892,51 +774,28 @@ var TreeCursor = class {
   @internal
   */
   constructor(node, mode = 0) {
-    this.mode = mode;
-    this.buffer = null;
-    this.stack = [];
-    this.index = 0;
-    this.bufferNode = null;
-    if (node instanceof TreeNode) {
+    if (this.mode = mode, this.buffer = null, this.stack = [], this.index = 0, this.bufferNode = null, node instanceof TreeNode)
       this.yieldNode(node);
-    } else {
-      this._tree = node.context.parent;
-      this.buffer = node.context;
+    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);
+      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;
+    return node ? (this._tree = node, this.type = node.type, this.from = node.from, this.to = node.to, !0) : !1;
   }
   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;
+    return this.type = type || buffer.set.types[buffer.buffer[index]], this.from = start + buffer.buffer[index + 1], this.to = start + buffer.buffer[index + 2], !0;
   }
   /**
   @internal
   */
   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);
+    return node ? node instanceof TreeNode ? (this.buffer = null, this.yieldNode(node)) : (this.buffer = node.context, this.yieldBuf(node.index, node.type)) : !1;
   }
   /**
   @internal
@@ -950,12 +809,8 @@ var TreeCursor = class {
   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);
+    let { buffer } = this.buffer, index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);
+    return index < 0 ? !1 : (this.stack.push(this.index), this.yieldBuf(index));
   }
   /**
   Move the cursor to this node's first child. When this returns
@@ -1010,9 +865,7 @@ var TreeCursor = class {
   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);
+    return this.buffer ? mode & IterMode.ExcludeBuffers ? !1 : this.enterChild(1, pos, side) : this.yield(this._tree.enter(pos, side, mode));
   }
   /**
   Move to the node's parent node, if this isn't the top node.
@@ -1023,15 +876,14 @@ var TreeCursor = class {
     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);
+    return this.buffer = null, 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));
+      return this._tree._parent ? this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4, this.mode)) : !1;
     let { buffer } = this.buffer, d = this.stack.length - 1;
     if (dir < 0) {
       let parentStart = d < 0 ? 0 : this.stack[d] + 4;
@@ -1049,7 +901,7 @@ var TreeCursor = class {
       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;
+    return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4, this.mode)) : !1;
   }
   /**
   Move to this node's next sibling, if any.
@@ -1068,25 +920,22 @@ var TreeCursor = class {
     if (buffer) {
       if (dir > 0) {
         if (this.index < buffer.buffer.buffer.length)
-          return false;
-      } else {
+          return !1;
+      } else
         for (let i = 0; i < this.index; i++)
           if (buffer.buffer.buffer[i + 3] < this.index)
-            return false;
-      }
+            return !1;
       ({ index, parent } = buffer);
-    } else {
+    } else
       ({ index, _parent: parent } = this._tree);
-    }
-    for (; parent; { index, _parent: parent } = parent) {
+    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 !1;
         }
-    }
-    return true;
+    return !0;
   }
   move(dir, enter) {
     if (enter && this.enterChild(
@@ -1095,12 +944,12 @@ var TreeCursor = class {
       4
       /* Side.DontCare */
     ))
-      return true;
+      return !0;
     for (; ; ) {
       if (this.sibling(dir))
-        return true;
+        return !0;
       if (this.atLastNode(dir) || !this.parent())
-        return false;
+        return !1;
     }
   }
   /**
@@ -1110,7 +959,7 @@ var TreeCursor = class {
   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) {
+  next(enter = !0) {
     return this.move(1, enter);
   }
   /**
@@ -1119,7 +968,7 @@ var TreeCursor = class {
   previous sibling or the previous sibling of the first parent
   node that has one.
   */
-  prev(enter = true) {
+  prev(enter = !0) {
     return this.move(-1, enter);
   }
   /**
@@ -1128,11 +977,10 @@ var TreeCursor = class {
   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)) {
-    }
+    for (; (this.from == this.to || (side < 1 ? this.from >= pos : this.from > pos) || (side > -1 ? this.to <= pos : this.to < pos)) && this.parent(); )
+      ;
+    for (; this.enterChild(1, pos, side); )
+      ;
     return this;
   }
   /**
@@ -1143,19 +991,17 @@ var TreeCursor = class {
     if (!this.buffer)
       return this._tree;
     let cache = this.bufferNode, result = null, depth = 0;
-    if (cache && cache.context == this.buffer) {
+    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;
+            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);
@@ -1176,26 +1022,20 @@ var TreeCursor = class {
   */
   iterate(enter, leave) {
     for (let depth = 0; ; ) {
-      let mustLeave = false;
-      if (this.type.isAnonymous || enter(this) !== false) {
+      let mustLeave = !1;
+      if (this.type.isAnonymous || enter(this) !== !1) {
         if (this.firstChild()) {
           depth++;
           continue;
         }
-        if (!this.type.isAnonymous)
-          mustLeave = true;
+        this.type.isAnonymous || (mustLeave = !0);
       }
       for (; ; ) {
-        if (mustLeave && leave)
-          leave(this);
-        mustLeave = this.type.isAnonymous;
-        if (!depth)
+        if (mustLeave && leave && leave(this), mustLeave = this.type.isAnonymous, !depth)
           return;
         if (this.nextSibling())
           break;
-        this.parent();
-        depth--;
-        mustLeave = true;
+        this.parent(), depth--, mustLeave = !0;
       }
     }
   }
@@ -1214,11 +1054,11 @@ var TreeCursor = class {
       let type = types[buffer.buffer[this.stack[d]]];
       if (!type.isAnonymous) {
         if (context[i] && context[i] != type.name)
-          return false;
+          return !1;
         i--;
       }
     }
-    return true;
+    return !0;
   }
 };
 function hasChild(tree) {
@@ -1226,19 +1066,13 @@ function hasChild(tree) {
 }
 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;
+  let { buffer, nodeSet, maxBufferLength = 1024, reused = [], minRepeatType = nodeSet.types.length } = data, cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer, types = nodeSet.types, contextHash = 0, lookAhead = 0;
   function takeNode(parentStart, minPos, children2, positions2, inRepeat, depth) {
-    let { id: id2, start, end, size } = cursor;
-    let lookAheadAtStart = lookAhead, contextAtStart = contextHash;
-    if (size < 0) {
-      cursor.next();
-      if (size == -1) {
+    let { id: id2, start, end, size } = cursor, lookAheadAtStart = lookAhead, contextAtStart = contextHash;
+    if (size < 0)
+      if (cursor.next(), size == -1) {
         let node2 = reused[id2];
-        children2.push(node2);
-        positions2.push(start - parentStart);
+        children2.push(node2), positions2.push(start - parentStart);
         return;
       } else if (size == -3) {
         contextHash = id2;
@@ -1246,81 +1080,45 @@ function buildTree(data) {
       } else if (size == -4) {
         lookAhead = id2;
         return;
-      } else {
+      } else
         throw new RangeError(`Unrecognized record size: ${size}`);
-      }
-    }
-    let type = types[id2], node, buffer2;
-    let startPos = start - parentStart;
+    let type = types[id2], node, buffer2, 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)
+      let data2 = new Uint16Array(buffer2.size - buffer2.skip), endPos = cursor.pos - buffer2.size, index = data2.length;
+      for (; cursor.pos > endPos; )
         index = copyToBuffer(buffer2.start, data2, index);
-      node = new TreeBuffer(data2, end - buffer2.start, nodeSet);
-      startPos = buffer2.start - parentStart;
+      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 = id2 >= minRepeatType ? id2 : -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, contextAtStart);
-            lastGroup = localChildren.length;
-            lastEnd = cursor.end;
-          }
-          cursor.next();
-        } else if (depth > 2500) {
-          takeFlatNode(start, endPos, localChildren, localPositions);
-        } else {
-          takeNode(start, endPos, localChildren, localPositions, localInRepeat, depth + 1);
-        }
-      }
-      if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)
-        makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart, contextAtStart);
-      localChildren.reverse();
-      localPositions.reverse();
-      if (localInRepeat > -1 && lastGroup > 0) {
+      let localChildren = [], localPositions = [], localInRepeat = id2 >= minRepeatType ? id2 : -1, lastGroup = 0, lastEnd = end;
+      for (; cursor.pos > endPos; )
+        localInRepeat >= 0 && cursor.id == localInRepeat && cursor.size >= 0 ? (cursor.end <= lastEnd - maxBufferLength && (makeRepeatLeaf(localChildren, localPositions, start, lastGroup, cursor.end, lastEnd, localInRepeat, lookAheadAtStart, contextAtStart), lastGroup = localChildren.length, lastEnd = cursor.end), cursor.next()) : depth > 2500 ? takeFlatNode(start, endPos, localChildren, localPositions) : takeNode(start, endPos, localChildren, localPositions, localInRepeat, depth + 1);
+      if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length && makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart, contextAtStart), localChildren.reverse(), localPositions.reverse(), localInRepeat > -1 && lastGroup > 0) {
         let make = makeBalanced(type, contextAtStart);
         node = balanceRange(type, localChildren, localPositions, 0, localChildren.length, 0, end - start, make, make);
-      } else {
+      } else
         node = makeTree(type, localChildren, localPositions, end - start, lookAheadAtStart - end, contextAtStart);
-      }
     }
-    children2.push(node);
-    positions2.push(startPos);
+    children2.push(node), positions2.push(startPos);
   }
   function takeFlatNode(parentStart, minPos, children2, positions2) {
-    let nodes = [];
-    let nodeCount = 0, stopAt = -1;
-    while (cursor.pos > minPos) {
+    let nodes = [], nodeCount = 0, stopAt = -1;
+    for (; cursor.pos > minPos; ) {
       let { id: id2, start, end, size } = cursor;
-      if (size > 4) {
-        cursor.next();
-      } else if (stopAt > -1 && start < stopAt) {
-        break;
-      } else {
-        if (stopAt < 0)
-          stopAt = end - maxBufferLength;
-        nodes.push(id2, start, end);
-        nodeCount++;
+      if (size > 4)
         cursor.next();
+      else {
+        if (stopAt > -1 && start < stopAt)
+          break;
+        stopAt < 0 && (stopAt = end - maxBufferLength), nodes.push(id2, start, end), nodeCount++, cursor.next();
       }
     }
     if (nodeCount) {
-      let buffer2 = new Uint16Array(nodeCount * 4);
-      let start = nodes[nodes.length - 2];
-      for (let i = nodes.length - 3, j = 0; i >= 0; i -= 3) {
-        buffer2[j++] = nodes[i];
-        buffer2[j++] = nodes[i + 1] - start;
-        buffer2[j++] = nodes[i + 2] - start;
-        buffer2[j++] = j;
-      }
-      children2.push(new TreeBuffer(buffer2, nodes[2] - start, nodeSet));
-      positions2.push(start - parentStart);
+      let buffer2 = new Uint16Array(nodeCount * 4), start = nodes[nodes.length - 2];
+      for (let i = nodes.length - 3, j = 0; i >= 0; i -= 3)
+        buffer2[j++] = nodes[i], buffer2[j++] = nodes[i + 1] - start, buffer2[j++] = nodes[i + 2] - start, buffer2[j++] = j;
+      children2.push(new TreeBuffer(buffer2, nodes[2] - start, nodeSet)), positions2.push(start - parentStart);
     }
   }
   function makeBalanced(type, contextHash2) {
@@ -1329,20 +1127,16 @@ function buildTree(data) {
       if (lastI >= 0 && (last = children2[lastI]) instanceof Tree) {
         if (!lastI && last.type == type && last.length == length2)
           return last;
-        if (lookAheadProp = last.prop(NodeProp.lookAhead))
-          lookAhead2 = positions2[lastI] + last.length + lookAheadProp;
+        (lookAheadProp = last.prop(NodeProp.lookAhead)) && (lookAhead2 = positions2[lastI] + last.length + lookAheadProp);
       }
       return makeTree(type, children2, positions2, length2, lookAhead2, contextHash2);
     };
   }
   function makeRepeatLeaf(children2, positions2, base, i, from, to, type, lookAhead2, contextHash2) {
     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, contextHash2));
-    positions2.push(from - base);
+    for (; 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, contextHash2)), positions2.push(from - base);
   }
   function makeTree(type, children2, positions2, length2, lookAhead2, contextHash2, props) {
     if (contextHash2) {
@@ -1356,71 +1150,45 @@ function buildTree(data) {
     return new Tree(type, children2, positions2, length2, 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 };
+    let fork = cursor.fork(), size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength, 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();
+        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) {
+      let localSkipped = fork.id >= minRepeatType ? 4 : 0, nodeStart = fork.start;
+      for (fork.next(); fork.pos > startPos; ) {
+        if (fork.size < 0)
           if (fork.size == -3 || fork.size == -4)
             localSkipped += 4;
           else
             break scan;
-        } else if (fork.id >= minRepeatType) {
-          localSkipped += 4;
-        }
+        else fork.id >= minRepeatType && (localSkipped += 4);
         fork.next();
       }
-      start = nodeStart;
-      size += nodeSize2;
-      skip += localSkipped;
+      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;
+    return (inRepeat < 0 || size == maxSize) && (result.size = size, result.start = start, result.skip = skip), result.size > 4 ? result : void 0;
   }
   function copyToBuffer(bufferStart, buffer2, index) {
     let { id: id2, start, end, size } = cursor;
-    cursor.next();
-    if (size >= 0 && id2 < minRepeatType) {
+    if (cursor.next(), size >= 0 && id2 < minRepeatType) {
       let startIndex = index;
       if (size > 4) {
         let endPos = cursor.pos - (size - 4);
-        while (cursor.pos > endPos)
+        for (; cursor.pos > endPos; )
           index = copyToBuffer(bufferStart, buffer2, index);
       }
-      buffer2[--index] = startIndex;
-      buffer2[--index] = end - bufferStart;
-      buffer2[--index] = start - bufferStart;
-      buffer2[--index] = id2;
-    } else if (size == -3) {
-      contextHash = id2;
-    } else if (size == -4) {
-      lookAhead = id2;
-    }
+      buffer2[--index] = startIndex, buffer2[--index] = end - bufferStart, buffer2[--index] = start - bufferStart, buffer2[--index] = id2;
+    } else size == -3 ? contextHash = id2 : size == -4 && (lookAhead = id2);
     return index;
   }
   let children = [], positions = [];
-  while (cursor.pos > 0)
+  for (; cursor.pos > 0; )
     takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1, 0);
   let length = (_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(), length);
@@ -1450,13 +1218,11 @@ function balanceRange(balanceType, children, positions, from, to, start, length,
   let maxChild = Math.ceil(
     total * 1.5 / 8
     /* Balance.BranchFactor */
-  );
-  let localChildren = [], localPositions = [];
+  ), 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++) {
+      for (i++; i < to2; i++) {
         let nextSize = nodeSize(balanceType, children2[i]);
         if (groupSize + nextSize >= maxChild)
           break;
@@ -1476,10 +1242,9 @@ function balanceRange(balanceType, children, positions, from, to, start, length,
       localPositions.push(groupStart + offset - start);
     }
   }
-  divide(children, positions, from, to, 0);
-  return (mkTop || mkTree)(localChildren, localPositions, length);
+  return divide(children, positions, from, to, 0), (mkTop || mkTree)(localChildren, localPositions, length);
 }
-var stoppedInner = new NodeProp({ perNode: true });
+var stoppedInner = new NodeProp({ perNode: !0 });
 
 // ../../node_modules/@lezer/lr/dist/index.js
 function decodeArray(input, Type = Uint16Array) {
@@ -1489,88 +1254,59 @@ function decodeArray(input, Type = Uint16Array) {
   for (let pos = 0, out = 0; pos < input.length; ) {
     let value = 0;
     for (; ; ) {
-      let next = input.charCodeAt(pos++), stop = false;
+      let next = input.charCodeAt(pos++), stop = !1;
       if (next == 126) {
         value = 65535;
         break;
       }
-      if (next >= 92)
-        next--;
-      if (next >= 34)
-        next--;
+      next >= 92 && next--, next >= 34 && next--;
       let digit = next - 32;
-      if (digit >= 46) {
-        digit -= 46;
-        stop = true;
-      }
-      value += digit;
-      if (stop)
+      if (digit >= 46 && (digit -= 46, stop = !0), value += digit, stop)
         break;
       value *= 46;
     }
-    if (array)
-      array[out++] = value;
-    else
-      array = new Type(value);
+    array ? array[out++] = value : 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;
+    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();
+}, nullToken = new CachedToken();
 var TokenGroup = class {
   constructor(data, id2) {
-    this.data = data;
-    this.id = id2;
+    this.data = data, this.id = id2;
   }
   token(input, stack) {
     let { parser } = stack.p;
     readToken(this.data, input, stack, this.id, parser.data, parser.tokenPrecTable);
   }
 };
-TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
+TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = !1;
 var LocalTokenGroup = class {
   constructor(data, precTable, elseToken) {
-    this.precTable = precTable;
-    this.elseToken = elseToken;
-    this.data = typeof data == "string" ? decodeArray(data) : data;
+    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)
+      if (readToken(this.data, input, stack, 0, this.data, this.precTable), input.token.value > -1)
         break;
       if (this.elseToken == null)
         return;
-      if (!atEof)
-        skipped++;
-      if (nextPos == null)
+      if (atEof || skipped++, nextPos == null)
         break;
       input.reset(nextPos, input.token);
     }
-    if (skipped) {
-      input.reset(start, input.token);
-      input.acceptToken(this.elseToken, skipped);
-    }
+    skipped && (input.reset(start, input.token), input.acceptToken(this.elseToken, skipped));
   }
 };
-LocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
+LocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = !1;
 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;
+  scan: for (; (groupMask & data[state]) != 0; ) {
     let accEnd = data[state + 1];
     for (let i = state + 3; i < accEnd; i += 2)
       if ((data[i + 1] & groupMask) > 0) {
@@ -1586,16 +1322,13 @@ function readToken(data, input, stack, group, precTable, precOffset) {
       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;
+      let mid = low + high >> 1, index = accEnd + mid + (mid << 1), 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();
+        state = data[index + 2], input.advance();
         continue scan;
       }
     }
@@ -1612,19 +1345,13 @@ 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 id = (x) => x;
-var ContextTracker = class {
+var verbose = typeof process < "u" && process.env && /\bparse\b/.test(process.env.LOG);
+var id = (x) => x, ContextTracker = class {
   /**
   Define a context tracker.
   */
   constructor(spec) {
-    this.start = spec.start;
-    this.shift = spec.shift || id;
-    this.reduce = spec.reduce || id;
-    this.reuse = spec.reuse || id;
-    this.hash = spec.hash || (() => 0);
-    this.strict = spec.strict !== false;
+    this.start = spec.start, this.shift = spec.shift || id, this.reduce = spec.reduce || id, this.reuse = spec.reuse || id, this.hash = spec.hash || (() => 0), this.strict = spec.strict !== !1;
   }
 };
 
@@ -1642,74 +1369,68 @@ var MATH_TOKENS = {
   CLOSE_PAREN: 10,
   BACKSLASH: 11,
   NEWLINE: 12
-};
-var mathContextTracker = new ContextTracker({
+}, mathContextTracker = new ContextTracker({
   start: {
-    inMath: false,
+    inMath: !1,
     mathType: null,
     depth: 0,
     startPos: -1,
-    isComplete: false,
-    hasError: false
+    isComplete: !1,
+    hasError: !1
   },
   shift(context, term, stack) {
-    const pos = stack.pos;
+    let pos = stack.pos;
     switch (term) {
       case MATH_TOKENS.INLINE_MATH:
-        if (!context.inMath) {
+        if (!context.inMath)
           return {
             ...context,
-            inMath: true,
+            inMath: !0,
             mathType: "inline",
             startPos: pos,
-            isComplete: false,
-            hasError: false
+            isComplete: !1,
+            hasError: !1
           };
-        }
-        if (context.mathType === "inline") {
+        if (context.mathType === "inline")
           return {
             ...context,
-            inMath: false,
+            inMath: !1,
             mathType: null,
-            isComplete: true
+            isComplete: !0
           };
-        }
         break;
       case MATH_TOKENS.DISPLAY_MATH:
-        if (!context.inMath) {
+        if (!context.inMath)
           return {
             ...context,
-            inMath: true,
+            inMath: !0,
             mathType: "display",
             startPos: pos,
-            isComplete: false,
-            hasError: false
+            isComplete: !1,
+            hasError: !1
           };
-        }
-        if (context.mathType === "display") {
+        if (context.mathType === "display")
           return {
             ...context,
-            inMath: false,
+            inMath: !1,
             mathType: null,
-            isComplete: true
+            isComplete: !0
           };
-        }
         break;
       case MATH_TOKENS.OPEN_BRACE:
       case MATH_TOKENS.OPEN_BRACKET:
       case MATH_TOKENS.OPEN_PAREN:
-        if (context.inMath) {
+        if (context.inMath)
           return {
             ...context,
             depth: context.depth + 1
           };
-        }
         break;
       case MATH_TOKENS.CLOSE_BRACE:
       case MATH_TOKENS.CLOSE_BRACKET:
       case MATH_TOKENS.CLOSE_PAREN:
         if (context.inMath) {
-          const newDepth = Math.max(0, context.depth - 1);
+          let newDepth = Math.max(0, context.depth - 1);
           return {
             ...context,
             depth: newDepth,
@@ -1719,12 +1440,11 @@ var mathContextTracker = new ContextTracker({
         }
         break;
       case MATH_TOKENS.NEWLINE:
-        if (context.inMath && context.mathType === "inline") {
+        if (context.inMath && context.mathType === "inline")
           return {
             ...context,
-            hasError: true
+            hasError: !0
           };
-        }
         break;
     }
     return context;
@@ -1733,12 +1453,11 @@ var mathContextTracker = new ContextTracker({
     switch (term) {
       case MATH_TOKENS.INLINE_MATH:
       case MATH_TOKENS.DISPLAY_MATH:
-        if (context.inMath && context.depth > 0) {
+        if (context.inMath && context.depth > 0)
           return {
             ...context,
-            hasError: true
+            hasError: !0
           };
-        }
         break;
     }
     return context;
@@ -1782,7 +1501,7 @@ var MathContextUtils = {
   createErrorContext(baseContext) {
     return {
       ...baseContext,
-      hasError: true
+      hasError: !0
     };
   },
   /**
@@ -1790,12 +1509,12 @@ var MathContextUtils = {
    */
   resetContext() {
     return {
-      inMath: false,
+      inMath: !1,
       mathType: null,
       depth: 0,
       startPos: -1,
-      isComplete: false,
-      hasError: false
+      isComplete: !1,
+      hasError: !1
     };
   }
 };