markdown-flow-ui 0.1.81-beta.11 → 0.1.81-beta.12

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/@lezer_lr@1.4.2/node_modules/@lezer/lr/dist/index.js

@@ -0,0 +1,1310 @@
+import { Parser as M, NodeSet as L, NodeType as $, DefaultBufferLength as E, NodeProp as y, Tree as S, IterMode as j } from "../../../../../@lezer_common@1.3.0/node_modules/@lezer/common/dist/index.js";
+class v {
+  /**
+  @internal
+  */
+  constructor(t, e, s, i, h, r, n, o, a, u = 0, f) {
+    this.p = t, this.stack = e, this.state = s, this.reducePos = i, this.pos = h, this.score = r, this.buffer = n, this.bufferBase = o, this.curContext = a, this.lookAhead = u, this.parent = f;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return `[${this.stack.filter((t, e) => e % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? "!" + this.score : ""}`;
+  }
+  // Start an empty stack
+  /**
+  @internal
+  */
+  static start(t, e, s = 0) {
+    let i = t.parser.context;
+    return new v(t, [], e, s, s, 0, [], 0, i ? new N(i, i.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(t, e) {
+    this.stack.push(this.state, e, this.bufferBase + this.buffer.length), this.state = t;
+  }
+  // Apply a reduce action
+  /**
+  @internal
+  */
+  reduce(t) {
+    var e;
+    let s = t >> 19, i = t & 65535, { parser: h } = this.p, r = this.reducePos < this.pos - 25;
+    r && this.setLookAhead(this.pos);
+    let n = h.dynamicPrecedence(i);
+    if (n && (this.score += n), s == 0) {
+      this.pushState(h.getGoto(this.state, i, !0), this.reducePos), i < h.minRepeatTerm && this.storeNode(i, this.reducePos, this.reducePos, r ? 8 : 4, !0), this.reduceContext(i, this.reducePos);
+      return;
+    }
+    let o = this.stack.length - (s - 1) * 3 - (t & 262144 ? 6 : 0), a = o ? this.stack[o - 2] : this.p.ranges[0].from, u = this.reducePos - a;
+    u >= 2e3 && !(!((e = this.p.parser.nodeSet.types[i]) === null || e === void 0) && e.isAnonymous) && (a == this.p.lastBigReductionStart ? (this.p.bigReductionCount++, this.p.lastBigReductionSize = u) : this.p.lastBigReductionSize < u && (this.p.bigReductionCount = 1, this.p.lastBigReductionStart = a, this.p.lastBigReductionSize = u));
+    let f = o ? this.stack[o - 1] : 0, p = this.bufferBase + this.buffer.length - f;
+    if (i < h.minRepeatTerm || t & 131072) {
+      let c = h.stateFlag(
+        this.state,
+        1
+        /* StateFlag.Skipped */
+      ) ? this.pos : this.reducePos;
+      this.storeNode(i, a, c, p + 4, !0);
+    }
+    if (t & 262144)
+      this.state = this.stack[o];
+    else {
+      let c = this.stack[o - 3];
+      this.state = h.getGoto(c, i, !0);
+    }
+    for (; this.stack.length > o; )
+      this.stack.pop();
+    this.reduceContext(i, a);
+  }
+  // Shift a value into the buffer
+  /**
+  @internal
+  */
+  storeNode(t, e, s, i = 4, h = !1) {
+    if (t == 0 && (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
+      let r = this, n = this.buffer.length;
+      if (n == 0 && r.parent && (n = r.bufferBase - r.parent.bufferBase, r = r.parent), n > 0 && r.buffer[n - 4] == 0 && r.buffer[n - 1] > -1) {
+        if (e == s)
+          return;
+        if (r.buffer[n - 2] >= e) {
+          r.buffer[n - 2] = s;
+          return;
+        }
+      }
+    }
+    if (!h || this.pos == s)
+      this.buffer.push(t, e, s, i);
+    else {
+      let r = this.buffer.length;
+      if (r > 0 && this.buffer[r - 4] != 0) {
+        let n = !1;
+        for (let o = r; o > 0 && this.buffer[o - 2] > s; o -= 4)
+          if (this.buffer[o - 1] >= 0) {
+            n = !0;
+            break;
+          }
+        if (n)
+          for (; r > 0 && this.buffer[r - 2] > s; )
+            this.buffer[r] = this.buffer[r - 4], this.buffer[r + 1] = this.buffer[r - 3], this.buffer[r + 2] = this.buffer[r - 2], this.buffer[r + 3] = this.buffer[r - 1], r -= 4, i > 4 && (i -= 4);
+      }
+      this.buffer[r] = t, this.buffer[r + 1] = e, this.buffer[r + 2] = s, this.buffer[r + 3] = i;
+    }
+  }
+  // Apply a shift action
+  /**
+  @internal
+  */
+  shift(t, e, s, i) {
+    if (t & 131072)
+      this.pushState(t & 65535, this.pos);
+    else if ((t & 262144) == 0) {
+      let h = t, { parser: r } = this.p;
+      (i > this.pos || e <= r.maxNode) && (this.pos = i, r.stateFlag(
+        h,
+        1
+        /* StateFlag.Skipped */
+      ) || (this.reducePos = i)), this.pushState(h, s), this.shiftContext(e, s), e <= r.maxNode && this.buffer.push(e, s, i, 4);
+    } else
+      this.pos = i, this.shiftContext(e, s), e <= this.p.parser.maxNode && this.buffer.push(e, s, i, 4);
+  }
+  // Apply an action
+  /**
+  @internal
+  */
+  apply(t, e, s, i) {
+    t & 65536 ? this.reduce(t) : this.shift(t, e, s, i);
+  }
+  // Add a prebuilt (reused) node into the buffer.
+  /**
+  @internal
+  */
+  useNode(t, e) {
+    let s = this.p.reused.length - 1;
+    (s < 0 || this.p.reused[s] != t) && (this.p.reused.push(t), s++);
+    let i = this.pos;
+    this.reducePos = this.pos = i + t.length, this.pushState(e, i), this.buffer.push(
+      s,
+      i,
+      this.reducePos,
+      -1
+      /* size == -1 means this is a reused value */
+    ), this.curContext && this.updateContext(this.curContext.tracker.reuse(this.curContext.context, t, this, this.p.stream.reset(this.pos - t.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 t = this, e = t.buffer.length;
+    for (; e > 0 && t.buffer[e - 2] > t.reducePos; )
+      e -= 4;
+    let s = t.buffer.slice(e), i = t.bufferBase + e;
+    for (; t && i == t.bufferBase; )
+      t = t.parent;
+    return new v(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, s, i, this.curContext, this.lookAhead, t);
+  }
+  // Try to recover from an error by 'deleting' (ignoring) one token.
+  /**
+  @internal
+  */
+  recoverByDelete(t, e) {
+    let s = t <= this.p.parser.maxNode;
+    s && this.storeNode(t, this.pos, e, 4), this.storeNode(0, this.pos, e, s ? 8 : 4), this.pos = this.reducePos = e, 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(t) {
+    for (let e = new G(this); ; ) {
+      let s = this.p.parser.stateSlot(
+        e.state,
+        4
+        /* ParseState.DefaultReduce */
+      ) || this.p.parser.hasAction(e.state, t);
+      if (s == 0)
+        return !1;
+      if ((s & 65536) == 0)
+        return !0;
+      e.reduce(s);
+    }
+  }
+  // Apply up to Recover.MaxNext recovery actions that conceptually
+  // inserts some missing token or rule.
+  /**
+  @internal
+  */
+  recoverByInsert(t) {
+    if (this.stack.length >= 300)
+      return [];
+    let e = this.p.parser.nextStates(this.state);
+    if (e.length > 8 || this.stack.length >= 120) {
+      let i = [];
+      for (let h = 0, r; h < e.length; h += 2)
+        (r = e[h + 1]) != this.state && this.p.parser.hasAction(r, t) && i.push(e[h], r);
+      if (this.stack.length < 120)
+        for (let h = 0; i.length < 8 && h < e.length; h += 2) {
+          let r = e[h + 1];
+          i.some((n, o) => o & 1 && n == r) || i.push(e[h], r);
+        }
+      e = i;
+    }
+    let s = [];
+    for (let i = 0; i < e.length && s.length < 4; i += 2) {
+      let h = e[i + 1];
+      if (h == this.state)
+        continue;
+      let r = this.split();
+      r.pushState(h, this.pos), r.storeNode(0, r.pos, r.pos, 4, !0), r.shiftContext(e[i], this.pos), r.reducePos = this.pos, r.score -= 200, s.push(r);
+    }
+    return s;
+  }
+  // Force a reduce, if possible. Return false if that can't
+  // be done.
+  /**
+  @internal
+  */
+  forceReduce() {
+    let { parser: t } = this.p, e = t.stateSlot(
+      this.state,
+      5
+      /* ParseState.ForcedReduce */
+    );
+    if ((e & 65536) == 0)
+      return !1;
+    if (!t.validAction(this.state, e)) {
+      let s = e >> 19, i = e & 65535, h = this.stack.length - s * 3;
+      if (h < 0 || t.getGoto(this.stack[h], i, !1) < 0) {
+        let r = this.findForcedReduction();
+        if (r == null)
+          return !1;
+        e = r;
+      }
+      this.storeNode(0, this.pos, this.pos, 4, !0), this.score -= 100;
+    }
+    return this.reducePos = this.pos, this.reduce(e), !0;
+  }
+  /**
+  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: t } = this.p, e = [], s = (i, h) => {
+      if (!e.includes(i))
+        return e.push(i), t.allActions(i, (r) => {
+          if (!(r & 393216)) if (r & 65536) {
+            let n = (r >> 19) - h;
+            if (n > 1) {
+              let o = r & 65535, a = this.stack.length - n * 3;
+              if (a >= 0 && t.getGoto(this.stack[a], o, !1) >= 0)
+                return n << 19 | 65536 | o;
+            }
+          } else {
+            let n = s(r, h + 1);
+            if (n != null)
+              return n;
+          }
+        });
+    };
+    return s(this.state, 0);
+  }
+  /**
+  @internal
+  */
+  forceAll() {
+    for (; !this.p.parser.stateFlag(
+      this.state,
+      2
+      /* StateFlag.Accepting */
+    ); )
+      if (!this.forceReduce()) {
+        this.storeNode(0, this.pos, this.pos, 4, !0);
+        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 !1;
+    let { parser: t } = this.p;
+    return t.data[t.stateSlot(
+      this.state,
+      1
+      /* ParseState.Actions */
+    )] == 65535 && !t.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.storeNode(0, this.pos, this.pos, 4, !0), this.state = this.stack[0], this.stack.length = 0;
+  }
+  /**
+  @internal
+  */
+  sameState(t) {
+    if (this.state != t.state || this.stack.length != t.stack.length)
+      return !1;
+    for (let e = 0; e < this.stack.length; e += 3)
+      if (this.stack[e] != t.stack[e])
+        return !1;
+    return !0;
+  }
+  /**
+  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(t) {
+    return this.p.parser.dialect.flags[t];
+  }
+  shiftContext(t, e) {
+    this.curContext && this.updateContext(this.curContext.tracker.shift(this.curContext.context, t, this, this.p.stream.reset(e)));
+  }
+  reduceContext(t, e) {
+    this.curContext && this.updateContext(this.curContext.tracker.reduce(this.curContext.context, t, this, this.p.stream.reset(e)));
+  }
+  /**
+  @internal
+  */
+  emitContext() {
+    let t = this.buffer.length - 1;
+    (t < 0 || this.buffer[t] != -3) && this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);
+  }
+  /**
+  @internal
+  */
+  emitLookAhead() {
+    let t = this.buffer.length - 1;
+    (t < 0 || this.buffer[t] != -4) && this.buffer.push(this.lookAhead, this.pos, this.pos, -4);
+  }
+  updateContext(t) {
+    if (t != this.curContext.context) {
+      let e = new N(this.curContext.tracker, t);
+      e.hash != this.curContext.hash && this.emitContext(), this.curContext = e;
+    }
+  }
+  /**
+  @internal
+  */
+  setLookAhead(t) {
+    t > this.lookAhead && (this.emitLookAhead(), this.lookAhead = t);
+  }
+  /**
+  @internal
+  */
+  close() {
+    this.curContext && this.curContext.tracker.strict && this.emitContext(), this.lookAhead > 0 && this.emitLookAhead();
+  }
+}
+class N {
+  constructor(t, e) {
+    this.tracker = t, this.context = e, this.hash = t.strict ? t.hash(e) : 0;
+  }
+}
+class G {
+  constructor(t) {
+    this.start = t, this.state = t.state, this.stack = t.stack, this.base = this.stack.length;
+  }
+  reduce(t) {
+    let e = t & 65535, s = t >> 19;
+    s == 0 ? (this.stack == this.start.stack && (this.stack = this.stack.slice()), this.stack.push(this.state, 0, 0), this.base += 3) : this.base -= (s - 1) * 3;
+    let i = this.start.p.parser.getGoto(this.stack[this.base - 3], e, !0);
+    this.state = i;
+  }
+}
+class A {
+  constructor(t, e, s) {
+    this.stack = t, this.pos = e, this.index = s, this.buffer = t.buffer, this.index == 0 && this.maybeNext();
+  }
+  static create(t, e = t.bufferBase + t.buffer.length) {
+    return new A(t, e, e - t.bufferBase);
+  }
+  maybeNext() {
+    let t = this.stack.parent;
+    t != null && (this.index = this.stack.bufferBase - t.bufferBase, this.stack = t, this.buffer = t.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, this.index == 0 && this.maybeNext();
+  }
+  fork() {
+    return new A(this.stack, this.pos, this.index);
+  }
+}
+function x(l, t = Uint16Array) {
+  if (typeof l != "string")
+    return l;
+  let e = null;
+  for (let s = 0, i = 0; s < l.length; ) {
+    let h = 0;
+    for (; ; ) {
+      let r = l.charCodeAt(s++), n = !1;
+      if (r == 126) {
+        h = 65535;
+        break;
+      }
+      r >= 92 && r--, r >= 34 && r--;
+      let o = r - 32;
+      if (o >= 46 && (o -= 46, n = !0), h += o, n)
+        break;
+      h *= 46;
+    }
+    e ? e[i++] = h : e = new t(h);
+  }
+  return e;
+}
+class P {
+  constructor() {
+    this.start = -1, this.value = -1, this.end = -1, this.extended = -1, this.lookAhead = 0, this.mask = 0, this.context = 0;
+  }
+}
+const R = new P();
+class U {
+  /**
+  @internal
+  */
+  constructor(t, e) {
+    this.input = t, this.ranges = e, this.chunk = "", this.chunkOff = 0, this.chunk2 = "", this.chunk2Pos = 0, this.next = -1, this.token = R, this.rangeIndex = 0, this.pos = this.chunkPos = e[0].from, this.range = e[0], this.end = e[e.length - 1].to, this.readNext();
+  }
+  /**
+  @internal
+  */
+  resolveOffset(t, e) {
+    let s = this.range, i = this.rangeIndex, h = this.pos + t;
+    for (; h < s.from; ) {
+      if (!i)
+        return null;
+      let r = this.ranges[--i];
+      h -= s.from - r.to, s = r;
+    }
+    for (; e < 0 ? h > s.to : h >= s.to; ) {
+      if (i == this.ranges.length - 1)
+        return null;
+      let r = this.ranges[++i];
+      h += r.from - s.to, s = r;
+    }
+    return h;
+  }
+  /**
+  @internal
+  */
+  clipPos(t) {
+    if (t >= this.range.from && t < this.range.to)
+      return t;
+    for (let e of this.ranges)
+      if (e.to > t)
+        return Math.max(t, e.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(t) {
+    let e = this.chunkOff + t, s, i;
+    if (e >= 0 && e < this.chunk.length)
+      s = this.pos + t, i = this.chunk.charCodeAt(e);
+    else {
+      let h = this.resolveOffset(t, 1);
+      if (h == null)
+        return -1;
+      if (s = h, s >= this.chunk2Pos && s < this.chunk2Pos + this.chunk2.length)
+        i = this.chunk2.charCodeAt(s - this.chunk2Pos);
+      else {
+        let r = this.rangeIndex, n = this.range;
+        for (; n.to <= s; )
+          n = this.ranges[++r];
+        this.chunk2 = this.input.chunk(this.chunk2Pos = s), s + this.chunk2.length > n.to && (this.chunk2 = this.chunk2.slice(0, n.to - s)), i = this.chunk2.charCodeAt(0);
+      }
+    }
+    return s >= this.token.lookAhead && (this.token.lookAhead = s + 1), i;
+  }
+  /**
+  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(t, e = 0) {
+    let s = e ? this.resolveOffset(e, -1) : this.pos;
+    if (s == null || s < this.token.start)
+      throw new RangeError("Token end out of bounds");
+    this.token.value = t, this.token.end = s;
+  }
+  /**
+  Accept a token ending at a specific given position.
+  */
+  acceptTokenTo(t, e) {
+    this.token.value = t, this.token.end = e;
+  }
+  getChunk() {
+    if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {
+      let { chunk: t, chunkPos: e } = this;
+      this.chunk = this.chunk2, this.chunkPos = this.chunk2Pos, this.chunk2 = t, this.chunk2Pos = e, this.chunkOff = this.pos - this.chunkPos;
+    } else {
+      this.chunk2 = this.chunk, this.chunk2Pos = this.chunkPos;
+      let t = this.input.chunk(this.pos), e = this.pos + t.length;
+      this.chunk = e > this.range.to ? t.slice(0, this.range.to - this.pos) : t, this.chunkPos = this.pos, this.chunkOff = 0;
+    }
+  }
+  readNext() {
+    return this.chunkOff >= this.chunk.length && (this.getChunk(), this.chunkOff == this.chunk.length) ? this.next = -1 : 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(t = 1) {
+    for (this.chunkOff += t; this.pos + t >= this.range.to; ) {
+      if (this.rangeIndex == this.ranges.length - 1)
+        return this.setDone();
+      t -= this.range.to - this.pos, this.range = this.ranges[++this.rangeIndex], this.pos = this.range.from;
+    }
+    return this.pos += t, this.pos >= this.token.lookAhead && (this.token.lookAhead = this.pos + 1), this.readNext();
+  }
+  setDone() {
+    return this.pos = this.chunkPos = this.end, this.range = this.ranges[this.rangeIndex = this.ranges.length - 1], this.chunk = "", this.next = -1;
+  }
+  /**
+  @internal
+  */
+  reset(t, e) {
+    if (e ? (this.token = e, e.start = t, e.lookAhead = t + 1, e.value = e.extended = -1) : this.token = R, this.pos != t) {
+      if (this.pos = t, t == this.end)
+        return this.setDone(), this;
+      for (; t < this.range.from; )
+        this.range = this.ranges[--this.rangeIndex];
+      for (; t >= this.range.to; )
+        this.range = this.ranges[++this.rangeIndex];
+      t >= this.chunkPos && t < this.chunkPos + this.chunk.length ? this.chunkOff = t - this.chunkPos : (this.chunk = "", this.chunkOff = 0), this.readNext();
+    }
+    return this;
+  }
+  /**
+  @internal
+  */
+  read(t, e) {
+    if (t >= this.chunkPos && e <= this.chunkPos + this.chunk.length)
+      return this.chunk.slice(t - this.chunkPos, e - this.chunkPos);
+    if (t >= this.chunk2Pos && e <= this.chunk2Pos + this.chunk2.length)
+      return this.chunk2.slice(t - this.chunk2Pos, e - this.chunk2Pos);
+    if (t >= this.range.from && e <= this.range.to)
+      return this.input.read(t, e);
+    let s = "";
+    for (let i of this.ranges) {
+      if (i.from >= e)
+        break;
+      i.to > t && (s += this.input.read(Math.max(i.from, t), Math.min(i.to, e)));
+    }
+    return s;
+  }
+}
+class m {
+  constructor(t, e) {
+    this.data = t, this.id = e;
+  }
+  token(t, e) {
+    let { parser: s } = e.p;
+    F(this.data, t, e, this.id, s.data, s.tokenPrecTable);
+  }
+}
+m.prototype.contextual = m.prototype.fallback = m.prototype.extend = !1;
+class H {
+  constructor(t, e, s) {
+    this.precTable = e, this.elseToken = s, this.data = typeof t == "string" ? x(t) : t;
+  }
+  token(t, e) {
+    let s = t.pos, i = 0;
+    for (; ; ) {
+      let h = t.next < 0, r = t.resolveOffset(1, 1);
+      if (F(this.data, t, e, 0, this.data, this.precTable), t.token.value > -1)
+        break;
+      if (this.elseToken == null)
+        return;
+      if (h || i++, r == null)
+        break;
+      t.reset(r, t.token);
+    }
+    i && (t.reset(s, t.token), t.acceptToken(this.elseToken, i));
+  }
+}
+H.prototype.contextual = m.prototype.fallback = m.prototype.extend = !1;
+class Y {
+  /**
+  Create a tokenizer. The first argument is the function that,
+  given an input stream, scans for the types of tokens it
+  recognizes at the stream's position, and calls
+  [`acceptToken`](#lr.InputStream.acceptToken) when it finds
+  one.
+  */
+  constructor(t, e = {}) {
+    this.token = t, this.contextual = !!e.contextual, this.fallback = !!e.fallback, this.extend = !!e.extend;
+  }
+}
+function F(l, t, e, s, i, h) {
+  let r = 0, n = 1 << s, { dialect: o } = e.p.parser;
+  t: for (; (n & l[r]) != 0; ) {
+    let a = l[r + 1];
+    for (let c = r + 3; c < a; c += 2)
+      if ((l[c + 1] & n) > 0) {
+        let d = l[c];
+        if (o.allows(d) && (t.token.value == -1 || t.token.value == d || W(d, t.token.value, i, h))) {
+          t.acceptToken(d);
+          break;
+        }
+      }
+    let u = t.next, f = 0, p = l[r + 2];
+    if (t.next < 0 && p > f && l[a + p * 3 - 3] == 65535) {
+      r = l[a + p * 3 - 1];
+      continue t;
+    }
+    for (; f < p; ) {
+      let c = f + p >> 1, d = a + c + (c << 1), b = l[d], O = l[d + 1] || 65536;
+      if (u < b)
+        p = c;
+      else if (u >= O)
+        f = c + 1;
+      else {
+        r = l[d + 2], t.advance();
+        continue t;
+      }
+    }
+    break;
+  }
+}
+function z(l, t, e) {
+  for (let s = t, i; (i = l[s]) != 65535; s++)
+    if (i == e)
+      return s - t;
+  return -1;
+}
+function W(l, t, e, s) {
+  let i = z(e, s, t);
+  return i < 0 || z(e, s, l) < i;
+}
+const g = typeof process < "u" && process.env && /\bparse\b/.test(process.env.LOG);
+let T = null;
+function I(l, t, e) {
+  let s = l.cursor(j.IncludeAnonymous);
+  for (s.moveTo(t); ; )
+    if (!(e < 0 ? s.childBefore(t) : s.childAfter(t)))
+      for (; ; ) {
+        if ((e < 0 ? s.to < t : s.from > t) && !s.type.isError)
+          return e < 0 ? Math.max(0, Math.min(
+            s.to - 1,
+            t - 25
+            /* Lookahead.Margin */
+          )) : Math.min(l.length, Math.max(
+            s.from + 1,
+            t + 25
+            /* Lookahead.Margin */
+          ));
+        if (e < 0 ? s.prevSibling() : s.nextSibling())
+          break;
+        if (!s.parent())
+          return e < 0 ? 0 : l.length;
+      }
+}
+class q {
+  constructor(t, e) {
+    this.fragments = t, this.nodeSet = e, this.i = 0, this.fragment = null, this.safeFrom = -1, this.safeTo = -1, this.trees = [], this.start = [], this.index = [], this.nextFragment();
+  }
+  nextFragment() {
+    let t = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];
+    if (t) {
+      for (this.safeFrom = t.openStart ? I(t.tree, t.from + t.offset, 1) - t.offset : t.from, this.safeTo = t.openEnd ? I(t.tree, t.to + t.offset, -1) - t.offset : t.to; this.trees.length; )
+        this.trees.pop(), this.start.pop(), this.index.pop();
+      this.trees.push(t.tree), this.start.push(-t.offset), this.index.push(0), this.nextStart = this.safeFrom;
+    } else
+      this.nextStart = 1e9;
+  }
+  // `pos` must be >= any previously given `pos` for this cursor
+  nodeAt(t) {
+    if (t < this.nextStart)
+      return null;
+    for (; this.fragment && this.safeTo <= t; )
+      this.nextFragment();
+    if (!this.fragment)
+      return null;
+    for (; ; ) {
+      let e = this.trees.length - 1;
+      if (e < 0)
+        return this.nextFragment(), null;
+      let s = this.trees[e], i = this.index[e];
+      if (i == s.children.length) {
+        this.trees.pop(), this.start.pop(), this.index.pop();
+        continue;
+      }
+      let h = s.children[i], r = this.start[e] + s.positions[i];
+      if (r > t)
+        return this.nextStart = r, null;
+      if (h instanceof S) {
+        if (r == t) {
+          if (r < this.safeFrom)
+            return null;
+          let n = r + h.length;
+          if (n <= this.safeTo) {
+            let o = h.prop(y.lookAhead);
+            if (!o || n + o < this.fragment.to)
+              return h;
+          }
+        }
+        this.index[e]++, r + h.length >= Math.max(this.safeFrom, t) && (this.trees.push(h), this.start.push(r), this.index.push(0));
+      } else
+        this.index[e]++, this.nextStart = r + h.length;
+    }
+  }
+}
+class J {
+  constructor(t, e) {
+    this.stream = e, this.tokens = [], this.mainToken = null, this.actions = [], this.tokens = t.tokenizers.map((s) => new P());
+  }
+  getActions(t) {
+    let e = 0, s = null, { parser: i } = t.p, { tokenizers: h } = i, r = i.stateSlot(
+      t.state,
+      3
+      /* ParseState.TokenizerMask */
+    ), n = t.curContext ? t.curContext.hash : 0, o = 0;
+    for (let a = 0; a < h.length; a++) {
+      if ((1 << a & r) == 0)
+        continue;
+      let u = h[a], f = this.tokens[a];
+      if (!(s && !u.fallback) && ((u.contextual || f.start != t.pos || f.mask != r || f.context != n) && (this.updateCachedToken(f, u, t), f.mask = r, f.context = n), f.lookAhead > f.end + 25 && (o = Math.max(f.lookAhead, o)), f.value != 0)) {
+        let p = e;
+        if (f.extended > -1 && (e = this.addActions(t, f.extended, f.end, e)), e = this.addActions(t, f.value, f.end, e), !u.extend && (s = f, e > p))
+          break;
+      }
+    }
+    for (; this.actions.length > e; )
+      this.actions.pop();
+    return o && t.setLookAhead(o), !s && t.pos == this.stream.end && (s = new P(), s.value = t.p.parser.eofTerm, s.start = s.end = t.pos, e = this.addActions(t, s.value, s.end, e)), this.mainToken = s, this.actions;
+  }
+  getMainToken(t) {
+    if (this.mainToken)
+      return this.mainToken;
+    let e = new P(), { pos: s, p: i } = t;
+    return e.start = s, e.end = Math.min(s + 1, i.stream.end), e.value = s == i.stream.end ? i.parser.eofTerm : 0, e;
+  }
+  updateCachedToken(t, e, s) {
+    let i = this.stream.clipPos(s.pos);
+    if (e.token(this.stream.reset(i, t), s), t.value > -1) {
+      let { parser: h } = s.p;
+      for (let r = 0; r < h.specialized.length; r++)
+        if (h.specialized[r] == t.value) {
+          let n = h.specializers[r](this.stream.read(t.start, t.end), s);
+          if (n >= 0 && s.p.parser.dialect.allows(n >> 1)) {
+            (n & 1) == 0 ? t.value = n >> 1 : t.extended = n >> 1;
+            break;
+          }
+        }
+    } else
+      t.value = 0, t.end = this.stream.clipPos(i + 1);
+  }
+  putAction(t, e, s, i) {
+    for (let h = 0; h < i; h += 3)
+      if (this.actions[h] == t)
+        return i;
+    return this.actions[i++] = t, this.actions[i++] = e, this.actions[i++] = s, i;
+  }
+  addActions(t, e, s, i) {
+    let { state: h } = t, { parser: r } = t.p, { data: n } = r;
+    for (let o = 0; o < 2; o++)
+      for (let a = r.stateSlot(
+        h,
+        o ? 2 : 1
+        /* ParseState.Actions */
+      ); ; a += 3) {
+        if (n[a] == 65535)
+          if (n[a + 1] == 1)
+            a = k(n, a + 2);
+          else {
+            i == 0 && n[a + 1] == 2 && (i = this.putAction(k(n, a + 2), e, s, i));
+            break;
+          }
+        n[a] == e && (i = this.putAction(k(n, a + 1), e, s, i));
+      }
+    return i;
+  }
+}
+class K {
+  constructor(t, e, s, i) {
+    this.parser = t, this.input = e, this.ranges = i, 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 U(e, i), this.tokens = new J(t, this.stream), this.topTerm = t.top[1];
+    let { from: h } = i[0];
+    this.stacks = [v.start(this, t.top[0], h)], this.fragments = s.length && this.stream.end - h > t.bufferLength * 4 ? new q(s, t.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 t = this.stacks, e = this.minStackPos, s = this.stacks = [], i, h;
+    if (this.bigReductionCount > 300 && t.length == 1) {
+      let [r] = t;
+      for (; r.forceReduce() && r.stack.length && r.stack[r.stack.length - 2] >= this.lastBigReductionStart; )
+        ;
+      this.bigReductionCount = this.lastBigReductionSize = 0;
+    }
+    for (let r = 0; r < t.length; r++) {
+      let n = t[r];
+      for (; ; ) {
+        if (this.tokens.mainToken = null, n.pos > e)
+          s.push(n);
+        else {
+          if (this.advanceStack(n, s, t))
+            continue;
+          {
+            i || (i = [], h = []), i.push(n);
+            let o = this.tokens.getMainToken(n);
+            h.push(o.value, o.end);
+          }
+        }
+        break;
+      }
+    }
+    if (!s.length) {
+      let r = i && V(i);
+      if (r)
+        return g && console.log("Finish with " + this.stackID(r)), this.stackToTree(r);
+      if (this.parser.strict)
+        throw g && i && console.log("Stuck with token " + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : "none")), new SyntaxError("No parse at " + e);
+      this.recovering || (this.recovering = 5);
+    }
+    if (this.recovering && i) {
+      let r = this.stoppedAt != null && i[0].pos > this.stoppedAt ? i[0] : this.runRecovery(i, h, s);
+      if (r)
+        return g && console.log("Force-finish " + this.stackID(r)), this.stackToTree(r.forceAll());
+    }
+    if (this.recovering) {
+      let r = this.recovering == 1 ? 1 : this.recovering * 3;
+      if (s.length > r)
+        for (s.sort((n, o) => o.score - n.score); s.length > r; )
+          s.pop();
+      s.some((n) => n.reducePos > e) && this.recovering--;
+    } else if (s.length > 1) {
+      t: for (let r = 0; r < s.length - 1; r++) {
+        let n = s[r];
+        for (let o = r + 1; o < s.length; o++) {
+          let a = s[o];
+          if (n.sameState(a) || n.buffer.length > 500 && a.buffer.length > 500)
+            if ((n.score - a.score || n.buffer.length - a.buffer.length) > 0)
+              s.splice(o--, 1);
+            else {
+              s.splice(r--, 1);
+              continue t;
+            }
+        }
+      }
+      s.length > 12 && s.splice(
+        12,
+        s.length - 12
+        /* Rec.MaxStackCount */
+      );
+    }
+    this.minStackPos = s[0].pos;
+    for (let r = 1; r < s.length; r++)
+      s[r].pos < this.minStackPos && (this.minStackPos = s[r].pos);
+    return null;
+  }
+  stopAt(t) {
+    if (this.stoppedAt != null && this.stoppedAt < t)
+      throw new RangeError("Can't move stoppedAt forward");
+    this.stoppedAt = t;
+  }
+  // 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(t, e, s) {
+    let i = t.pos, { parser: h } = this, r = g ? this.stackID(t) + " -> " : "";
+    if (this.stoppedAt != null && i > this.stoppedAt)
+      return t.forceReduce() ? t : null;
+    if (this.fragments) {
+      let a = t.curContext && t.curContext.tracker.strict, u = a ? t.curContext.hash : 0;
+      for (let f = this.fragments.nodeAt(i); f; ) {
+        let p = this.parser.nodeSet.types[f.type.id] == f.type ? h.getGoto(t.state, f.type.id) : -1;
+        if (p > -1 && f.length && (!a || (f.prop(y.contextHash) || 0) == u))
+          return t.useNode(f, p), g && console.log(r + this.stackID(t) + ` (via reuse of ${h.getName(f.type.id)})`), !0;
+        if (!(f instanceof S) || f.children.length == 0 || f.positions[0] > 0)
+          break;
+        let c = f.children[0];
+        if (c instanceof S && f.positions[0] == 0)
+          f = c;
+        else
+          break;
+      }
+    }
+    let n = h.stateSlot(
+      t.state,
+      4
+      /* ParseState.DefaultReduce */
+    );
+    if (n > 0)
+      return t.reduce(n), g && console.log(r + this.stackID(t) + ` (via always-reduce ${h.getName(
+        n & 65535
+        /* Action.ValueMask */
+      )})`), !0;
+    if (t.stack.length >= 8400)
+      for (; t.stack.length > 6e3 && t.forceReduce(); )
+        ;
+    let o = this.tokens.getActions(t);
+    for (let a = 0; a < o.length; ) {
+      let u = o[a++], f = o[a++], p = o[a++], c = a == o.length || !s, d = c ? t : t.split(), b = this.tokens.mainToken;
+      if (d.apply(u, f, b ? b.start : d.pos, p), g && console.log(r + this.stackID(d) + ` (via ${(u & 65536) == 0 ? "shift" : `reduce of ${h.getName(
+        u & 65535
+        /* Action.ValueMask */
+      )}`} for ${h.getName(f)} @ ${i}${d == t ? "" : ", split"})`), c)
+        return !0;
+      d.pos > i ? e.push(d) : s.push(d);
+    }
+    return !1;
+  }
+  // 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(t, e) {
+    let s = t.pos;
+    for (; ; ) {
+      if (!this.advanceStack(t, null, null))
+        return !1;
+      if (t.pos > s)
+        return D(t, e), !0;
+    }
+  }
+  runRecovery(t, e, s) {
+    let i = null, h = !1;
+    for (let r = 0; r < t.length; r++) {
+      let n = t[r], o = e[r << 1], a = e[(r << 1) + 1], u = g ? this.stackID(n) + " -> " : "";
+      if (n.deadEnd && (h || (h = !0, n.restart(), g && console.log(u + this.stackID(n) + " (restarted)"), this.advanceFully(n, s))))
+        continue;
+      let f = n.split(), p = u;
+      for (let c = 0; f.forceReduce() && c < 10 && (g && console.log(p + this.stackID(f) + " (via force-reduce)"), !this.advanceFully(f, s)); c++)
+        g && (p = this.stackID(f) + " -> ");
+      for (let c of n.recoverByInsert(o))
+        g && console.log(u + this.stackID(c) + " (via recover-insert)"), this.advanceFully(c, s);
+      this.stream.end > n.pos ? (a == n.pos && (a++, o = 0), n.recoverByDelete(o, a), g && console.log(u + this.stackID(n) + ` (via recover-delete ${this.parser.getName(o)})`), D(n, s)) : (!i || i.score < n.score) && (i = n);
+    }
+    return i;
+  }
+  // Convert the stack's buffer to a syntax tree.
+  stackToTree(t) {
+    return t.close(), S.build({
+      buffer: A.create(t),
+      nodeSet: this.parser.nodeSet,
+      topID: this.topTerm,
+      maxBufferLength: this.parser.bufferLength,
+      reused: this.reused,
+      start: this.ranges[0].from,
+      length: t.pos - this.ranges[0].from,
+      minRepeatType: this.parser.minRepeatTerm
+    });
+  }
+  stackID(t) {
+    let e = (T || (T = /* @__PURE__ */ new WeakMap())).get(t);
+    return e || T.set(t, e = String.fromCodePoint(this.nextStackID++)), e + t;
+  }
+}
+function D(l, t) {
+  for (let e = 0; e < t.length; e++) {
+    let s = t[e];
+    if (s.pos == l.pos && s.sameState(l)) {
+      t[e].score < l.score && (t[e] = l);
+      return;
+    }
+  }
+  t.push(l);
+}
+class Q {
+  constructor(t, e, s) {
+    this.source = t, this.flags = e, this.disabled = s;
+  }
+  allows(t) {
+    return !this.disabled || this.disabled[t] == 0;
+  }
+}
+const C = (l) => l;
+class Z {
+  /**
+  Define a context tracker.
+  */
+  constructor(t) {
+    this.start = t.start, this.shift = t.shift || C, this.reduce = t.reduce || C, this.reuse = t.reuse || C, this.hash = t.hash || (() => 0), this.strict = t.strict !== !1;
+  }
+}
+class w extends M {
+  /**
+  @internal
+  */
+  constructor(t) {
+    if (super(), this.wrappers = [], t.version != 14)
+      throw new RangeError(`Parser version (${t.version}) doesn't match runtime version (14)`);
+    let e = t.nodeNames.split(" ");
+    this.minRepeatTerm = e.length;
+    for (let n = 0; n < t.repeatNodeCount; n++)
+      e.push("");
+    let s = Object.keys(t.topRules).map((n) => t.topRules[n][1]), i = [];
+    for (let n = 0; n < e.length; n++)
+      i.push([]);
+    function h(n, o, a) {
+      i[n].push([o, o.deserialize(String(a))]);
+    }
+    if (t.nodeProps)
+      for (let n of t.nodeProps) {
+        let o = n[0];
+        typeof o == "string" && (o = y[o]);
+        for (let a = 1; a < n.length; ) {
+          let u = n[a++];
+          if (u >= 0)
+            h(u, o, n[a++]);
+          else {
+            let f = n[a + -u];
+            for (let p = -u; p > 0; p--)
+              h(n[a++], o, f);
+            a++;
+          }
+        }
+      }
+    this.nodeSet = new L(e.map((n, o) => $.define({
+      name: o >= this.minRepeatTerm ? void 0 : n,
+      id: o,
+      props: i[o],
+      top: s.indexOf(o) > -1,
+      error: o == 0,
+      skipped: t.skippedNodes && t.skippedNodes.indexOf(o) > -1
+    }))), t.propSources && (this.nodeSet = this.nodeSet.extend(...t.propSources)), this.strict = !1, this.bufferLength = E;
+    let r = x(t.tokenData);
+    this.context = t.context, this.specializerSpecs = t.specialized || [], this.specialized = new Uint16Array(this.specializerSpecs.length);
+    for (let n = 0; n < this.specializerSpecs.length; n++)
+      this.specialized[n] = this.specializerSpecs[n].term;
+    this.specializers = this.specializerSpecs.map(B), this.states = x(t.states, Uint32Array), this.data = x(t.stateData), this.goto = x(t.goto), this.maxTerm = t.maxTerm, this.tokenizers = t.tokenizers.map((n) => typeof n == "number" ? new m(r, n) : n), this.topRules = t.topRules, this.dialects = t.dialects || {}, this.dynamicPrecedences = t.dynamicPrecedences || null, this.tokenPrecTable = t.tokenPrec, this.termNames = t.termNames || null, this.maxNode = this.nodeSet.types.length - 1, this.dialect = this.parseDialect(), this.top = this.topRules[Object.keys(this.topRules)[0]];
+  }
+  createParse(t, e, s) {
+    let i = new K(this, t, e, s);
+    for (let h of this.wrappers)
+      i = h(i, t, e, s);
+    return i;
+  }
+  /**
+  Get a goto table entry @internal
+  */
+  getGoto(t, e, s = !1) {
+    let i = this.goto;
+    if (e >= i[0])
+      return -1;
+    for (let h = i[e + 1]; ; ) {
+      let r = i[h++], n = r & 1, o = i[h++];
+      if (n && s)
+        return o;
+      for (let a = h + (r >> 1); h < a; h++)
+        if (i[h] == t)
+          return o;
+      if (n)
+        return -1;
+    }
+  }
+  /**
+  Check if this state has an action for a given terminal @internal
+  */
+  hasAction(t, e) {
+    let s = this.data;
+    for (let i = 0; i < 2; i++)
+      for (let h = this.stateSlot(
+        t,
+        i ? 2 : 1
+        /* ParseState.Actions */
+      ), r; ; h += 3) {
+        if ((r = s[h]) == 65535)
+          if (s[h + 1] == 1)
+            r = s[h = k(s, h + 2)];
+          else {
+            if (s[h + 1] == 2)
+              return k(s, h + 2);
+            break;
+          }
+        if (r == e || r == 0)
+          return k(s, h + 1);
+      }
+    return 0;
+  }
+  /**
+  @internal
+  */
+  stateSlot(t, e) {
+    return this.states[t * 6 + e];
+  }
+  /**
+  @internal
+  */
+  stateFlag(t, e) {
+    return (this.stateSlot(
+      t,
+      0
+      /* ParseState.Flags */
+    ) & e) > 0;
+  }
+  /**
+  @internal
+  */
+  validAction(t, e) {
+    return !!this.allActions(t, (s) => s == e ? !0 : null);
+  }
+  /**
+  @internal
+  */
+  allActions(t, e) {
+    let s = this.stateSlot(
+      t,
+      4
+      /* ParseState.DefaultReduce */
+    ), i = s ? e(s) : void 0;
+    for (let h = this.stateSlot(
+      t,
+      1
+      /* ParseState.Actions */
+    ); i == null; h += 3) {
+      if (this.data[h] == 65535)
+        if (this.data[h + 1] == 1)
+          h = k(this.data, h + 2);
+        else
+          break;
+      i = e(k(this.data, h + 1));
+    }
+    return i;
+  }
+  /**
+  Get the states that can follow this one through shift actions or
+  goto jumps. @internal
+  */
+  nextStates(t) {
+    let e = [];
+    for (let s = this.stateSlot(
+      t,
+      1
+      /* ParseState.Actions */
+    ); ; s += 3) {
+      if (this.data[s] == 65535)
+        if (this.data[s + 1] == 1)
+          s = k(this.data, s + 2);
+        else
+          break;
+      if ((this.data[s + 2] & 1) == 0) {
+        let i = this.data[s + 1];
+        e.some((h, r) => r & 1 && h == i) || e.push(this.data[s], i);
+      }
+    }
+    return e;
+  }
+  /**
+  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(t) {
+    let e = Object.assign(Object.create(w.prototype), this);
+    if (t.props && (e.nodeSet = this.nodeSet.extend(...t.props)), t.top) {
+      let s = this.topRules[t.top];
+      if (!s)
+        throw new RangeError(`Invalid top rule name ${t.top}`);
+      e.top = s;
+    }
+    return t.tokenizers && (e.tokenizers = this.tokenizers.map((s) => {
+      let i = t.tokenizers.find((h) => h.from == s);
+      return i ? i.to : s;
+    })), t.specializers && (e.specializers = this.specializers.slice(), e.specializerSpecs = this.specializerSpecs.map((s, i) => {
+      let h = t.specializers.find((n) => n.from == s.external);
+      if (!h)
+        return s;
+      let r = Object.assign(Object.assign({}, s), { external: h.to });
+      return e.specializers[i] = B(r), r;
+    })), t.contextTracker && (e.context = t.contextTracker), t.dialect && (e.dialect = this.parseDialect(t.dialect)), t.strict != null && (e.strict = t.strict), t.wrap && (e.wrappers = e.wrappers.concat(t.wrap)), t.bufferLength != null && (e.bufferLength = t.bufferLength), e;
+  }
+  /**
+  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(t) {
+    return this.termNames ? this.termNames[t] : String(t <= this.maxNode && this.nodeSet.types[t].name || t);
+  }
+  /**
+  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(t) {
+    let e = this.dynamicPrecedences;
+    return e == null ? 0 : e[t] || 0;
+  }
+  /**
+  @internal
+  */
+  parseDialect(t) {
+    let e = Object.keys(this.dialects), s = e.map(() => !1);
+    if (t)
+      for (let h of t.split(" ")) {
+        let r = e.indexOf(h);
+        r >= 0 && (s[r] = !0);
+      }
+    let i = null;
+    for (let h = 0; h < e.length; h++)
+      if (!s[h])
+        for (let r = this.dialects[e[h]], n; (n = this.data[r++]) != 65535; )
+          (i || (i = new Uint8Array(this.maxTerm + 1)))[n] = 1;
+    return new Q(t, s, i);
+  }
+  /**
+  Used by the output of the parser generator. Not available to
+  user code. @hide
+  */
+  static deserialize(t) {
+    return new w(t);
+  }
+}
+function k(l, t) {
+  return l[t] | l[t + 1] << 16;
+}
+function V(l) {
+  let t = null;
+  for (let e of l) {
+    let s = e.p.stoppedAt;
+    (e.pos == e.p.stream.end || s != null && e.pos > s) && e.p.parser.stateFlag(
+      e.state,
+      2
+      /* StateFlag.Accepting */
+    ) && (!t || t.score < e.score) && (t = e);
+  }
+  return t;
+}
+function B(l) {
+  if (l.external) {
+    let t = l.extend ? 1 : 0;
+    return (e, s) => l.external(e, s) << 1 | t;
+  }
+  return l.get;
+}
+export {
+  Z as ContextTracker,
+  Y as ExternalTokenizer,
+  U as InputStream,
+  w as LRParser,
+  H as LocalTokenGroup,
+  v as Stack
+};
+//# sourceMappingURL=index.js.map