@adyen/bento-vue2 1.26.0 → 1.28.0

package/dist/chunks/code-snippet.C4IbjAhH.js

@@ -0,0 +1,968 @@
+import { defineComponent as oe, ref as L, computed as k, shallowRef as P, onMounted as re, watch as ie, watchEffect as se } from "vue";
+import { highlightActiveLine as le, keymap as ce, EditorView as J, lineNumbers as de } from "@codemirror/view";
+import { EditorSelection as ge, Compartment as j, EditorState as G } from "@codemirror/state";
+import { indentWithTab as ue, history as pe } from "@codemirror/commands";
+import { syntaxHighlighting as fe, HighlightStyle as me } from "@codemirror/language";
+import { B as he } from "./dropdown.yhhQCKve.js";
+import { B as be } from "./button.DhAUh5JA.js";
+import { B as ye } from "./typography.Bjtu3Gca.js";
+import { B as ve } from "./loading-indicator.DXc7I1Lm.js";
+import { u as _e } from "./i18n.BQkEbtPM.js";
+import { n as q } from "./_plugin-vue2_normalizer.CeySl7Fu.js";
+import { h as Ne } from "./base-modal.C5I7bR0d.js";
+import { C as ke } from "./copy.BtFWFG3q.js";
+import { json as we } from "@codemirror/lang-json";
+import { xml as Ce } from "@codemirror/lang-xml";
+import { javascript as xe } from "@codemirror/lang-javascript";
+import { java as Le } from "@codemirror/lang-java";
+import { python as Ae } from "@codemirror/lang-python";
+import { B as Oe } from "./tooltip.DR8rbIYw.js";
+import "../assets/code-snippet.css";
+let Ie = 0;
+class l {
+  /**
+  Create a new node prop type.
+  */
+  constructor(e = {}) {
+    this.id = Ie++, 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 = x.match(e)), (o) => {
+      let r = e(o);
+      return r === void 0 ? null : [this, r];
+    };
+  }
+}
+l.closedBy = new l({ deserialize: (t) => t.split(" ") });
+l.openedBy = new l({ deserialize: (t) => t.split(" ") });
+l.group = new l({ deserialize: (t) => t.split(" ") });
+l.isolate = new l({ deserialize: (t) => {
+  if (t && t != "rtl" && t != "ltr" && t != "auto")
+    throw new RangeError("Invalid value for isolate: " + t);
+  return t || "auto";
+} });
+l.contextHash = new l({ perNode: !0 });
+l.lookAhead = new l({ perNode: !0 });
+l.mounted = new l({ perNode: !0 });
+const Ee = /* @__PURE__ */ Object.create(null);
+class x {
+  /**
+  @internal
+  */
+  constructor(e, o, r, s = 0) {
+    this.name = e, this.props = o, this.id = r, this.flags = s;
+  }
+  /**
+  Define a node type.
+  */
+  static define(e) {
+    let o = e.props && e.props.length ? /* @__PURE__ */ Object.create(null) : Ee, r = (e.top ? 1 : 0) | (e.skipped ? 2 : 0) | (e.error ? 4 : 0) | (e.name == null ? 8 : 0), s = new x(e.name || "", o, e.id, r);
+    if (e.props) {
+      for (let i of e.props)
+        if (Array.isArray(i) || (i = i(s)), i) {
+          if (i[0].perNode)
+            throw new RangeError("Can't store a per-node prop on a node type");
+          o[i[0].id] = i[1];
+        }
+    }
+    return s;
+  }
+  /**
+  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 o = this.prop(l.group);
+      return o ? o.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 o = /* @__PURE__ */ Object.create(null);
+    for (let r in e)
+      for (let s of r.split(" "))
+        o[s] = e[r];
+    return (r) => {
+      for (let s = r.prop(l.group), i = -1; i < (s ? s.length : 0); i++) {
+        let c = o[i < 0 ? r.name : s[i]];
+        if (c)
+          return c;
+      }
+    };
+  }
+}
+x.none = new x(
+  "",
+  /* @__PURE__ */ Object.create(null),
+  0,
+  8
+  /* NodeFlag.Anonymous */
+);
+var K;
+(function(t) {
+  t[t.ExcludeBuffers = 1] = "ExcludeBuffers", t[t.IncludeAnonymous = 2] = "IncludeAnonymous", t[t.IgnoreMounts = 4] = "IgnoreMounts", t[t.IgnoreOverlays = 8] = "IgnoreOverlays";
+})(K || (K = {}));
+new l({ perNode: !0 });
+let Te = 0;
+class f {
+  /**
+  @internal
+  */
+  constructor(e, o, r) {
+    this.set = e, this.base = o, this.modified = r, this.id = Te++;
+  }
+  /**
+  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 o = new f([], null, []);
+    if (o.set.push(o), e)
+      for (let r of e.set)
+        o.set.push(r);
+    return o;
+  }
+  /**
+  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 T();
+    return (o) => o.modified.indexOf(e) > -1 ? o : T.get(o.base || o, o.modified.concat(e).sort((r, s) => r.id - s.id));
+  }
+}
+let Be = 0;
+class T {
+  constructor() {
+    this.instances = [], this.id = Be++;
+  }
+  static get(e, o) {
+    if (!o.length)
+      return e;
+    let r = o[0].instances.find((d) => d.base == e && Se(o, d.modified));
+    if (r)
+      return r;
+    let s = [], i = new f(s, e, o);
+    for (let d of o)
+      d.instances.push(i);
+    let c = He(o);
+    for (let d of e.set)
+      if (!d.modified.length)
+        for (let _ of c)
+          s.push(T.get(d, _));
+    return i;
+  }
+}
+function Se(t, e) {
+  return t.length == e.length && t.every((o, r) => o == e[r]);
+}
+function He(t) {
+  let e = [[]];
+  for (let o = 0; o < t.length; o++)
+    for (let r = 0, s = e.length; r < s; r++)
+      e.push(e[r].concat(t[o]));
+  return e.sort((o, r) => r.length - o.length);
+}
+new l();
+function Me(t, e) {
+  let o = /* @__PURE__ */ Object.create(null);
+  for (let i of t)
+    if (!Array.isArray(i.tag))
+      o[i.tag.id] = i.class;
+    else
+      for (let c of i.tag)
+        o[c.id] = i.class;
+  let { scope: r, all: s = null } = {};
+  return {
+    style: (i) => {
+      let c = s;
+      for (let d of i)
+        for (let _ of d.set) {
+          let N = o[_.id];
+          if (N) {
+            c = c ? c + " " + N : N;
+            break;
+          }
+        }
+      return c;
+    },
+    scope: r
+  };
+}
+const a = f.define, A = a(), m = a(), U = a(m), F = a(m), h = a(), O = a(h), R = a(h), p = a(), v = a(p), g = a(), u = a(), V = a(), w = a(V), I = a(), n = {
+  /**
+  A comment.
+  */
+  comment: A,
+  /**
+  A line [comment](#highlight.tags.comment).
+  */
+  lineComment: a(A),
+  /**
+  A block [comment](#highlight.tags.comment).
+  */
+  blockComment: a(A),
+  /**
+  A documentation [comment](#highlight.tags.comment).
+  */
+  docComment: a(A),
+  /**
+  Any kind of identifier.
+  */
+  name: m,
+  /**
+  The [name](#highlight.tags.name) of a variable.
+  */
+  variableName: a(m),
+  /**
+  A type [name](#highlight.tags.name).
+  */
+  typeName: U,
+  /**
+  A tag name (subtag of [`typeName`](#highlight.tags.typeName)).
+  */
+  tagName: a(U),
+  /**
+  A property or field [name](#highlight.tags.name).
+  */
+  propertyName: F,
+  /**
+  An attribute name (subtag of [`propertyName`](#highlight.tags.propertyName)).
+  */
+  attributeName: a(F),
+  /**
+  The [name](#highlight.tags.name) of a class.
+  */
+  className: a(m),
+  /**
+  A label [name](#highlight.tags.name).
+  */
+  labelName: a(m),
+  /**
+  A namespace [name](#highlight.tags.name).
+  */
+  namespace: a(m),
+  /**
+  The [name](#highlight.tags.name) of a macro.
+  */
+  macroName: a(m),
+  /**
+  A literal value.
+  */
+  literal: h,
+  /**
+  A string [literal](#highlight.tags.literal).
+  */
+  string: O,
+  /**
+  A documentation [string](#highlight.tags.string).
+  */
+  docString: a(O),
+  /**
+  A character literal (subtag of [string](#highlight.tags.string)).
+  */
+  character: a(O),
+  /**
+  An attribute value (subtag of [string](#highlight.tags.string)).
+  */
+  attributeValue: a(O),
+  /**
+  A number [literal](#highlight.tags.literal).
+  */
+  number: R,
+  /**
+  An integer [number](#highlight.tags.number) literal.
+  */
+  integer: a(R),
+  /**
+  A floating-point [number](#highlight.tags.number) literal.
+  */
+  float: a(R),
+  /**
+  A boolean [literal](#highlight.tags.literal).
+  */
+  bool: a(h),
+  /**
+  Regular expression [literal](#highlight.tags.literal).
+  */
+  regexp: a(h),
+  /**
+  An escape [literal](#highlight.tags.literal), for example a
+  backslash escape in a string.
+  */
+  escape: a(h),
+  /**
+  A color [literal](#highlight.tags.literal).
+  */
+  color: a(h),
+  /**
+  A URL [literal](#highlight.tags.literal).
+  */
+  url: a(h),
+  /**
+  A language keyword.
+  */
+  keyword: g,
+  /**
+  The [keyword](#highlight.tags.keyword) for the self or this
+  object.
+  */
+  self: a(g),
+  /**
+  The [keyword](#highlight.tags.keyword) for null.
+  */
+  null: a(g),
+  /**
+  A [keyword](#highlight.tags.keyword) denoting some atomic value.
+  */
+  atom: a(g),
+  /**
+  A [keyword](#highlight.tags.keyword) that represents a unit.
+  */
+  unit: a(g),
+  /**
+  A modifier [keyword](#highlight.tags.keyword).
+  */
+  modifier: a(g),
+  /**
+  A [keyword](#highlight.tags.keyword) that acts as an operator.
+  */
+  operatorKeyword: a(g),
+  /**
+  A control-flow related [keyword](#highlight.tags.keyword).
+  */
+  controlKeyword: a(g),
+  /**
+  A [keyword](#highlight.tags.keyword) that defines something.
+  */
+  definitionKeyword: a(g),
+  /**
+  A [keyword](#highlight.tags.keyword) related to defining or
+  interfacing with modules.
+  */
+  moduleKeyword: a(g),
+  /**
+  An operator.
+  */
+  operator: u,
+  /**
+  An [operator](#highlight.tags.operator) that dereferences something.
+  */
+  derefOperator: a(u),
+  /**
+  Arithmetic-related [operator](#highlight.tags.operator).
+  */
+  arithmeticOperator: a(u),
+  /**
+  Logical [operator](#highlight.tags.operator).
+  */
+  logicOperator: a(u),
+  /**
+  Bit [operator](#highlight.tags.operator).
+  */
+  bitwiseOperator: a(u),
+  /**
+  Comparison [operator](#highlight.tags.operator).
+  */
+  compareOperator: a(u),
+  /**
+  [Operator](#highlight.tags.operator) that updates its operand.
+  */
+  updateOperator: a(u),
+  /**
+  [Operator](#highlight.tags.operator) that defines something.
+  */
+  definitionOperator: a(u),
+  /**
+  Type-related [operator](#highlight.tags.operator).
+  */
+  typeOperator: a(u),
+  /**
+  Control-flow [operator](#highlight.tags.operator).
+  */
+  controlOperator: a(u),
+  /**
+  Program or markup punctuation.
+  */
+  punctuation: V,
+  /**
+  [Punctuation](#highlight.tags.punctuation) that separates
+  things.
+  */
+  separator: a(V),
+  /**
+  Bracket-style [punctuation](#highlight.tags.punctuation).
+  */
+  bracket: w,
+  /**
+  Angle [brackets](#highlight.tags.bracket) (usually `<` and `>`
+  tokens).
+  */
+  angleBracket: a(w),
+  /**
+  Square [brackets](#highlight.tags.bracket) (usually `[` and `]`
+  tokens).
+  */
+  squareBracket: a(w),
+  /**
+  Parentheses (usually `(` and `)` tokens). Subtag of
+  [bracket](#highlight.tags.bracket).
+  */
+  paren: a(w),
+  /**
+  Braces (usually `{` and `}` tokens). Subtag of
+  [bracket](#highlight.tags.bracket).
+  */
+  brace: a(w),
+  /**
+  Content, for example plain text in XML or markup documents.
+  */
+  content: p,
+  /**
+  [Content](#highlight.tags.content) that represents a heading.
+  */
+  heading: v,
+  /**
+  A level 1 [heading](#highlight.tags.heading).
+  */
+  heading1: a(v),
+  /**
+  A level 2 [heading](#highlight.tags.heading).
+  */
+  heading2: a(v),
+  /**
+  A level 3 [heading](#highlight.tags.heading).
+  */
+  heading3: a(v),
+  /**
+  A level 4 [heading](#highlight.tags.heading).
+  */
+  heading4: a(v),
+  /**
+  A level 5 [heading](#highlight.tags.heading).
+  */
+  heading5: a(v),
+  /**
+  A level 6 [heading](#highlight.tags.heading).
+  */
+  heading6: a(v),
+  /**
+  A prose separator (such as a horizontal rule).
+  */
+  contentSeparator: a(p),
+  /**
+  [Content](#highlight.tags.content) that represents a list.
+  */
+  list: a(p),
+  /**
+  [Content](#highlight.tags.content) that represents a quote.
+  */
+  quote: a(p),
+  /**
+  [Content](#highlight.tags.content) that is emphasized.
+  */
+  emphasis: a(p),
+  /**
+  [Content](#highlight.tags.content) that is styled strong.
+  */
+  strong: a(p),
+  /**
+  [Content](#highlight.tags.content) that is part of a link.
+  */
+  link: a(p),
+  /**
+  [Content](#highlight.tags.content) that is styled as code or
+  monospace.
+  */
+  monospace: a(p),
+  /**
+  [Content](#highlight.tags.content) that has a strike-through
+  style.
+  */
+  strikethrough: a(p),
+  /**
+  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: I,
+  /**
+  [Metadata](#highlight.tags.meta) that applies to the entire
+  document.
+  */
+  documentMeta: a(I),
+  /**
+  [Metadata](#highlight.tags.meta) that annotates or adds
+  attributes to a given syntactic element.
+  */
+  annotation: a(I),
+  /**
+  Processing instruction or preprocessor directive. Subtag of
+  [meta](#highlight.tags.meta).
+  */
+  processingInstruction: a(I),
+  /**
+  [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: f.defineModifier(),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates that
+  something is constant. Mostly expected to be used with
+  [variable names](#highlight.tags.variableName).
+  */
+  constant: f.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: f.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: f.defineModifier(),
+  /**
+  [Modifier](#highlight.Tag^defineModifier) that indicates a given
+  [names](#highlight.tags.name) is local to some scope.
+  */
+  local: f.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: f.defineModifier()
+};
+Me([
+  { tag: n.link, class: "tok-link" },
+  { tag: n.heading, class: "tok-heading" },
+  { tag: n.emphasis, class: "tok-emphasis" },
+  { tag: n.strong, class: "tok-strong" },
+  { tag: n.keyword, class: "tok-keyword" },
+  { tag: n.atom, class: "tok-atom" },
+  { tag: n.bool, class: "tok-bool" },
+  { tag: n.url, class: "tok-url" },
+  { tag: n.labelName, class: "tok-labelName" },
+  { tag: n.inserted, class: "tok-inserted" },
+  { tag: n.deleted, class: "tok-deleted" },
+  { tag: n.literal, class: "tok-literal" },
+  { tag: n.string, class: "tok-string" },
+  { tag: n.number, class: "tok-number" },
+  { tag: [n.regexp, n.escape, n.special(n.string)], class: "tok-string2" },
+  { tag: n.variableName, class: "tok-variableName" },
+  { tag: n.local(n.variableName), class: "tok-variableName tok-local" },
+  { tag: n.definition(n.variableName), class: "tok-variableName tok-definition" },
+  { tag: n.special(n.variableName), class: "tok-variableName2" },
+  { tag: n.definition(n.propertyName), class: "tok-propertyName tok-definition" },
+  { tag: n.typeName, class: "tok-typeName" },
+  { tag: n.namespace, class: "tok-namespace" },
+  { tag: n.className, class: "tok-className" },
+  { tag: n.macroName, class: "tok-macroName" },
+  { tag: n.propertyName, class: "tok-propertyName" },
+  { tag: n.operator, class: "tok-operator" },
+  { tag: n.comment, class: "tok-comment" },
+  { tag: n.meta, class: "tok-meta" },
+  { tag: n.invalid, class: "tok-invalid" },
+  { tag: n.punctuation, class: "tok-punctuation" }
+]);
+const je = "#c72727", Re = "#9b5700", Ve = "#067934", $e = "#0063d7", ze = {
+  red: je,
+  orange: Re,
+  green: Ve,
+  blue: $e,
+  invalid: "#ffffff"
+}, De = (t) => me.define([
+  {
+    tag: n.keyword,
+    color: t.red
+  },
+  {
+    tag: [n.name, n.deleted, n.character, n.propertyName, n.macroName],
+    color: t.green
+  },
+  {
+    tag: [n.function(n.variableName), n.labelName],
+    color: t.blue
+  },
+  {
+    tag: [n.color, n.constant(n.name), n.standard(n.name)],
+    color: t.red
+  },
+  {
+    tag: [n.definition(n.name), n.separator],
+    color: t.red
+  },
+  {
+    tag: [n.typeName, n.className, n.number, n.changed, n.annotation, n.modifier, n.self, n.namespace],
+    color: t.orange
+  },
+  {
+    tag: [n.operator, n.operatorKeyword, n.url, n.escape, n.regexp, n.link, n.special(n.string)],
+    color: t.blue
+  },
+  {
+    tag: [n.meta, n.comment],
+    color: t.orange
+  },
+  {
+    tag: n.strong,
+    fontWeight: "bold"
+  },
+  {
+    tag: n.emphasis,
+    fontStyle: "italic"
+  },
+  {
+    tag: n.strikethrough,
+    textDecoration: "line-through"
+  },
+  {
+    tag: n.link,
+    color: t.orange,
+    textDecoration: "underline"
+  },
+  {
+    tag: n.heading,
+    fontWeight: "bold",
+    color: t.blue
+  },
+  {
+    tag: [n.atom, n.bool, n.special(n.variableName)],
+    color: t.red
+  },
+  {
+    tag: [n.processingInstruction, n.string, n.inserted],
+    color: t.blue
+  },
+  {
+    tag: n.invalid,
+    color: t.invalid
+  }
+]), Pe = fe(De(ze));
+var E = /* @__PURE__ */ ((t) => (t.INLINE = "inline", t.SINGLELINE = "singleline", t.MULTILINE = "multiline", t))(E || {}), b = /* @__PURE__ */ ((t) => (t.JSON = "json", t.XML = "xml", t.JAVA = "java", t.JAVASCRIPT = "javascript", t.PYTHON = "python", t))(b || {}), C = /* @__PURE__ */ ((t) => (t.ACTION = "action", t.CHANGE = "change", t))(C || {});
+const Je = {
+  [b.JSON]: we,
+  [b.XML]: Ce,
+  [b.JAVASCRIPT]: xe,
+  [b.JAVA]: Le,
+  [b.PYTHON]: Ae
+}, Ge = (t) => async () => Je[t], Ke = (t, e) => {
+  const o = t.doc.lineAt(e.from), r = /^\s*/.exec(o.text);
+  return r ? r[0] : "";
+}, Ue = {
+  key: "Enter",
+  run: ({ state: t, dispatch: e }) => {
+    const o = t.changeByRange((r) => {
+      const i = `
+${Ke(t, r)}`;
+      return {
+        changes: { from: r.from, to: r.to, insert: i },
+        range: ge.cursor(r.from + i.length)
+      };
+    });
+    return e(t.update(o, { scrollIntoView: !0, userEvent: "input" })), !0;
+  }
+};
+let W = 0;
+const Fe = {
+  beforeCreate() {
+    this.uuid = W.toString(), W += 1;
+  }
+};
+var We = function() {
+  var e = this, o = e._self._c;
+  return o("svg", e._b({ staticClass: "ui-assets-icons-16", attrs: { role: "img", xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "none" } }, "svg", e.$attrs, !1), [e.$attrs["svg-title"] ? o("title", [e._v(e._s(e.$attrs["svg-title"]))]) : e._e(), o("path", { attrs: { fill: "#00112C", d: "M14.75 1.25V6.75H13.25V3.81083L10.0001 7.06072L8.93945 6.00006L12.1895 2.75H9.25V1.25H14.75Z" } }), o("path", { attrs: { fill: "#00112C", d: "M2.75 12.1895V9.25H1.25V14.75H6.75V13.25H3.81083L7.06072 10.0001L6.00006 8.93945L2.75 12.1895Z" } })]);
+}, qe = [], Xe = /* @__PURE__ */ q(
+  Fe,
+  We,
+  qe,
+  !1,
+  null,
+  null
+);
+const Ye = Xe.exports, Ze = {
+  "en-US": {
+    run: "Run",
+    expand: "Expand"
+  }
+}, Qe = oe({
+  i18n: { messages: Ze },
+  name: "bento-code-snippet",
+  components: {
+    BentoTypography: ye,
+    BentoButton: be,
+    BentoDropdown: he,
+    Copy: ke,
+    BaseModal: Ne,
+    BentoLoadingIndicator: ve,
+    ExpandIcon: Ye
+  },
+  directives: { BentoTooltipDirective: Oe },
+  props: {
+    /**
+     * Defines the variant of code-snippet
+     */
+    variant: {
+      type: String,
+      default: E.MULTILINE,
+      validator: (t) => Object.values(E).includes(t)
+    },
+    /**
+     * Language name for syntax highlighting rules
+     */
+    lang: {
+      type: String,
+      default: b.JSON,
+      validator: (t) => Object.values(b).includes(t)
+    },
+    /**
+     * 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: [C.ACTION, C.CHANGE],
+  setup(t, { emit: e }) {
+    const { t: o } = _e(), r = L(null), s = [], i = () => {
+    }, c = k(() => t.langLabel ?? t.lang.toUpperCase()), d = k(() => t.variant === E.INLINE), _ = k(() => ({
+      "b-code-snippet--inline": d.value,
+      "b-code-snippet--scrollable": !d.value
+    })), N = k(() => ({
+      "b-code-snippet__code-area-content--editable": t.editable
+    })), X = Ge(t.lang), $ = P(), B = P(), Y = new j(), Z = new j(), Q = new j(), y = L(null), S = L(0);
+    re(async () => {
+      const H = await X();
+      y.value = t.content;
+      const ae = ({ state: M }) => {
+        y.value = M.doc.toString();
+      }, z = [
+        le(),
+        ce.of([ue, Ue]),
+        Y.of(H()),
+        Z.of(Pe),
+        Q.of(G.readOnly.of(!t.editable)),
+        J.updateListener.of((M) => ae(M))
+      ];
+      t.variant === "multiline" && z.push([de(), pe()]);
+      const D = G.create({
+        doc: t.content,
+        extensions: [...z]
+      });
+      S.value = D.doc.length, B.value = new J({
+        state: D,
+        parent: $.value
+      });
+    }), ie(
+      () => t.content,
+      () => {
+        if (t.content !== y.value) {
+          const H = t.content.length;
+          B.value.dispatch({
+            changes: {
+              from: 0,
+              to: S.value,
+              insert: t.content
+            }
+          }), S.value = H;
+        }
+      }
+    );
+    const ee = k(() => o(t.actionableText)), te = () => {
+      e(C.ACTION, y.value);
+    };
+    se(() => {
+      y.value !== null && e(C.CHANGE, y.value);
+    });
+    const ne = L(!1);
+    return {
+      // Values
+      availableLanguages: s,
+      codeAreaContentConditionalClasses: N,
+      conditionalClasses: _,
+      container: $,
+      currentContents: y,
+      displayedLang: c,
+      editor: B,
+      selectedLanguage: r,
+      showModal: ne,
+      isInlineVariant: d,
+      // Methods
+      handleChangeLanguage: i,
+      onActionClicked: te,
+      runText: ee,
+      // Translations
+      t: o
+    };
+  }
+});
+var et = function() {
+  var e = this, o = e._self._c;
+  return e._self._setupProxy, o("div", { staticClass: "b-code-snippet", class: e.conditionalClasses }, [e.isInlineVariant ? e._e() : o("section", { staticClass: "b-code-snippet__action-bar" }, [o("div", { staticClass: "b-code-snippet__action-bar--start" }, [e.availableLanguages.length > 0 ? o("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(r) {
+    e.selectedLanguage = r;
+  }, expression: "selectedLanguage" } }, "bento-dropdown", e.$props, !1)) : e._e(), o("bento-typography", { attrs: { el: "span", stronger: "" } }, [e._v(" " + e._s(e.displayedLang) + " ")])], 1), o("div", { staticClass: "b-code-snippet__action-bar--end" }, [e.loading ? o("bento-loading-indicator") : e._e(), e.currentContents !== null ? o("copy", { staticClass: "b-structured-list__icon", attrs: { text: e.currentContents } }) : e._e(), e.expandable ? o("bento-button", { attrs: { variant: "tertiary", condensed: "", "aria-label": e.t("expand") }, on: { click: function(r) {
+    e.showModal = !0;
+  } }, scopedSlots: e._u([{ key: "iconLeft", fn: function() {
+    return [o("expand-icon")];
+  }, proxy: !0 }], null, !1, 3789760120) }) : e._e(), e.actionable ? o("bento-button", { attrs: { variant: "primary", tertiary: "", condensed: "" }, on: { click: e.onActionClicked }, scopedSlots: e._u([{ key: "iconLeft", fn: function() {
+    return [o("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 ? o("code", { staticClass: "b-code-snippet__code-area" }, [o("div", { ref: "container", staticClass: "b-code-snippet__code-area-content", class: e.codeAreaContentConditionalClasses })]) : o("section", [e._t("empty-state", function() {
+    return [o("div", { staticClass: "b-code-snippet__empty-state" }, [e._v("Nothing to show")])];
+  })], 2), e.expandable ? o("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(r) {
+    e.showModal = !1;
+  } }, scopedSlots: e._u([{ key: "content", fn: function() {
+    return [o("bento-code-snippet", e._b({}, "bento-code-snippet", { ...e.$props, expandable: !1 }, !1))];
+  }, proxy: !0 }], null, !1, 3343589027) }) : e._e()], 1);
+}, tt = [], nt = /* @__PURE__ */ q(
+  Qe,
+  et,
+  tt,
+  !1,
+  null,
+  "befa6cc9"
+);
+const kt = nt.exports;
+export {
+  E as B,
+  b as a,
+  C as b,
+  kt as c
+};
+//# sourceMappingURL=code-snippet.C4IbjAhH.js.map