@adyen/bento-vue2 1.28.0 → 1.29.0

package/dist/code-snippet.js

@@ -1,8 +1,2037 @@
-import { c as n, b as o, a as p, B as a } from "./chunks/code-snippet.C4IbjAhH.js";
+import { defineComponent as He, ref as ae, computed as re, shallowRef as Se, onMounted as Re, watch as De, watchEffect as Je } from "vue";
+import { highlightActiveLine as Ue, keymap as Ve, EditorView as Ie, lineNumbers as We } from "@codemirror/view";
+import { EditorSelection as Ge, Compartment as be, EditorState as Be } from "@codemirror/state";
+import { indentWithTab as $e, history as Ke } from "@codemirror/commands";
+import { syntaxHighlighting as Fe, HighlightStyle as qe } from "@codemirror/language";
+import { B as Xe, a as Ye, b as Qe, c as Ze } from "./chunks/es6.cf6b43e9.js";
+import { B as et } from "./chunks/dropdown.9bee6e1d.js";
+import { a as tt } from "./chunks/button.9184ade9.js";
+import { B as nt } from "./chunks/index.e29a6907.js";
+import { BentoLoadingIndicator as rt } from "./loading-indicator.js";
+import { u as it } from "./chunks/i18n.eb5b985b.js";
+import { E as st } from "./chunks/expand.d0ccfcfe.js";
+import { h as lt } from "./chunks/base-modal.00322d31.js";
+import { C as ot } from "./chunks/copy.d5dd2b60.js";
+import { json as at } from "@codemirror/lang-json";
+import { xml as ut } from "@codemirror/lang-xml";
+import { javascript as ft } from "@codemirror/lang-javascript";
+import { java as ht } from "@codemirror/lang-java";
+import { python as ct } from "@codemirror/lang-python";
+import { b as dt } from "./chunks/tooltip.77610390.js";
+import { n as pt } from "./chunks/_plugin-vue2_normalizer.71e2aa87.js";
+import "./assets/index7.css";
+const gt = 1024;
+let mt = 0;
+class _ {
+  /**
+  Create a new node prop type.
+  */
+  constructor(e = {}) {
+    this.id = mt++, this.perNode = !!e.perNode, this.deserialize = e.deserialize || (() => {
+      throw new Error("This node type doesn't define a deserialize function");
+    });
+  }
+  /**
+  This is meant to be used with
+  [`NodeSet.extend`](#common.NodeSet.extend) or
+  [`LRParser.configure`](#lr.ParserConfig.props) to compute
+  prop values for each node type in the set. Takes a [match
+  object](#common.NodeType^match) or function that returns undefined
+  if the node type doesn't get this prop, and the prop's value if
+  it does.
+  */
+  add(e) {
+    if (this.perNode)
+      throw new RangeError("Can't add per-node props to node types");
+    return typeof e != "function" && (e = G.match(e)), (t) => {
+      let n = e(t);
+      return n === void 0 ? null : [this, n];
+    };
+  }
+}
+_.closedBy = new _({ deserialize: (i) => i.split(" ") });
+_.openedBy = new _({ deserialize: (i) => i.split(" ") });
+_.group = new _({ deserialize: (i) => i.split(" ") });
+_.isolate = new _({ deserialize: (i) => {
+  if (i && i != "rtl" && i != "ltr" && i != "auto")
+    throw new RangeError("Invalid value for isolate: " + i);
+  return i || "auto";
+} });
+_.contextHash = new _({ perNode: !0 });
+_.lookAhead = new _({ perNode: !0 });
+_.mounted = new _({ perNode: !0 });
+class ge {
+  constructor(e, t, n) {
+    this.tree = e, this.overlay = t, this.parser = n;
+  }
+  /**
+  @internal
+  */
+  static get(e) {
+    return e && e.props && e.props[_.mounted.id];
+  }
+}
+const bt = /* @__PURE__ */ Object.create(null);
+class G {
+  /**
+  @internal
+  */
+  constructor(e, t, n, r = 0) {
+    this.name = e, this.props = t, this.id = n, this.flags = r;
+  }
+  /**
+  Define a node type.
+  */
+  static define(e) {
+    let t = e.props && e.props.length ? /* @__PURE__ */ Object.create(null) : bt, n = (e.top ? 1 : 0) | (e.skipped ? 2 : 0) | (e.error ? 4 : 0) | (e.name == null ? 8 : 0), r = new G(e.name || "", t, e.id, n);
+    if (e.props) {
+      for (let s of e.props)
+        if (Array.isArray(s) || (s = s(r)), s) {
+          if (s[0].perNode)
+            throw new RangeError("Can't store a per-node prop on a node type");
+          t[s[0].id] = s[1];
+        }
+    }
+    return r;
+  }
+  /**
+  Retrieves a node prop for this type. Will return `undefined` if
+  the prop isn't present on this node.
+  */
+  prop(e) {
+    return this.props[e.id];
+  }
+  /**
+  True when this is the top node of a grammar.
+  */
+  get isTop() {
+    return (this.flags & 1) > 0;
+  }
+  /**
+  True when this node is produced by a skip rule.
+  */
+  get isSkipped() {
+    return (this.flags & 2) > 0;
+  }
+  /**
+  Indicates whether this is an error node.
+  */
+  get isError() {
+    return (this.flags & 4) > 0;
+  }
+  /**
+  When true, this node type doesn't correspond to a user-declared
+  named node, for example because it is used to cache repetition.
+  */
+  get isAnonymous() {
+    return (this.flags & 8) > 0;
+  }
+  /**
+  Returns true when this node's name or one of its
+  [groups](#common.NodeProp^group) matches the given string.
+  */
+  is(e) {
+    if (typeof e == "string") {
+      if (this.name == e)
+        return !0;
+      let t = this.prop(_.group);
+      return t ? t.indexOf(e) > -1 : !1;
+    }
+    return this.id == e;
+  }
+  /**
+  Create a function from node types to arbitrary values by
+  specifying an object whose property names are node or
+  [group](#common.NodeProp^group) names. Often useful with
+  [`NodeProp.add`](#common.NodeProp.add). You can put multiple
+  names, separated by spaces, in a single property name to map
+  multiple node names to a single value.
+  */
+  static match(e) {
+    let t = /* @__PURE__ */ Object.create(null);
+    for (let n in e)
+      for (let r of n.split(" "))
+        t[r] = e[n];
+    return (n) => {
+      for (let r = n.prop(_.group), s = -1; s < (r ? r.length : 0); s++) {
+        let l = t[s < 0 ? n.name : r[s]];
+        if (l)
+          return l;
+      }
+    };
+  }
+}
+G.none = new G(
+  "",
+  /* @__PURE__ */ Object.create(null),
+  0,
+  8
+  /* NodeFlag.Anonymous */
+);
+const ue = /* @__PURE__ */ new WeakMap(), Le = /* @__PURE__ */ new WeakMap();
+var A;
+(function(i) {
+  i[i.ExcludeBuffers = 1] = "ExcludeBuffers", i[i.IncludeAnonymous = 2] = "IncludeAnonymous", i[i.IgnoreMounts = 4] = "IgnoreMounts", i[i.IgnoreOverlays = 8] = "IgnoreOverlays";
+})(A || (A = {}));
+class D {
+  /**
+  Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+  */
+  constructor(e, t, n, r, s) {
+    if (this.type = e, this.children = t, this.positions = n, this.length = r, this.props = null, s && s.length) {
+      this.props = /* @__PURE__ */ Object.create(null);
+      for (let [l, u] of s)
+        this.props[typeof l == "number" ? l : l.id] = u;
+    }
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let e = ge.get(this);
+    if (e && !e.overlay)
+      return e.tree.toString();
+    let t = "";
+    for (let n of this.children) {
+      let r = n.toString();
+      r && (t && (t += ","), t += r);
+    }
+    return this.type.name ? (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (t.length ? "(" + t + ")" : "") : t;
+  }
+  /**
+  Get a [tree cursor](#common.TreeCursor) positioned at the top of
+  the tree. Mode can be used to [control](#common.IterMode) which
+  nodes the cursor visits.
+  */
+  cursor(e = 0) {
+    return new ke(this.topNode, e);
+  }
+  /**
+  Get a [tree cursor](#common.TreeCursor) pointing into this tree
+  at the given position and side (see
+  [`moveTo`](#common.TreeCursor.moveTo).
+  */
+  cursorAt(e, t = 0, n = 0) {
+    let r = ue.get(this) || this.topNode, s = new ke(r);
+    return s.moveTo(e, t), ue.set(this, s._tree), s;
+  }
+  /**
+  Get a [syntax node](#common.SyntaxNode) object for the top of the
+  tree.
+  */
+  get topNode() {
+    return new E(this, 0, 0, null);
+  }
+  /**
+  Get the [syntax node](#common.SyntaxNode) at the given position.
+  If `side` is -1, this will move into nodes that end at the
+  position. If 1, it'll move into nodes that start at the
+  position. With 0, it'll only enter nodes that cover the position
+  from both sides.
+  
+  Note that this will not enter
+  [overlays](#common.MountedTree.overlay), and you often want
+  [`resolveInner`](#common.Tree.resolveInner) instead.
+  */
+  resolve(e, t = 0) {
+    let n = le(ue.get(this) || this.topNode, e, t, !1);
+    return ue.set(this, n), n;
+  }
+  /**
+  Like [`resolve`](#common.Tree.resolve), but will enter
+  [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
+  pointing into the innermost overlaid tree at the given position
+  (with parent links going through all parent structure, including
+  the host trees).
+  */
+  resolveInner(e, t = 0) {
+    let n = le(Le.get(this) || this.topNode, e, t, !0);
+    return Le.set(this, n), n;
+  }
+  /**
+  In some situations, it can be useful to iterate through all
+  nodes around a position, including those in overlays that don't
+  directly cover the position. This method gives you an iterator
+  that will produce all nodes, from small to big, around the given
+  position.
+  */
+  resolveStack(e, t = 0) {
+    return kt(this, e, t);
+  }
+  /**
+  Iterate over the tree and its children, calling `enter` for any
+  node that touches the `from`/`to` region (if given) before
+  running over such a node's children, and `leave` (if given) when
+  leaving the node. When `enter` returns `false`, that node will
+  not have its children iterated over (or `leave` called).
+  */
+  iterate(e) {
+    let { enter: t, leave: n, from: r = 0, to: s = this.length } = e, l = e.mode || 0, u = (l & A.IncludeAnonymous) > 0;
+    for (let h = this.cursor(l | A.IncludeAnonymous); ; ) {
+      let v = !1;
+      if (h.from <= s && h.to >= r && (!u && h.type.isAnonymous || t(h) !== !1)) {
+        if (h.firstChild())
+          continue;
+        v = !0;
+      }
+      for (; v && n && (u || !h.type.isAnonymous) && n(h), !h.nextSibling(); ) {
+        if (!h.parent())
+          return;
+        v = !0;
+      }
+    }
+  }
+  /**
+  Get the value of the given [node prop](#common.NodeProp) for this
+  node. Works with both per-node and per-type props.
+  */
+  prop(e) {
+    return e.perNode ? this.props ? this.props[e.id] : void 0 : this.type.prop(e);
+  }
+  /**
+  Returns the node's [per-node props](#common.NodeProp.perNode) in a
+  format that can be passed to the [`Tree`](#common.Tree)
+  constructor.
+  */
+  get propValues() {
+    let e = [];
+    if (this.props)
+      for (let t in this.props)
+        e.push([+t, this.props[t]]);
+    return e;
+  }
+  /**
+  Balance the direct children of this tree, producing a copy of
+  which may have children grouped into subtrees with type
+  [`NodeType.none`](#common.NodeType^none).
+  */
+  balance(e = {}) {
+    return this.children.length <= 8 ? this : we(G.none, this.children, this.positions, 0, this.children.length, 0, this.length, (t, n, r) => new D(this.type, t, n, r, this.propValues), e.makeTree || ((t, n, r) => new D(G.none, t, n, r)));
+  }
+  /**
+  Build a tree from a postfix-ordered buffer of node information,
+  or a cursor over such a buffer.
+  */
+  static build(e) {
+    return _t(e);
+  }
+}
+D.empty = new D(G.none, [], [], 0);
+class ve {
+  constructor(e, t) {
+    this.buffer = e, this.index = t;
+  }
+  get id() {
+    return this.buffer[this.index - 4];
+  }
+  get start() {
+    return this.buffer[this.index - 3];
+  }
+  get end() {
+    return this.buffer[this.index - 2];
+  }
+  get size() {
+    return this.buffer[this.index - 1];
+  }
+  get pos() {
+    return this.index;
+  }
+  next() {
+    this.index -= 4;
+  }
+  fork() {
+    return new ve(this.buffer, this.index);
+  }
+}
+class X {
+  /**
+  Create a tree buffer.
+  */
+  constructor(e, t, n) {
+    this.buffer = e, this.length = t, this.set = n;
+  }
+  /**
+  @internal
+  */
+  get type() {
+    return G.none;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let e = [];
+    for (let t = 0; t < this.buffer.length; )
+      e.push(this.childString(t)), t = this.buffer[t + 3];
+    return e.join(",");
+  }
+  /**
+  @internal
+  */
+  childString(e) {
+    let t = this.buffer[e], n = this.buffer[e + 3], r = this.set.types[t], s = r.name;
+    if (/\W/.test(s) && !r.isError && (s = JSON.stringify(s)), e += 4, n == e)
+      return s;
+    let l = [];
+    for (; e < n; )
+      l.push(this.childString(e)), e = this.buffer[e + 3];
+    return s + "(" + l.join(",") + ")";
+  }
+  /**
+  @internal
+  */
+  findChild(e, t, n, r, s) {
+    let { buffer: l } = this, u = -1;
+    for (let h = e; h != t && !(Te(s, r, l[h + 1], l[h + 2]) && (u = h, n > 0)); h = l[h + 3])
+      ;
+    return u;
+  }
+  /**
+  @internal
+  */
+  slice(e, t, n) {
+    let r = this.buffer, s = new Uint16Array(t - e), l = 0;
+    for (let u = e, h = 0; u < t; ) {
+      s[h++] = r[u++], s[h++] = r[u++] - n;
+      let v = s[h++] = r[u++] - n;
+      s[h++] = r[u++] - e, l = Math.max(l, v);
+    }
+    return new X(s, l, this.set);
+  }
+}
+function Te(i, e, t, n) {
+  switch (i) {
+    case -2:
+      return t < e;
+    case -1:
+      return n >= e && t < e;
+    case 0:
+      return t < e && n > e;
+    case 1:
+      return t <= e && n > e;
+    case 2:
+      return n > e;
+    case 4:
+      return !0;
+  }
+}
+function le(i, e, t, n) {
+  for (var r; i.from == i.to || (t < 1 ? i.from >= e : i.from > e) || (t > -1 ? i.to <= e : i.to < e); ) {
+    let l = !n && i instanceof E && i.index < 0 ? null : i.parent;
+    if (!l)
+      return i;
+    i = l;
+  }
+  let s = n ? 0 : A.IgnoreOverlays;
+  if (n)
+    for (let l = i, u = l.parent; u; l = u, u = l.parent)
+      l instanceof E && l.index < 0 && ((r = u.enter(e, t, s)) === null || r === void 0 ? void 0 : r.from) != l.from && (i = u);
+  for (; ; ) {
+    let l = i.enter(e, t, s);
+    if (!l)
+      return i;
+    i = l;
+  }
+}
+class Pe {
+  cursor(e = 0) {
+    return new ke(this, e);
+  }
+  getChild(e, t = null, n = null) {
+    let r = Ee(this, e, t, n);
+    return r.length ? r[0] : null;
+  }
+  getChildren(e, t = null, n = null) {
+    return Ee(this, e, t, n);
+  }
+  resolve(e, t = 0) {
+    return le(this, e, t, !1);
+  }
+  resolveInner(e, t = 0) {
+    return le(this, e, t, !0);
+  }
+  matchContext(e) {
+    return xe(this, e);
+  }
+  enterUnfinishedNodesBefore(e) {
+    let t = this.childBefore(e), n = this;
+    for (; t; ) {
+      let r = t.lastChild;
+      if (!r || r.to != t.to)
+        break;
+      r.type.isError && r.from == r.to ? (n = t, t = r.prevSibling) : t = r;
+    }
+    return n;
+  }
+  get node() {
+    return this;
+  }
+  get next() {
+    return this.parent;
+  }
+}
+class E extends Pe {
+  constructor(e, t, n, r) {
+    super(), this._tree = e, this.from = t, this.index = n, this._parent = r;
+  }
+  get type() {
+    return this._tree.type;
+  }
+  get name() {
+    return this._tree.type.name;
+  }
+  get to() {
+    return this.from + this._tree.length;
+  }
+  nextChild(e, t, n, r, s = 0) {
+    for (let l = this; ; ) {
+      for (let { children: u, positions: h } = l._tree, v = t > 0 ? u.length : -1; e != v; e += t) {
+        let C = u[e], N = h[e] + l.from;
+        if (Te(r, n, N, N + C.length)) {
+          if (C instanceof X) {
+            if (s & A.ExcludeBuffers)
+              continue;
+            let S = C.findChild(0, C.buffer.length, t, n - N, r);
+            if (S > -1)
+              return new q(new yt(l, C, e, N), null, S);
+          } else if (s & A.IncludeAnonymous || !C.type.isAnonymous || Ce(C)) {
+            let S;
+            if (!(s & A.IgnoreMounts) && (S = ge.get(C)) && !S.overlay)
+              return new E(S.tree, N, e, l);
+            let z = new E(C, N, e, l);
+            return s & A.IncludeAnonymous || !z.type.isAnonymous ? z : z.nextChild(t < 0 ? C.children.length - 1 : 0, t, n, r);
+          }
+        }
+      }
+      if (s & A.IncludeAnonymous || !l.type.isAnonymous || (l.index >= 0 ? e = l.index + t : e = t < 0 ? -1 : l._parent._tree.children.length, l = l._parent, !l))
+        return null;
+    }
+  }
+  get firstChild() {
+    return this.nextChild(
+      0,
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get lastChild() {
+    return this.nextChild(
+      this._tree.children.length - 1,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  childAfter(e) {
+    return this.nextChild(
+      0,
+      1,
+      e,
+      2
+      /* Side.After */
+    );
+  }
+  childBefore(e) {
+    return this.nextChild(
+      this._tree.children.length - 1,
+      -1,
+      e,
+      -2
+      /* Side.Before */
+    );
+  }
+  enter(e, t, n = 0) {
+    let r;
+    if (!(n & A.IgnoreOverlays) && (r = ge.get(this._tree)) && r.overlay) {
+      let s = e - this.from;
+      for (let { from: l, to: u } of r.overlay)
+        if ((t > 0 ? l <= s : l < s) && (t < 0 ? u >= s : u > s))
+          return new E(r.tree, r.overlay[0].from + this.from, -1, this);
+    }
+    return this.nextChild(0, 1, e, t, n);
+  }
+  nextSignificantParent() {
+    let e = this;
+    for (; e.type.isAnonymous && e._parent; )
+      e = e._parent;
+    return e;
+  }
+  get parent() {
+    return this._parent ? this._parent.nextSignificantParent() : null;
+  }
+  get nextSibling() {
+    return this._parent && this.index >= 0 ? this._parent.nextChild(
+      this.index + 1,
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    ) : null;
+  }
+  get prevSibling() {
+    return this._parent && this.index >= 0 ? this._parent.nextChild(
+      this.index - 1,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    ) : null;
+  }
+  get tree() {
+    return this._tree;
+  }
+  toTree() {
+    return this._tree;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this._tree.toString();
+  }
+}
+function Ee(i, e, t, n) {
+  let r = i.cursor(), s = [];
+  if (!r.firstChild())
+    return s;
+  if (t != null) {
+    for (let l = !1; !l; )
+      if (l = r.type.is(t), !r.nextSibling())
+        return s;
+  }
+  for (; ; ) {
+    if (n != null && r.type.is(n))
+      return s;
+    if (r.type.is(e) && s.push(r.node), !r.nextSibling())
+      return n == null ? s : [];
+  }
+}
+function xe(i, e, t = e.length - 1) {
+  for (let n = i.parent; t >= 0; n = n.parent) {
+    if (!n)
+      return !1;
+    if (!n.type.isAnonymous) {
+      if (e[t] && e[t] != n.name)
+        return !1;
+      t--;
+    }
+  }
+  return !0;
+}
+class yt {
+  constructor(e, t, n, r) {
+    this.parent = e, this.buffer = t, this.index = n, this.start = r;
+  }
+}
+class q extends Pe {
+  get name() {
+    return this.type.name;
+  }
+  get from() {
+    return this.context.start + this.context.buffer.buffer[this.index + 1];
+  }
+  get to() {
+    return this.context.start + this.context.buffer.buffer[this.index + 2];
+  }
+  constructor(e, t, n) {
+    super(), this.context = e, this._parent = t, this.index = n, this.type = e.buffer.set.types[e.buffer.buffer[n]];
+  }
+  child(e, t, n) {
+    let { buffer: r } = this.context, s = r.findChild(this.index + 4, r.buffer[this.index + 3], e, t - this.context.start, n);
+    return s < 0 ? null : new q(this.context, this, s);
+  }
+  get firstChild() {
+    return this.child(
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get lastChild() {
+    return this.child(
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  childAfter(e) {
+    return this.child(
+      1,
+      e,
+      2
+      /* Side.After */
+    );
+  }
+  childBefore(e) {
+    return this.child(
+      -1,
+      e,
+      -2
+      /* Side.Before */
+    );
+  }
+  enter(e, t, n = 0) {
+    if (n & A.ExcludeBuffers)
+      return null;
+    let { buffer: r } = this.context, s = r.findChild(this.index + 4, r.buffer[this.index + 3], t > 0 ? 1 : -1, e - this.context.start, t);
+    return s < 0 ? null : new q(this.context, this, s);
+  }
+  get parent() {
+    return this._parent || this.context.parent.nextSignificantParent();
+  }
+  externalSibling(e) {
+    return this._parent ? null : this.context.parent.nextChild(
+      this.context.index + e,
+      e,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get nextSibling() {
+    let { buffer: e } = this.context, t = e.buffer[this.index + 3];
+    return t < (this._parent ? e.buffer[this._parent.index + 3] : e.buffer.length) ? new q(this.context, this._parent, t) : this.externalSibling(1);
+  }
+  get prevSibling() {
+    let { buffer: e } = this.context, t = this._parent ? this._parent.index + 4 : 0;
+    return this.index == t ? this.externalSibling(-1) : new q(this.context, this._parent, e.findChild(
+      t,
+      this.index,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    ));
+  }
+  get tree() {
+    return null;
+  }
+  toTree() {
+    let e = [], t = [], { buffer: n } = this.context, r = this.index + 4, s = n.buffer[this.index + 3];
+    if (s > r) {
+      let l = n.buffer[this.index + 1];
+      e.push(n.slice(r, s, l)), t.push(0);
+    }
+    return new D(this.type, e, t, this.to - this.from);
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.context.buffer.childString(this.index);
+  }
+}
+function je(i) {
+  if (!i.length)
+    return null;
+  let e = 0, t = i[0];
+  for (let s = 1; s < i.length; s++) {
+    let l = i[s];
+    (l.from > t.from || l.to < t.to) && (t = l, e = s);
+  }
+  let n = t instanceof E && t.index < 0 ? null : t.parent, r = i.slice();
+  return n ? r[e] = n : r.splice(e, 1), new xt(r, t);
+}
+class xt {
+  constructor(e, t) {
+    this.heads = e, this.node = t;
+  }
+  get next() {
+    return je(this.heads);
+  }
+}
+function kt(i, e, t) {
+  let n = i.resolveInner(e, t), r = null;
+  for (let s = n instanceof E ? n : n.context.parent; s; s = s.parent)
+    if (s.index < 0) {
+      let l = s.parent;
+      (r || (r = [n])).push(l.resolve(e, t)), s = l;
+    } else {
+      let l = ge.get(s.tree);
+      if (l && l.overlay && l.overlay[0].from <= e && l.overlay[l.overlay.length - 1].to >= e) {
+        let u = new E(l.tree, l.overlay[0].from + s.from, -1, s);
+        (r || (r = [n])).push(le(u, e, t, !1));
+      }
+    }
+  return r ? je(r) : n;
+}
+class ke {
+  /**
+  Shorthand for `.type.name`.
+  */
+  get name() {
+    return this.type.name;
+  }
+  /**
+  @internal
+  */
+  constructor(e, t = 0) {
+    if (this.mode = t, this.buffer = null, this.stack = [], this.index = 0, this.bufferNode = null, e instanceof E)
+      this.yieldNode(e);
+    else {
+      this._tree = e.context.parent, this.buffer = e.context;
+      for (let n = e._parent; n; n = n._parent)
+        this.stack.unshift(n.index);
+      this.bufferNode = e, this.yieldBuf(e.index);
+    }
+  }
+  yieldNode(e) {
+    return e ? (this._tree = e, this.type = e.type, this.from = e.from, this.to = e.to, !0) : !1;
+  }
+  yieldBuf(e, t) {
+    this.index = e;
+    let { start: n, buffer: r } = this.buffer;
+    return this.type = t || r.set.types[r.buffer[e]], this.from = n + r.buffer[e + 1], this.to = n + r.buffer[e + 2], !0;
+  }
+  /**
+  @internal
+  */
+  yield(e) {
+    return e ? e instanceof E ? (this.buffer = null, this.yieldNode(e)) : (this.buffer = e.context, this.yieldBuf(e.index, e.type)) : !1;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
+  }
+  /**
+  @internal
+  */
+  enterChild(e, t, n) {
+    if (!this.buffer)
+      return this.yield(this._tree.nextChild(e < 0 ? this._tree._tree.children.length - 1 : 0, e, t, n, this.mode));
+    let { buffer: r } = this.buffer, s = r.findChild(this.index + 4, r.buffer[this.index + 3], e, t - this.buffer.start, n);
+    return s < 0 ? !1 : (this.stack.push(this.index), this.yieldBuf(s));
+  }
+  /**
+  Move the cursor to this node's first child. When this returns
+  false, the node has no child, and the cursor has not been moved.
+  */
+  firstChild() {
+    return this.enterChild(
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  /**
+  Move the cursor to this node's last child.
+  */
+  lastChild() {
+    return this.enterChild(
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  /**
+  Move the cursor to the first child that ends after `pos`.
+  */
+  childAfter(e) {
+    return this.enterChild(
+      1,
+      e,
+      2
+      /* Side.After */
+    );
+  }
+  /**
+  Move to the last child that starts before `pos`.
+  */
+  childBefore(e) {
+    return this.enterChild(
+      -1,
+      e,
+      -2
+      /* Side.Before */
+    );
+  }
+  /**
+  Move the cursor to the child around `pos`. If side is -1 the
+  child may end at that position, when 1 it may start there. This
+  will also enter [overlaid](#common.MountedTree.overlay)
+  [mounted](#common.NodeProp^mounted) trees unless `overlays` is
+  set to false.
+  */
+  enter(e, t, n = this.mode) {
+    return this.buffer ? n & A.ExcludeBuffers ? !1 : this.enterChild(1, e, t) : this.yield(this._tree.enter(e, t, n));
+  }
+  /**
+  Move to the node's parent node, if this isn't the top node.
+  */
+  parent() {
+    if (!this.buffer)
+      return this.yieldNode(this.mode & A.IncludeAnonymous ? this._tree._parent : this._tree.parent);
+    if (this.stack.length)
+      return this.yieldBuf(this.stack.pop());
+    let e = this.mode & A.IncludeAnonymous ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+    return this.buffer = null, this.yieldNode(e);
+  }
+  /**
+  @internal
+  */
+  sibling(e) {
+    if (!this.buffer)
+      return this._tree._parent ? this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + e, e, 0, 4, this.mode)) : !1;
+    let { buffer: t } = this.buffer, n = this.stack.length - 1;
+    if (e < 0) {
+      let r = n < 0 ? 0 : this.stack[n] + 4;
+      if (this.index != r)
+        return this.yieldBuf(t.findChild(
+          r,
+          this.index,
+          -1,
+          0,
+          4
+          /* Side.DontCare */
+        ));
+    } else {
+      let r = t.buffer[this.index + 3];
+      if (r < (n < 0 ? t.buffer.length : t.buffer[this.stack[n] + 3]))
+        return this.yieldBuf(r);
+    }
+    return n < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + e, e, 0, 4, this.mode)) : !1;
+  }
+  /**
+  Move to this node's next sibling, if any.
+  */
+  nextSibling() {
+    return this.sibling(1);
+  }
+  /**
+  Move to this node's previous sibling, if any.
+  */
+  prevSibling() {
+    return this.sibling(-1);
+  }
+  atLastNode(e) {
+    let t, n, { buffer: r } = this;
+    if (r) {
+      if (e > 0) {
+        if (this.index < r.buffer.buffer.length)
+          return !1;
+      } else
+        for (let s = 0; s < this.index; s++)
+          if (r.buffer.buffer[s + 3] < this.index)
+            return !1;
+      ({ index: t, parent: n } = r);
+    } else
+      ({ index: t, _parent: n } = this._tree);
+    for (; n; { index: t, _parent: n } = n)
+      if (t > -1)
+        for (let s = t + e, l = e < 0 ? -1 : n._tree.children.length; s != l; s += e) {
+          let u = n._tree.children[s];
+          if (this.mode & A.IncludeAnonymous || u instanceof X || !u.type.isAnonymous || Ce(u))
+            return !1;
+        }
+    return !0;
+  }
+  move(e, t) {
+    if (t && this.enterChild(
+      e,
+      0,
+      4
+      /* Side.DontCare */
+    ))
+      return !0;
+    for (; ; ) {
+      if (this.sibling(e))
+        return !0;
+      if (this.atLastNode(e) || !this.parent())
+        return !1;
+    }
+  }
+  /**
+  Move to the next node in a
+  [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
+  traversal, going from a node to its first child or, if the
+  current node is empty or `enter` is false, its next sibling or
+  the next sibling of the first parent node that has one.
+  */
+  next(e = !0) {
+    return this.move(1, e);
+  }
+  /**
+  Move to the next node in a last-to-first pre-order traveral. A
+  node is followed by its last child or, if it has none, its
+  previous sibling or the previous sibling of the first parent
+  node that has one.
+  */
+  prev(e = !0) {
+    return this.move(-1, e);
+  }
+  /**
+  Move the cursor to the innermost node that covers `pos`. If
+  `side` is -1, it will enter nodes that end at `pos`. If it is 1,
+  it will enter nodes that start at `pos`.
+  */
+  moveTo(e, t = 0) {
+    for (; (this.from == this.to || (t < 1 ? this.from >= e : this.from > e) || (t > -1 ? this.to <= e : this.to < e)) && this.parent(); )
+      ;
+    for (; this.enterChild(1, e, t); )
+      ;
+    return this;
+  }
+  /**
+  Get a [syntax node](#common.SyntaxNode) at the cursor's current
+  position.
+  */
+  get node() {
+    if (!this.buffer)
+      return this._tree;
+    let e = this.bufferNode, t = null, n = 0;
+    if (e && e.context == this.buffer)
+      e:
+        for (let r = this.index, s = this.stack.length; s >= 0; ) {
+          for (let l = e; l; l = l._parent)
+            if (l.index == r) {
+              if (r == this.index)
+                return l;
+              t = l, n = s + 1;
+              break e;
+            }
+          r = this.stack[--s];
+        }
+    for (let r = n; r < this.stack.length; r++)
+      t = new q(this.buffer, t, this.stack[r]);
+    return this.bufferNode = new q(this.buffer, t, this.index);
+  }
+  /**
+  Get the [tree](#common.Tree) that represents the current node, if
+  any. Will return null when the node is in a [tree
+  buffer](#common.TreeBuffer).
+  */
+  get tree() {
+    return this.buffer ? null : this._tree._tree;
+  }
+  /**
+  Iterate over the current node and all its descendants, calling
+  `enter` when entering a node and `leave`, if given, when leaving
+  one. When `enter` returns `false`, any children of that node are
+  skipped, and `leave` isn't called for it.
+  */
+  iterate(e, t) {
+    for (let n = 0; ; ) {
+      let r = !1;
+      if (this.type.isAnonymous || e(this) !== !1) {
+        if (this.firstChild()) {
+          n++;
+          continue;
+        }
+        this.type.isAnonymous || (r = !0);
+      }
+      for (; r && t && t(this), r = this.type.isAnonymous, !this.nextSibling(); ) {
+        if (!n)
+          return;
+        this.parent(), n--, r = !0;
+      }
+    }
+  }
+  /**
+  Test whether the current node matches a given context—a sequence
+  of direct parent node names. Empty strings in the context array
+  are treated as wildcards.
+  */
+  matchContext(e) {
+    if (!this.buffer)
+      return xe(this.node, e);
+    let { buffer: t } = this.buffer, { types: n } = t.set;
+    for (let r = e.length - 1, s = this.stack.length - 1; r >= 0; s--) {
+      if (s < 0)
+        return xe(this.node, e, r);
+      let l = n[t.buffer[this.stack[s]]];
+      if (!l.isAnonymous) {
+        if (e[r] && e[r] != l.name)
+          return !1;
+        r--;
+      }
+    }
+    return !0;
+  }
+}
+function Ce(i) {
+  return i.children.some((e) => e instanceof X || !e.type.isAnonymous || Ce(e));
+}
+function _t(i) {
+  var e;
+  let { buffer: t, nodeSet: n, maxBufferLength: r = gt, reused: s = [], minRepeatType: l = n.types.length } = i, u = Array.isArray(t) ? new ve(t, t.length) : t, h = n.types, v = 0, C = 0;
+  function N(g, b, f, y, p, m) {
+    let { id: c, start: d, end: k, size: x } = u, B = C;
+    for (; x < 0; )
+      if (u.next(), x == -1) {
+        let W = s[c];
+        f.push(W), y.push(d - g);
+        return;
+      } else if (x == -3) {
+        v = c;
+        return;
+      } else if (x == -4) {
+        C = c;
+        return;
+      } else
+        throw new RangeError(`Unrecognized record size: ${x}`);
+    let Y = h[c], te, Q, Ne = d - g;
+    if (k - d <= r && (Q = O(u.pos - b, p))) {
+      let W = new Uint16Array(Q.size - Q.skip), L = u.pos - Q.size, T = W.length;
+      for (; u.pos > L; )
+        T = J(Q.start, W, T);
+      te = new X(W, k - Q.start, n), Ne = Q.start - g;
+    } else {
+      let W = u.pos - x;
+      u.next();
+      let L = [], T = [], Z = c >= l ? c : -1, ne = 0, oe = k;
+      for (; u.pos > W; )
+        Z >= 0 && u.id == Z && u.size >= 0 ? (u.end <= oe - r && (I(L, T, d, ne, u.end, oe, Z, B), ne = L.length, oe = u.end), u.next()) : m > 2500 ? S(d, W, L, T) : N(d, W, L, T, Z, m + 1);
+      if (Z >= 0 && ne > 0 && ne < L.length && I(L, T, d, ne, d, oe, Z, B), L.reverse(), T.reverse(), Z > -1 && ne > 0) {
+        let Ae = z(Y);
+        te = we(Y, L, T, 0, L.length, 0, k - d, Ae, Ae);
+      } else
+        te = M(Y, L, T, k - d, B - k);
+    }
+    f.push(te), y.push(Ne);
+  }
+  function S(g, b, f, y) {
+    let p = [], m = 0, c = -1;
+    for (; u.pos > b; ) {
+      let { id: d, start: k, end: x, size: B } = u;
+      if (B > 4)
+        u.next();
+      else {
+        if (c > -1 && k < c)
+          break;
+        c < 0 && (c = x - r), p.push(d, k, x), m++, u.next();
+      }
+    }
+    if (m) {
+      let d = new Uint16Array(m * 4), k = p[p.length - 2];
+      for (let x = p.length - 3, B = 0; x >= 0; x -= 3)
+        d[B++] = p[x], d[B++] = p[x + 1] - k, d[B++] = p[x + 2] - k, d[B++] = B;
+      f.push(new X(d, p[2] - k, n)), y.push(k - g);
+    }
+  }
+  function z(g) {
+    return (b, f, y) => {
+      let p = 0, m = b.length - 1, c, d;
+      if (m >= 0 && (c = b[m]) instanceof D) {
+        if (!m && c.type == g && c.length == y)
+          return c;
+        (d = c.prop(_.lookAhead)) && (p = f[m] + c.length + d);
+      }
+      return M(g, b, f, y, p);
+    };
+  }
+  function I(g, b, f, y, p, m, c, d) {
+    let k = [], x = [];
+    for (; g.length > y; )
+      k.push(g.pop()), x.push(b.pop() + f - p);
+    g.push(M(n.types[c], k, x, m - p, d - m)), b.push(p - f);
+  }
+  function M(g, b, f, y, p = 0, m) {
+    if (v) {
+      let c = [_.contextHash, v];
+      m = m ? [c].concat(m) : [c];
+    }
+    if (p > 25) {
+      let c = [_.lookAhead, p];
+      m = m ? [c].concat(m) : [c];
+    }
+    return new D(g, b, f, y, m);
+  }
+  function O(g, b) {
+    let f = u.fork(), y = 0, p = 0, m = 0, c = f.end - r, d = { size: 0, start: 0, skip: 0 };
+    e:
+      for (let k = f.pos - g; f.pos > k; ) {
+        let x = f.size;
+        if (f.id == b && x >= 0) {
+          d.size = y, d.start = p, d.skip = m, m += 4, y += 4, f.next();
+          continue;
+        }
+        let B = f.pos - x;
+        if (x < 0 || B < k || f.start < c)
+          break;
+        let Y = f.id >= l ? 4 : 0, te = f.start;
+        for (f.next(); f.pos > B; ) {
+          if (f.size < 0)
+            if (f.size == -3)
+              Y += 4;
+            else
+              break e;
+          else
+            f.id >= l && (Y += 4);
+          f.next();
+        }
+        p = te, y += x, m += Y;
+      }
+    return (b < 0 || y == g) && (d.size = y, d.start = p, d.skip = m), d.size > 4 ? d : void 0;
+  }
+  function J(g, b, f) {
+    let { id: y, start: p, end: m, size: c } = u;
+    if (u.next(), c >= 0 && y < l) {
+      let d = f;
+      if (c > 4) {
+        let k = u.pos - (c - 4);
+        for (; u.pos > k; )
+          f = J(g, b, f);
+      }
+      b[--f] = d, b[--f] = m - g, b[--f] = p - g, b[--f] = y;
+    } else
+      c == -3 ? v = y : c == -4 && (C = y);
+    return f;
+  }
+  let U = [], w = [];
+  for (; u.pos > 0; )
+    N(i.start || 0, i.bufferStart || 0, U, w, -1, 0);
+  let V = (e = i.length) !== null && e !== void 0 ? e : U.length ? w[0] + U[0].length : 0;
+  return new D(h[i.topID], U.reverse(), w.reverse(), V);
+}
+const Oe = /* @__PURE__ */ new WeakMap();
+function de(i, e) {
+  if (!i.isAnonymous || e instanceof X || e.type != i)
+    return 1;
+  let t = Oe.get(e);
+  if (t == null) {
+    t = 1;
+    for (let n of e.children) {
+      if (n.type != i || !(n instanceof D)) {
+        t = 1;
+        break;
+      }
+      t += de(i, n);
+    }
+    Oe.set(e, t);
+  }
+  return t;
+}
+function we(i, e, t, n, r, s, l, u, h) {
+  let v = 0;
+  for (let I = n; I < r; I++)
+    v += de(i, e[I]);
+  let C = Math.ceil(
+    v * 1.5 / 8
+    /* Balance.BranchFactor */
+  ), N = [], S = [];
+  function z(I, M, O, J, U) {
+    for (let w = O; w < J; ) {
+      let V = w, g = M[w], b = de(i, I[w]);
+      for (w++; w < J; w++) {
+        let f = de(i, I[w]);
+        if (b + f >= C)
+          break;
+        b += f;
+      }
+      if (w == V + 1) {
+        if (b > C) {
+          let f = I[V];
+          z(f.children, f.positions, 0, f.children.length, M[V] + U);
+          continue;
+        }
+        N.push(I[V]);
+      } else {
+        let f = M[w - 1] + I[w - 1].length - g;
+        N.push(we(i, I, M, V, w, g, f, null, h));
+      }
+      S.push(g + U - s);
+    }
+  }
+  return z(e, t, n, r, 0), (u || h)(N, S, l);
+}
+new _({ perNode: !0 });
+let vt = 0;
+class R {
+  /**
+  @internal
+  */
+  constructor(e, t, n) {
+    this.set = e, this.base = t, this.modified = n, this.id = vt++;
+  }
+  /**
+  Define a new tag. If `parent` is given, the tag is treated as a
+  sub-tag of that parent, and
+  [highlighters](#highlight.tagHighlighter) that don't mention
+  this tag will try to fall back to the parent tag (or grandparent
+  tag, etc).
+  */
+  static define(e) {
+    if (e != null && e.base)
+      throw new Error("Can not derive from a modified tag");
+    let t = new R([], null, []);
+    if (t.set.push(t), e)
+      for (let n of e.set)
+        t.set.push(n);
+    return t;
+  }
+  /**
+  Define a tag _modifier_, which is a function that, given a tag,
+  will return a tag that is a subtag of the original. Applying the
+  same modifier to a twice tag will return the same value (`m1(t1)
+  == m1(t1)`) and applying multiple modifiers will, regardless or
+  order, produce the same tag (`m1(m2(t1)) == m2(m1(t1))`).
+  
+  When multiple modifiers are applied to a given base tag, each
+  smaller set of modifiers is registered as a parent, so that for
+  example `m1(m2(m3(t1)))` is a subtype of `m1(m2(t1))`,
+  `m1(m3(t1)`, and so on.
+  */
+  static defineModifier() {
+    let e = new me();
+    return (t) => t.modified.indexOf(e) > -1 ? t : me.get(t.base || t, t.modified.concat(e).sort((n, r) => n.id - r.id));
+  }
+}
+let Ct = 0;
+class me {
+  constructor() {
+    this.instances = [], this.id = Ct++;
+  }
+  static get(e, t) {
+    if (!t.length)
+      return e;
+    let n = t[0].instances.find((u) => u.base == e && wt(t, u.modified));
+    if (n)
+      return n;
+    let r = [], s = new R(r, e, t);
+    for (let u of t)
+      u.instances.push(s);
+    let l = Nt(t);
+    for (let u of e.set)
+      if (!u.modified.length)
+        for (let h of l)
+          r.push(me.get(u, h));
+    return s;
+  }
+}
+function wt(i, e) {
+  return i.length == e.length && i.every((t, n) => t == e[n]);
+}
+function Nt(i) {
+  let e = [[]];
+  for (let t = 0; t < i.length; t++)
+    for (let n = 0, r = e.length; n < r; n++)
+      e.push(e[n].concat(i[t]));
+  return e.sort((t, n) => n.length - t.length);
+}
+new _();
+function At(i, e) {
+  let t = /* @__PURE__ */ Object.create(null);
+  for (let s of i)
+    if (!Array.isArray(s.tag))
+      t[s.tag.id] = s.class;
+    else
+      for (let l of s.tag)
+        t[l.id] = s.class;
+  let { scope: n, all: r = null } = e || {};
+  return {
+    style: (s) => {
+      let l = r;
+      for (let u of s)
+        for (let h of u.set) {
+          let v = t[h.id];
+          if (v) {
+            l = l ? l + " " + v : v;
+            break;
+          }
+        }
+      return l;
+    },
+    scope: n
+  };
+}
+const a = R.define, fe = a(), $ = a(), ze = a($), Me = a($), K = a(), he = a(K), ye = a(K), H = a(), ee = a(H), P = a(), j = a(), _e = a(), ie = a(_e), ce = a(), o = {
+  /**
+  A comment.
+  */
+  comment: fe,
+  /**
+  A line [comment](#highlight.tags.comment).
+  */
+  lineComment: a(fe),
+  /**
+  A block [comment](#highlight.tags.comment).
+  */
+  blockComment: a(fe),
+  /**
+  A documentation [comment](#highlight.tags.comment).
+  */
+  docComment: a(fe),
+  /**
+  Any kind of identifier.
+  */
+  name: $,
+  /**
+  The [name](#highlight.tags.name) of a variable.
+  */
+  variableName: a($),
+  /**
+  A type [name](#highlight.tags.name).
+  */
+  typeName: ze,
+  /**
+  A tag name (subtag of [`typeName`](#highlight.tags.typeName)).
+  */
+  tagName: a(ze),
+  /**
+  A property or field [name](#highlight.tags.name).
+  */
+  propertyName: Me,
+  /**
+  An attribute name (subtag of [`propertyName`](#highlight.tags.propertyName)).
+  */
+  attributeName: a(Me),
+  /**
+  The [name](#highlight.tags.name) of a class.
+  */
+  className: a($),
+  /**
+  A label [name](#highlight.tags.name).
+  */
+  labelName: a($),
+  /**
+  A namespace [name](#highlight.tags.name).
+  */
+  namespace: a($),
+  /**
+  The [name](#highlight.tags.name) of a macro.
+  */
+  macroName: a($),
+  /**
+  A literal value.
+  */
+  literal: K,
+  /**
+  A string [literal](#highlight.tags.literal).
+  */
+  string: he,
+  /**
+  A documentation [string](#highlight.tags.string).
+  */
+  docString: a(he),
+  /**
+  A character literal (subtag of [string](#highlight.tags.string)).
+  */
+  character: a(he),
+  /**
+  An attribute value (subtag of [string](#highlight.tags.string)).
+  */
+  attributeValue: a(he),
+  /**
+  A number [literal](#highlight.tags.literal).
+  */
+  number: ye,
+  /**
+  An integer [number](#highlight.tags.number) literal.
+  */
+  integer: a(ye),
+  /**
+  A floating-point [number](#highlight.tags.number) literal.
+  */
+  float: a(ye),
+  /**
+  A boolean [literal](#highlight.tags.literal).
+  */
+  bool: a(K),
+  /**
+  Regular expression [literal](#highlight.tags.literal).
+  */
+  regexp: a(K),
+  /**
+  An escape [literal](#highlight.tags.literal), for example a
+  backslash escape in a string.
+  */
+  escape: a(K),
+  /**
+  A color [literal](#highlight.tags.literal).
+  */
+  color: a(K),
+  /**
+  A URL [literal](#highlight.tags.literal).
+  */
+  url: a(K),
+  /**
+  A language keyword.
+  */
+  keyword: P,
+  /**
+  The [keyword](#highlight.tags.keyword) for the self or this
+  object.
+  */
+  self: a(P),
+  /**
+  The [keyword](#highlight.tags.keyword) for null.
+  */
+  null: a(P),
+  /**
+  A [keyword](#highlight.tags.keyword) denoting some atomic value.
+  */
+  atom: a(P),
+  /**
+  A [keyword](#highlight.tags.keyword) that represents a unit.
+  */
+  unit: a(P),
+  /**
+  A modifier [keyword](#highlight.tags.keyword).
+  */
+  modifier: a(P),
+  /**
+  A [keyword](#highlight.tags.keyword) that acts as an operator.
+  */
+  operatorKeyword: a(P),
+  /**
+  A control-flow related [keyword](#highlight.tags.keyword).
+  */
+  controlKeyword: a(P),
+  /**
+  A [keyword](#highlight.tags.keyword) that defines something.
+  */
+  definitionKeyword: a(P),
+  /**
+  A [keyword](#highlight.tags.keyword) related to defining or
+  interfacing with modules.
+  */
+  moduleKeyword: a(P),
+  /**
+  An operator.
+  */
+  operator: j,
+  /**
+  An [operator](#highlight.tags.operator) that dereferences something.
+  */
+  derefOperator: a(j),
+  /**
+  Arithmetic-related [operator](#highlight.tags.operator).
+  */
+  arithmeticOperator: a(j),
+  /**
+  Logical [operator](#highlight.tags.operator).
+  */
+  logicOperator: a(j),
+  /**
+  Bit [operator](#highlight.tags.operator).
+  */
+  bitwiseOperator: a(j),
+  /**
+  Comparison [operator](#highlight.tags.operator).
+  */
+  compareOperator: a(j),
+  /**
+  [Operator](#highlight.tags.operator) that updates its operand.
+  */
+  updateOperator: a(j),
+  /**
+  [Operator](#highlight.tags.operator) that defines something.
+  */
+  definitionOperator: a(j),
+  /**
+  Type-related [operator](#highlight.tags.operator).
+  */
+  typeOperator: a(j),
+  /**
+  Control-flow [operator](#highlight.tags.operator).
+  */
+  controlOperator: a(j),
+  /**
+  Program or markup punctuation.
+  */
+  punctuation: _e,
+  /**
+  [Punctuation](#highlight.tags.punctuation) that separates
+  things.
+  */
+  separator: a(_e),
+  /**
+  Bracket-style [punctuation](#highlight.tags.punctuation).
+  */
+  bracket: ie,
+  /**
+  Angle [brackets](#highlight.tags.bracket) (usually `<` and `>`
+  tokens).
+  */
+  angleBracket: a(ie),
+  /**
+  Square [brackets](#highlight.tags.bracket) (usually `[` and `]`
+  tokens).
+  */
+  squareBracket: a(ie),
+  /**
+  Parentheses (usually `(` and `)` tokens). Subtag of
+  [bracket](#highlight.tags.bracket).
+  */
+  paren: a(ie),
+  /**
+  Braces (usually `{` and `}` tokens). Subtag of
+  [bracket](#highlight.tags.bracket).
+  */
+  brace: a(ie),
+  /**
+  Content, for example plain text in XML or markup documents.
+  */
+  content: H,
+  /**
+  [Content](#highlight.tags.content) that represents a heading.
+  */
+  heading: ee,
+  /**
+  A level 1 [heading](#highlight.tags.heading).
+  */
+  heading1: a(ee),
+  /**
+  A level 2 [heading](#highlight.tags.heading).
+  */
+  heading2: a(ee),
+  /**
+  A level 3 [heading](#highlight.tags.heading).
+  */
+  heading3: a(ee),
+  /**
+  A level 4 [heading](#highlight.tags.heading).
+  */
+  heading4: a(ee),
+  /**
+  A level 5 [heading](#highlight.tags.heading).
+  */
+  heading5: a(ee),
+  /**
+  A level 6 [heading](#highlight.tags.heading).
+  */
+  heading6: a(ee),
+  /**
+  A prose separator (such as a horizontal rule).
+  */
+  contentSeparator: a(H),
+  /**
+  [Content](#highlight.tags.content) that represents a list.
+  */
+  list: a(H),
+  /**
+  [Content](#highlight.tags.content) that represents a quote.
+  */
+  quote: a(H),
+  /**
+  [Content](#highlight.tags.content) that is emphasized.
+  */
+  emphasis: a(H),
+  /**
+  [Content](#highlight.tags.content) that is styled strong.
+  */
+  strong: a(H),
+  /**
+  [Content](#highlight.tags.content) that is part of a link.
+  */
+  link: a(H),
+  /**
+  [Content](#highlight.tags.content) that is styled as code or
+  monospace.
+  */
+  monospace: a(H),
+  /**
+  [Content](#highlight.tags.content) that has a strike-through
+  style.
+  */
+  strikethrough: a(H),
+  /**
+  Inserted text in a change-tracking format.
+  */
+  inserted: a(),
+  /**
+  Deleted text.
+  */
+  deleted: a(),
+  /**
+  Changed text.
+  */
+  changed: a(),
+  /**
+  An invalid or unsyntactic element.
+  */
+  invalid: a(),
+  /**
+  Metadata or meta-instruction.
+  */
+  meta: ce,
+  /**
+  [Metadata](#highlight.tags.meta) that applies to the entire
+  document.
+  */
+  documentMeta: a(ce),
+  /**
+  [Metadata](#highlight.tags.meta) that annotates or adds
+  attributes to a given syntactic element.
+  */
+  annotation: a(ce),
+  /**
+  Processing instruction or preprocessor directive. Subtag of
+  [meta](#highlight.tags.meta).
+  */
+  processingInstruction: a(ce),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates that a
+  given element is being defined. Expected to be used with the
+  various [name](#highlight.tags.name) tags.
+  */
+  definition: R.defineModifier(),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates that
+  something is constant. Mostly expected to be used with
+  [variable names](#highlight.tags.variableName).
+  */
+  constant: R.defineModifier(),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) used to indicate that
+  a [variable](#highlight.tags.variableName) or [property
+  name](#highlight.tags.propertyName) is being called or defined
+  as a function.
+  */
+  function: R.defineModifier(),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that can be applied to
+  [names](#highlight.tags.name) to indicate that they belong to
+  the language's standard environment.
+  */
+  standard: R.defineModifier(),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates a given
+  [names](#highlight.tags.name) is local to some scope.
+  */
+  local: R.defineModifier(),
+  /**
+  A generic variant [modifier](#highlight.Tag^defineModifier) that
+  can be used to tag language-specific alternative variants of
+  some common tag. It is recommended for themes to define special
+  forms of at least the [string](#highlight.tags.string) and
+  [variable name](#highlight.tags.variableName) tags, since those
+  come up a lot.
+  */
+  special: R.defineModifier()
+};
+At([
+  { tag: o.link, class: "tok-link" },
+  { tag: o.heading, class: "tok-heading" },
+  { tag: o.emphasis, class: "tok-emphasis" },
+  { tag: o.strong, class: "tok-strong" },
+  { tag: o.keyword, class: "tok-keyword" },
+  { tag: o.atom, class: "tok-atom" },
+  { tag: o.bool, class: "tok-bool" },
+  { tag: o.url, class: "tok-url" },
+  { tag: o.labelName, class: "tok-labelName" },
+  { tag: o.inserted, class: "tok-inserted" },
+  { tag: o.deleted, class: "tok-deleted" },
+  { tag: o.literal, class: "tok-literal" },
+  { tag: o.string, class: "tok-string" },
+  { tag: o.number, class: "tok-number" },
+  { tag: [o.regexp, o.escape, o.special(o.string)], class: "tok-string2" },
+  { tag: o.variableName, class: "tok-variableName" },
+  { tag: o.local(o.variableName), class: "tok-variableName tok-local" },
+  { tag: o.definition(o.variableName), class: "tok-variableName tok-definition" },
+  { tag: o.special(o.variableName), class: "tok-variableName2" },
+  { tag: o.definition(o.propertyName), class: "tok-propertyName tok-definition" },
+  { tag: o.typeName, class: "tok-typeName" },
+  { tag: o.namespace, class: "tok-namespace" },
+  { tag: o.className, class: "tok-className" },
+  { tag: o.macroName, class: "tok-macroName" },
+  { tag: o.propertyName, class: "tok-propertyName" },
+  { tag: o.operator, class: "tok-operator" },
+  { tag: o.comment, class: "tok-comment" },
+  { tag: o.meta, class: "tok-meta" },
+  { tag: o.invalid, class: "tok-invalid" },
+  { tag: o.punctuation, class: "tok-punctuation" }
+]);
+const St = {
+  red: Xe,
+  orange: Ye,
+  green: Qe,
+  blue: Ze,
+  invalid: "#ffffff"
+}, It = (i) => qe.define([
+  {
+    tag: o.keyword,
+    color: i.red
+  },
+  {
+    tag: [o.name, o.deleted, o.character, o.propertyName, o.macroName],
+    color: i.green
+  },
+  {
+    tag: [o.function(o.variableName), o.labelName],
+    color: i.blue
+  },
+  {
+    tag: [o.color, o.constant(o.name), o.standard(o.name)],
+    color: i.red
+  },
+  {
+    tag: [o.definition(o.name), o.separator],
+    color: i.red
+  },
+  {
+    tag: [o.typeName, o.className, o.number, o.changed, o.annotation, o.modifier, o.self, o.namespace],
+    color: i.orange
+  },
+  {
+    tag: [o.operator, o.operatorKeyword, o.url, o.escape, o.regexp, o.link, o.special(o.string)],
+    color: i.blue
+  },
+  {
+    tag: [o.meta, o.comment],
+    color: i.orange
+  },
+  {
+    tag: o.strong,
+    fontWeight: "bold"
+  },
+  {
+    tag: o.emphasis,
+    fontStyle: "italic"
+  },
+  {
+    tag: o.strikethrough,
+    textDecoration: "line-through"
+  },
+  {
+    tag: o.link,
+    color: i.orange,
+    textDecoration: "underline"
+  },
+  {
+    tag: o.heading,
+    fontWeight: "bold",
+    color: i.blue
+  },
+  {
+    tag: [o.atom, o.bool, o.special(o.variableName)],
+    color: i.red
+  },
+  {
+    tag: [o.processingInstruction, o.string, o.inserted],
+    color: i.blue
+  },
+  {
+    tag: o.invalid,
+    color: i.invalid
+  }
+]), Bt = Fe(It(St));
+var pe = /* @__PURE__ */ ((i) => (i.INLINE = "inline", i.SINGLELINE = "singleline", i.MULTILINE = "multiline", i))(pe || {}), F = /* @__PURE__ */ ((i) => (i.JSON = "json", i.XML = "xml", i.JAVA = "java", i.JAVASCRIPT = "javascript", i.PYTHON = "python", i))(F || {}), se = /* @__PURE__ */ ((i) => (i.ACTION = "action", i.CHANGE = "change", i))(se || {});
+const Lt = {
+  [F.JSON]: at,
+  [F.XML]: ut,
+  [F.JAVASCRIPT]: ft,
+  [F.JAVA]: ht,
+  [F.PYTHON]: ct
+}, Et = (i) => async () => Lt[i], Ot = (i, e) => {
+  const t = i.doc.lineAt(e.from), n = /^\s*/.exec(t.text);
+  return n ? n[0] : "";
+}, zt = {
+  key: "Enter",
+  run: ({ state: i, dispatch: e }) => {
+    const t = i.changeByRange((n) => {
+      const s = `
+${Ot(i, n)}`;
+      return {
+        changes: { from: n.from, to: n.to, insert: s },
+        range: Ge.cursor(n.from + s.length)
+      };
+    });
+    return e(i.update(t, { scrollIntoView: !0, userEvent: "input" })), !0;
+  }
+}, Mt = {
+  "en-US": {
+    run: "Run",
+    expand: "Expand"
+  }
+}, Tt = He({
+  i18n: { messages: Mt },
+  name: "bento-code-snippet",
+  components: {
+    BentoTypography: nt,
+    BentoButton: tt,
+    BentoDropdown: et,
+    Copy: ot,
+    BaseModal: lt,
+    BentoLoadingIndicator: rt,
+    ExpandIcon: st
+  },
+  directives: { BentoTooltipDirective: dt },
+  props: {
+    /**
+     * Defines the variant of code-snippet
+     */
+    variant: {
+      type: String,
+      default: pe.MULTILINE,
+      validator: (i) => Object.values(pe).includes(i)
+    },
+    /**
+     * Language name for syntax highlighting rules
+     */
+    lang: {
+      type: String,
+      default: F.JSON,
+      validator: (i) => Object.values(F).includes(i)
+    },
+    /**
+     * Label to show in the action-bar, describing the language
+     */
+    langLabel: {
+      type: String,
+      default: null
+    },
+    /**
+     * The code content
+     */
+    content: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Allows editing of the code-snippet content by the user
+     */
+    editable: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Displays a button that when clicked will emit an action event
+     * Leaves to the parent component the logic of what to do with it
+     */
+    actionable: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Displays a button that can expand the codeblock into a modal to easily
+     * view large blocks of code.
+     */
+    expandable: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Displays a button that when clicked will emit a run event
+     * Leaves to the parent component the logic of what to do with it
+     */
+    actionableText: {
+      type: String,
+      default: "run"
+    },
+    /**
+     * Toggles the loading indicator within the action bar
+     */
+    loading: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [se.ACTION, se.CHANGE],
+  setup(i, { emit: e }) {
+    const { t } = it(), n = ae(null), r = [], s = () => {
+    }, l = re(() => i.langLabel ?? i.lang.toUpperCase()), u = re(() => i.variant === pe.INLINE), h = re(() => ({
+      "b-code-snippet--inline": u.value,
+      "b-code-snippet--scrollable": !u.value
+    })), v = re(() => ({
+      "b-code-snippet__code-area-content--editable": i.editable
+    })), C = Et(i.lang), N = Se(), S = Se(), z = new be(), I = new be(), M = new be(), O = ae(null), J = ae(0);
+    Re(async () => {
+      const g = await C();
+      O.value = i.content;
+      const b = ({ state: p }) => {
+        O.value = p.doc.toString();
+      }, f = [
+        Ue(),
+        Ve.of([$e, zt]),
+        z.of(g()),
+        I.of(Bt),
+        M.of(Be.readOnly.of(!i.editable)),
+        Ie.updateListener.of((p) => b(p))
+      ];
+      i.variant === "multiline" && f.push([We(), Ke()]);
+      const y = Be.create({
+        doc: i.content,
+        extensions: [...f]
+      });
+      J.value = y.doc.length, S.value = new Ie({
+        state: y,
+        parent: N.value
+      });
+    }), De(
+      () => i.content,
+      () => {
+        if (i.content !== O.value) {
+          const g = i.content.length;
+          S.value.dispatch({
+            changes: {
+              from: 0,
+              to: J.value,
+              insert: i.content
+            }
+          }), J.value = g;
+        }
+      }
+    );
+    const U = re(() => t(i.actionableText)), w = () => {
+      e(se.ACTION, O.value);
+    };
+    Je(() => {
+      O.value !== null && e(se.CHANGE, O.value);
+    });
+    const V = ae(!1);
+    return {
+      // Values
+      availableLanguages: r,
+      codeAreaContentConditionalClasses: v,
+      conditionalClasses: h,
+      container: N,
+      currentContents: O,
+      displayedLang: l,
+      editor: S,
+      selectedLanguage: n,
+      showModal: V,
+      isInlineVariant: u,
+      // Methods
+      handleChangeLanguage: s,
+      onActionClicked: w,
+      runText: U,
+      // Translations
+      t
+    };
+  }
+});
+var Pt = function() {
+  var e = this, t = e._self._c;
+  return e._self._setupProxy, t("div", { staticClass: "b-code-snippet", class: e.conditionalClasses }, [e.isInlineVariant ? e._e() : t("section", { staticClass: "b-code-snippet__action-bar" }, [t("div", { staticClass: "b-code-snippet__action-bar--start" }, [e.availableLanguages.length > 0 ? t("bento-dropdown", e._b({ staticClass: "b-code-snippet__language-picker", attrs: { disabled: e.availableLanguages.length === 1, items: e.availableLanguages }, on: { input: e.handleChangeLanguage }, model: { value: e.selectedLanguage, callback: function(n) {
+    e.selectedLanguage = n;
+  }, expression: "selectedLanguage" } }, "bento-dropdown", e.$props, !1)) : e._e(), t("bento-typography", { attrs: { el: "span", stronger: "" } }, [e._v(" " + e._s(e.displayedLang) + " ")])], 1), t("div", { staticClass: "b-code-snippet__action-bar--end" }, [e.loading ? t("bento-loading-indicator") : e._e(), e.currentContents !== null ? t("copy", { staticClass: "b-structured-list__icon", attrs: { text: e.currentContents } }) : e._e(), e.expandable ? t("bento-button", { attrs: { variant: "tertiary", condensed: "", "aria-label": e.t("expand") }, on: { click: function(n) {
+    e.showModal = !0;
+  } }, scopedSlots: e._u([{ key: "iconLeft", fn: function() {
+    return [t("expand-icon")];
+  }, proxy: !0 }], null, !1, 3789760120) }) : e._e(), e.actionable ? t("bento-button", { attrs: { variant: "primary", tertiary: "", condensed: "" }, on: { click: e.onActionClicked }, scopedSlots: e._u([{ key: "iconLeft", fn: function() {
+    return [t("bento-typography", { staticClass: "b-code-snippet__action-button", attrs: { el: "span" } }, [e._v(" " + e._s(e.runText) + " ")])];
+  }, proxy: !0 }], null, !1, 4293069853) }) : e._e()], 1)]), e.content || e.editable ? t("code", { staticClass: "b-code-snippet__code-area" }, [t("div", { ref: "container", staticClass: "b-code-snippet__code-area-content", class: e.codeAreaContentConditionalClasses })]) : t("section", [e._t("empty-state", function() {
+    return [t("div", { staticClass: "b-code-snippet__empty-state" }, [e._v("Nothing to show")])];
+  })], 2), e.expandable ? t("base-modal", { staticClass: "b-code-snippet__modal", attrs: { "hide-close-button": !0, "custom-padding": "0px", "is-dismissible": !0, "is-open": e.showModal, size: "large" }, on: { "close-modal": function(n) {
+    e.showModal = !1;
+  } }, scopedSlots: e._u([{ key: "content", fn: function() {
+    return [t("bento-code-snippet", e._b({}, "bento-code-snippet", { ...e.$props, expandable: !1 }, !1))];
+  }, proxy: !0 }], null, !1, 3343589027) }) : e._e()], 1);
+}, jt = [], Ht = /* @__PURE__ */ pt(
+  Tt,
+  Pt,
+  jt,
+  !1,
+  null,
+  "befa6cc9",
+  null,
+  null
+);
+const on = Ht.exports;
 export {
-  n as BentoCodeSnippet,
-  o as BentoCodeSnippetEvent,
-  p as BentoCodeSnippetSupportedLanguage,
-  a as BentoCodeSnippetVariant
+  on as BentoCodeSnippet,
+  se as BentoCodeSnippetEvent,
+  F as BentoCodeSnippetSupportedLanguage,
+  pe as BentoCodeSnippetVariant
 };
 //# sourceMappingURL=code-snippet.js.map