@dialpad/dialtone-vue 3.93.1 → 3.94.0

package/dist/message_input-104c4579.js

@@ -0,0 +1,3619 @@
+import { NodeViewWrapper as oe, nodeViewProps as ie, VueRenderer as ae, VueNodeViewRenderer as re, EditorContent as ke, Editor as Ie } from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/vue-3/dist/index.js";
+import we from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-code-block/dist/index.js";
+import Oe from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-document/dist/index.js";
+import Te from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-hard-break/dist/index.js";
+import Ae from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-paragraph/dist/index.js";
+import Pe from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-placeholder/dist/index.js";
+import Le from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-text/dist/index.js";
+import { Node as je, mergeAttributes as K, nodeInputRule as U, nodePasteRule as G, getMarksBetween as De, combineTransactionSteps as xe, getChangedRanges as Re, findChildrenInRange as Fe, Mark as Ne } from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/core/dist/index.js";
+import { D as A, y as Be, b as N, L as Ve, j as Me, g as le, a5 as He, a0 as qe, a3 as de, _ as Ke, f as ze } from "./emoji-fa0ee549.js";
+import { openBlock as a, createElementBlock as p, toDisplayString as E, createCommentVNode as g, createElementVNode as S, normalizeClass as _, resolveComponent as d, createBlock as h, resolveDynamicComponent as O, withCtx as u, mergeProps as L, renderSlot as f, createVNode as m, createTextVNode as R, withKeys as w, withModifiers as P, toHandlers as ce, createSlots as $e, renderList as ue, Teleport as We, withDirectives as Ue, Fragment as me, vShow as Ge, markRaw as pe, normalizeStyle as Ye } from "vue";
+import { _ as v, g as H, p as Ze, h as B, u as Xe, q as Je, d as Qe, r as et, t as tt, v as nt, w as st, x as ot, D as it } from "./tooltip-0cdd1500.js";
+import { PluginKey as fe, Plugin as at } from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/pm/state/dist/index.js";
+import rt from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/suggestion/dist/index.js";
+import "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/emoji-regex/index.mjs";
+import he from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/tippy.js/dist/tippy.esm.js";
+import lt from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@tiptap/extension-mention/dist/index.js";
+import dt from "/home/runner/work/dialtone-vue/dialtone-vue/node_modules/@dialpad/dialtone-icons/dist/icons.json";
+const D = {
+  BUSY: "busy",
+  AWAY: "away",
+  OFFLINE: "offline",
+  ACTIVE: "active"
+}, ct = [
+  D.BUSY,
+  D.AWAY,
+  D.OFFLINE,
+  D.ACTIVE
+], ut = {
+  name: "DtPresence",
+  props: {
+    /**
+     * Determines the color of the inner presence circle, indicating status.
+     * Accepts one of 4 values: 'busy', 'away', 'active', 'offline'
+     * @values busy, away, active, offline
+     */
+    presence: {
+      type: String,
+      default: D.ACTIVE,
+      validator: (e) => ct.includes(e)
+    },
+    /**
+     * Since Presence is a visual element, we need SRs to read out any state changes
+     * that occur.
+     * Text entered here will be read by assistive technology. If null this component will be ignored by AT.
+     */
+    srText: {
+      type: String,
+      default: null
+    }
+  }
+}, mt = ["aria-live"], pt = {
+  key: 0,
+  "data-qa": "dt-presence-sr-text",
+  class: "sr-only"
+};
+function ft(e, t, n, i, o, s) {
+  return a(), p("div", {
+    class: "d-presence",
+    "data-qa": "dt-presence",
+    role: "status",
+    "aria-live": e.$attrs.ariaLive || "off"
+  }, [
+    n.srText ? (a(), p("span", pt, E(n.srText), 1)) : g("", !0),
+    S("div", {
+      class: _(["d-presence__inner", {
+        "d-presence__inner--active": n.presence === "active",
+        "d-presence__inner--away": n.presence === "away",
+        "d-presence__inner--busy": n.presence === "busy",
+        "d-presence__inner--offline": n.presence === "offline"
+      }])
+    }, null, 2)
+  ], 8, mt);
+}
+const ht = /* @__PURE__ */ v(ut, [["render", ft]]), V = {
+  xs: "d-avatar--xs",
+  sm: "d-avatar--sm",
+  md: "d-avatar--md",
+  lg: "d-avatar--lg",
+  xl: "d-avatar--xl"
+}, gt = {
+  default: "",
+  icon: "d-avatar__icon",
+  initials: "d-avatar__initials"
+}, yt = {
+  md: "d-avatar__presence--md",
+  lg: "d-avatar__presence--lg"
+}, Y = {
+  NONE: "",
+  BUSY: "busy",
+  AWAY: "away",
+  OFFLINE: "offline",
+  ACTIVE: "active"
+}, _t = {
+  xs: "100",
+  sm: "200",
+  md: "300",
+  lg: "500",
+  xl: "600"
+}, vt = [
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900",
+  "1000",
+  "1100",
+  "1200",
+  "1300",
+  "1400",
+  "1500",
+  "1600",
+  "1700",
+  "1800"
+], Z = (e) => e > 1;
+function bt() {
+  return [void 0, ...dt];
+}
+const St = (e) => {
+  if (typeof e != "string" || !e.trim())
+    return "";
+  const t = e.trim().split(/\s+/g);
+  return t.length === 1 ? t.join("").substring(0, 2) : t.filter((n, i) => i === 0 || i === t.length - 1).map((n) => n.slice(0, 1).toUpperCase()).join("");
+};
+const Et = bt(), Ct = {
+  name: "DtAvatar",
+  components: { DtPresence: ht, DtIcon: A },
+  inheritAttrs: !1,
+  props: {
+    /**
+     * Id of the avatar content wrapper element
+     */
+    id: {
+      type: String,
+      default() {
+        return H();
+      }
+    },
+    /**
+     * Pass in a seed to get the random color generation based on that string. For example if you pass in a
+     * user ID as the string it will return the same randomly generated colors every time for that user.
+     */
+    seed: {
+      type: String,
+      default: void 0
+    },
+    /**
+     * Set the avatar background to a specific color. If undefined will randomize the color which can be deterministic
+     * if the seed prop is set.
+     */
+    color: {
+      type: String,
+      default: void 0
+    },
+    /**
+     * The size of the avatar
+     * @values xs, sm, md, lg, xl
+     */
+    size: {
+      type: String,
+      default: "md",
+      validator: (e) => Object.keys(V).includes(e)
+    },
+    /**
+     * Used to customize the avatar container
+     */
+    avatarClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Set classes on the avatar canvas. Wrapper around the core avatar image.
+     */
+    canvasClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Pass through classes. Used to customize the avatar icon
+     */
+    iconClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Determines whether to show the presence indicator for
+     * Avatar - accepts PRESENCE_STATES values: 'busy', 'away', 'offline',
+     * or 'active'. By default, it's null and nothing is shown.
+     * @values null, busy, away, offline, active
+     */
+    presence: {
+      type: String,
+      default: Y.NONE,
+      validator: (e) => Object.values(Y).includes(e)
+    },
+    /**
+     * A set of props to be passed into the presence component.
+     */
+    presenceProps: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Determines whether to show a group avatar.
+     * Limit to 2 digits max, more than 99 will be rendered as “99+”.
+     * if the number is 1 or less it would just show the regular avatar as if group had not been set.
+     */
+    group: {
+      type: Number,
+      default: void 0,
+      validator: (e) => Z(e)
+    },
+    /**
+     * The icon that overlays the avatar
+     */
+    overlayIcon: {
+      type: String,
+      default: ""
+    },
+    /**
+     * The text that overlays the avatar
+     */
+    overlayText: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Used to customize the avatar overlay
+     */
+    overlayClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Source of the image
+     */
+    imageSrc: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Alt attribute of the image, by default
+     * it'd be the full name
+     */
+    imageAlt: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Icon name to be displayed on the avatar
+     */
+    iconName: {
+      type: String,
+      default: void 0,
+      validator: (e) => Et.includes(e)
+    },
+    /**
+     * Icon size to be displayed on the avatar
+     * @values 100, 200, 300, 400, 500, 600, 700, 800
+     */
+    iconSize: {
+      type: String,
+      default: "",
+      validator: (e) => !e || Object.keys(Be).includes(e)
+    },
+    /**
+     * Full name used to extract initials and set alt attribute.
+     */
+    fullName: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Makes the avatar focusable and clickable,
+     * emits a click event when clicked.
+     */
+    clickable: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    /**
+     * Avatar click event
+     *
+     * @event click
+     * @type {PointerEvent | KeyboardEvent}
+     */
+    "click"
+  ],
+  data() {
+    return {
+      AVATAR_SIZE_MODIFIERS: V,
+      AVATAR_KIND_MODIFIERS: gt,
+      AVATAR_PRESENCE_SIZE_MODIFIERS: yt,
+      AVATAR_ICON_SIZES: _t,
+      imageLoadedSuccessfully: null,
+      formattedInitials: "",
+      initializing: !1
+    };
+  },
+  computed: {
+    isNotIconType() {
+      return !this.iconName;
+    },
+    avatarClasses() {
+      return [
+        "d-avatar",
+        V[this.validatedSize],
+        this.avatarClass,
+        {
+          "d-avatar--group": this.showGroup,
+          [`d-avatar--color-${this.getColor()}`]: this.isNotIconType,
+          "d-avatar--clickable": this.clickable
+        }
+      ];
+    },
+    overlayClasses() {
+      return [
+        "d-avatar__overlay",
+        this.overlayClass
+      ];
+    },
+    showGroup() {
+      return Z(this.group);
+    },
+    formattedGroup() {
+      return this.group > 99 ? "99+" : this.group;
+    },
+    validatedSize() {
+      return this.group ? "xs" : this.size;
+    },
+    showImage() {
+      return this.imageLoadedSuccessfully !== !1 && this.imageSrc;
+    },
+    buttonAriaLabel() {
+      if (this.clickable)
+        return this.fullName || this.imageAlt || this.$attrs["aria-label"];
+    }
+  },
+  watch: {
+    fullName: {
+      immediate: !0,
+      handler(e) {
+        this.formatInitials(e);
+      }
+    },
+    imageSrc(e) {
+      this.imageLoadedSuccessfully = null, e && (this.validateProps(), this.setImageListeners());
+    }
+  },
+  mounted() {
+    this.validateProps(), this.setImageListeners();
+  },
+  methods: {
+    async setImageListeners() {
+      await this.$nextTick();
+      const e = this.$refs.avatarImage;
+      e && (e.addEventListener("load", () => this._loadedImageEventHandler(e), { once: !0 }), e.addEventListener("error", () => this._erroredImageEventHandler(e), { once: !0 }));
+    },
+    formatInitials(e) {
+      const t = St(e);
+      this.validatedSize === "xs" ? this.formattedInitials = "" : this.validatedSize === "sm" ? this.formattedInitials = t[0] : this.formattedInitials = t;
+    },
+    getColor() {
+      return this.color ?? Ze(vt, this.seed);
+    },
+    _loadedImageEventHandler(e) {
+      this.imageLoadedSuccessfully = !0, e.classList.remove("d-d-none");
+    },
+    _erroredImageEventHandler(e) {
+      this.imageLoadedSuccessfully = !1, e.classList.add("d-d-none");
+    },
+    validateProps() {
+      if (this.imageSrc && !(this.fullName || this.imageAlt))
+        throw new Error("full-name or image-alt must be set if image-src is provided");
+    },
+    handleClick(e) {
+      this.clickable && this.$emit("click", e);
+    }
+  }
+}, kt = ["src", "alt"], It = {
+  key: 1,
+  class: "d-avatar__overlay-text"
+}, wt = {
+  key: 1,
+  class: "d-avatar__count",
+  "data-qa": "dt-avatar-count"
+};
+function Ot(e, t, n, i, o, s) {
+  const r = d("dt-icon"), c = d("dt-presence");
+  return a(), h(O(n.clickable ? "button" : "div"), {
+    id: n.id,
+    class: _(s.avatarClasses),
+    "data-qa": "dt-avatar",
+    "aria-label": s.buttonAriaLabel,
+    onClick: s.handleClick
+  }, {
+    default: u(() => [
+      S("div", {
+        ref: "canvas",
+        class: _([
+          n.canvasClass,
+          "d-avatar__canvas",
+          { "d-avatar--image-loaded": o.imageLoadedSuccessfully }
+        ])
+      }, [
+        s.showImage ? (a(), p("img", {
+          key: 0,
+          ref: "avatarImage",
+          class: "d-avatar__image",
+          "data-qa": "dt-avatar-image",
+          src: n.imageSrc,
+          alt: n.imageAlt || n.fullName
+        }, null, 8, kt)) : n.iconName ? (a(), h(r, {
+          key: 1,
+          name: n.iconName,
+          size: n.iconSize || o.AVATAR_ICON_SIZES[n.size],
+          class: _([n.iconClass, o.AVATAR_KIND_MODIFIERS.icon]),
+          "data-qa": "dt-avatar-icon"
+        }, null, 8, ["name", "size", "class"])) : (a(), p("span", {
+          key: 2,
+          class: _([o.AVATAR_KIND_MODIFIERS.initials, "d-ps-absolute d-zi-base d-us-none"])
+        }, E(o.formattedInitials), 3))
+      ], 2),
+      n.overlayIcon || n.overlayText ? (a(), p("div", {
+        key: 0,
+        class: _(s.overlayClasses)
+      }, [
+        n.overlayIcon ? (a(), h(r, {
+          key: 0,
+          class: "d-avatar__overlay-icon",
+          name: n.overlayIcon
+        }, null, 8, ["name"])) : n.overlayText ? (a(), p("p", It, E(n.overlayText), 1)) : g("", !0)
+      ], 2)) : g("", !0),
+      s.showGroup ? (a(), p("span", wt, E(s.formattedGroup), 1)) : g("", !0),
+      n.presence && !s.showGroup ? (a(), h(c, L({
+        key: 2,
+        presence: n.presence,
+        class: [
+          "d-avatar__presence",
+          o.AVATAR_PRESENCE_SIZE_MODIFIERS[n.size]
+        ]
+      }, n.presenceProps, { "data-qa": "dt-presence" }), null, 16, ["presence", "class"])) : g("", !0)
+    ]),
+    _: 1
+  }, 8, ["id", "class", "aria-label", "onClick"]);
+}
+const Tt = /* @__PURE__ */ v(Ct, [["render", Ot]]), z = ["base", "error", "info", "success", "warning"], At = ["alert", "alertdialog", "status"], Pt = /* @__PURE__ */ new Map([
+  ["info", "info"],
+  ["success", "check-circle"],
+  ["warning", "alert-triangle"],
+  ["error", "alert-circle"],
+  ["base", "bell"]
+]), Lt = {
+  name: "DtNoticeIcon",
+  components: {
+    DtIcon: A
+  },
+  props: {
+    /**
+     * Kind of icon
+     * @values base, error, info, success, warning
+     */
+    kind: {
+      type: String,
+      default: "base",
+      validate(e) {
+        return z.includes(e);
+      }
+    }
+  },
+  data() {
+    return {
+      hasSlotContent: B
+    };
+  },
+  computed: {
+    defaultIcon() {
+      return Pt.get(this.kind);
+    }
+  }
+}, jt = {
+  key: 0,
+  "aria-hidden": "true",
+  class: "d-notice__icon"
+};
+function Dt(e, t, n, i, o, s) {
+  const r = d("dt-icon");
+  return s.defaultIcon || o.hasSlotContent(e.$slots.default) ? (a(), p("div", jt, [
+    f(e.$slots, "default", {}, () => [
+      m(r, {
+        name: s.defaultIcon,
+        size: "400"
+      }, null, 8, ["name"])
+    ])
+  ])) : g("", !0);
+}
+const xt = /* @__PURE__ */ v(Lt, [["render", Dt]]), Rt = {
+  name: "DtNoticeContent",
+  props: {
+    /**
+     * Title header of the notice. This can be left blank to remove the title from the notice entirely.
+     */
+    title: {
+      type: String,
+      default: ""
+    },
+    /**
+     * ID for the title element of the component. Useful for aria-describedby
+     * or aria-labelledby or any other reason you may need an id to refer to the title.
+     */
+    titleId: {
+      type: String,
+      default: void 0
+    },
+    /**
+     * ID for the content element of the component. Useful for aria-describedby
+     * or aria-labelledby or any other reason you may need an id to refer to the content.
+     */
+    contentId: {
+      type: String,
+      default: void 0
+    }
+  },
+  data() {
+    return {
+      hasSlotContent: B
+    };
+  }
+}, Ft = {
+  class: "d-notice__content",
+  "data-qa": "notice-content"
+}, Nt = ["id"], Bt = ["id"];
+function Vt(e, t, n, i, o, s) {
+  return a(), p("div", Ft, [
+    n.title || o.hasSlotContent(e.$slots.titleOverride) ? (a(), p("p", {
+      key: 0,
+      id: n.titleId,
+      class: "d-notice__title",
+      "data-qa": "notice-content-title"
+    }, [
+      f(e.$slots, "titleOverride", {}, () => [
+        R(E(n.title), 1)
+      ])
+    ], 8, Nt)) : g("", !0),
+    S("p", {
+      id: n.contentId,
+      class: "d-notice__message",
+      "data-qa": "notice-content-message"
+    }, [
+      f(e.$slots, "default")
+    ], 8, Bt)
+  ]);
+}
+const Mt = /* @__PURE__ */ v(Rt, [["render", Vt]]), $ = {
+  props: {
+    /**
+     * If true, a hidden close button is included for screen readers
+     * @values true, false
+     */
+    visuallyHiddenClose: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Label for the visually hidden close button
+     * Required if visuallyHiddenClose is set to `true`
+     */
+    visuallyHiddenCloseLabel: {
+      type: String,
+      default: null
+    }
+  },
+  watch: {
+    $props: {
+      immediate: !0,
+      deep: !0,
+      handler() {
+        this.validateVisuallyHiddenCloseProps();
+      }
+    }
+  },
+  computed: {
+    showVisuallyHiddenClose() {
+      return this.visuallyHiddenClose && this.visuallyHiddenCloseLabel != null;
+    }
+  },
+  methods: {
+    validateVisuallyHiddenCloseProps() {
+      this.visuallyHiddenClose && !this.visuallyHiddenCloseLabel && console.error(`If visuallyHiddenClose prop is true, the component includes
+           a visually hidden close button and you must set the visuallyHiddenCloseLabel prop.`);
+    }
+  }
+}, Ht = {
+  name: "SrOnlyCloseButton",
+  components: {
+    DtIcon: A,
+    DtButton: N
+  },
+  props: {
+    /**
+     * Label for the visually hidden close button
+     * Required if visuallyHiddenClose is set to `true`
+     */
+    visuallyHiddenCloseLabel: {
+      type: String,
+      default: null
+    }
+  },
+  emits: ["close"],
+  methods: {
+    close() {
+      this.$emit("close");
+    }
+  }
+};
+function qt(e, t, n, i, o, s) {
+  const r = d("dt-icon"), c = d("dt-button");
+  return a(), h(c, {
+    id: "sr-only-close-button",
+    "data-qa": "dt-sr-only-close-button",
+    class: "d-vi-visible-sr",
+    "aria-label": n.visuallyHiddenCloseLabel,
+    onClick: s.close,
+    onKeydown: w(P(s.close, ["prevent", "stop"]), ["space"])
+  }, {
+    default: u(() => [
+      m(r, { name: "close" })
+    ]),
+    _: 1
+  }, 8, ["aria-label", "onClick", "onKeydown"]);
+}
+const ge = /* @__PURE__ */ v(Ht, [["render", qt]]), Kt = {
+  name: "DtNoticeAction",
+  components: {
+    DtIcon: A,
+    DtButton: N,
+    SrOnlyCloseButton: ge
+  },
+  mixins: [$],
+  props: {
+    /**
+     * Props for the notice close button.
+     */
+    closeButtonProps: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Hides the close button from the notice
+     * @values true, false
+     */
+    hideClose: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    /**
+     * Close button click event
+     *
+     * @event close
+     */
+    "close"
+  ],
+  created() {
+    !this.hideClose && !this.closeButtonProps.ariaLabel && console.error("Invalid props: you must pass in closeButtonProps.ariaLabel if the close button is displayed.");
+  },
+  mounted() {
+    this.hideClose || (this.lastFocusedElement = document.activeElement);
+  },
+  beforeUnmount() {
+    var e;
+    (e = this.lastFocusedElement) == null || e.focus();
+  },
+  methods: {
+    close() {
+      this.$emit("close");
+    }
+  }
+}, zt = {
+  class: "d-notice__actions",
+  "data-qa": "notice-content-actions"
+};
+function $t(e, t, n, i, o, s) {
+  const r = d("dt-icon"), c = d("dt-button"), b = d("sr-only-close-button");
+  return a(), p("div", zt, [
+    f(e.$slots, "default"),
+    n.hideClose ? g("", !0) : (a(), h(c, L({
+      key: 0,
+      ref: "closeButton",
+      "data-qa": "dt-notice-action-close-button",
+      size: "sm",
+      importance: "clear",
+      circle: "",
+      "aria-label": n.closeButtonProps.ariaLabel ? n.closeButtonProps.ariaLabel : "Close"
+    }, n.closeButtonProps, { onClick: s.close }), {
+      icon: u(() => [
+        m(r, {
+          name: "close",
+          size: "200"
+        })
+      ]),
+      _: 1
+    }, 16, ["aria-label", "onClick"])),
+    e.showVisuallyHiddenClose ? (a(), h(b, {
+      key: 1,
+      "visually-hidden-close-label": e.visuallyHiddenCloseLabel,
+      onClose: s.close
+    }, null, 8, ["visually-hidden-close-label", "onClose"])) : g("", !0)
+  ]);
+}
+const Wt = /* @__PURE__ */ v(Kt, [["render", $t]]), ye = ':not(:disabled):not([aria-disabled="true"]):not([role="presentation"])', Ut = `${ye}:not([tabindex="-1"])`, Gt = "button,[href],input,select,textarea,details,[tabindex]", Yt = {
+  methods: {
+    /**
+     * get the first focusable element in your component, includes tabindex="-1".
+     * @param {object} el - optional - ref of dom element to trap focus on.
+     *  will default to the root node of the vue component
+     */
+    async getFirstFocusableElement(e) {
+      await this.$nextTick();
+      const t = this._getFocusableElements(e, !0);
+      return this._getFirstFocusElement(t);
+    },
+    /**
+     * set focus to the first focusable element in your component, includes tabindex="-1".
+     * @param {object} el - optional - ref of dom element to trap focus on.
+     *  will default to the root node of the vue component
+     */
+    async focusFirstElement(e) {
+      const t = await this.getFirstFocusableElement(e);
+      t == null || t.focus({ preventScroll: !0 });
+    },
+    /**
+     * internal use only.
+     *
+     * @param focusableElements - list of focusable elements
+     * @returns {*} - first DOM element that is focusable.
+     * @private
+     */
+    _getFirstFocusElement(e) {
+      if (!e.length)
+        return;
+      let t = e[0];
+      return t.matches('[type="radio"]:not(:checked)') && (t = e.find((n) => n.checked && n.name === t.name) || t), t;
+    },
+    /**
+     * internal use only.
+     *
+     * gets all the focusable elements within the component
+     * and sets the first and last of those elements.
+     *
+     * @param {object} el - the root dom element to find focusable elements in.
+     * @param {bool} includeNegativeTabIndex - will include tabindex="-1" in the list of focusable elements.
+     */
+    _getFocusableElements(e = this.$el, t = !1) {
+      return e ? [...e.querySelectorAll(Gt)].filter((i) => {
+        const o = window.getComputedStyle(i);
+        return o.getPropertyValue("display") !== "none" && o.getPropertyValue("visibility") !== "hidden" && i.matches(t ? ye : Ut);
+      }) : [];
+    },
+    /**
+     * tabs to the next element contained within your component, does not include tabindex="-1".
+     * @param {object} e - keypress event
+     * @param {object} el - optional - ref of dom element to trap focus on.
+     *  will default to the root node of the vue component
+     */
+    focusTrappedTabPress(e, t) {
+      if (!(e.key === "Tab"))
+        return;
+      const i = this._getFocusableElements(t);
+      if (!i.length) {
+        e.preventDefault();
+        return;
+      }
+      const o = this._getFirstFocusElement(i), s = i[i.length - 1];
+      e.shiftKey ? document.activeElement === o && (s.focus(), e.preventDefault()) : document.activeElement === s && (o.focus(), e.preventDefault());
+    }
+  }
+}, Zt = {
+  name: "DtLink",
+  props: {
+    /**
+     * Applies the link variant styles
+     * @values null, danger, warning, success, muted, inverted
+     */
+    kind: {
+      type: String,
+      default: "",
+      validator(e) {
+        return Ve.includes(e);
+      }
+    }
+  },
+  data() {
+    return {
+      LINK_KIND_MODIFIERS: Me
+    };
+  }
+}, Xt = ["href"];
+function Jt(e, t, n, i, o, s) {
+  return a(), p("a", {
+    class: _([
+      "d-link",
+      o.LINK_KIND_MODIFIERS[n.kind]
+    ]),
+    "data-qa": "dt-link",
+    href: "href" in e.$attrs ? e.$attrs.href : "javascript:void(0)"
+  }, [
+    f(e.$slots, "default")
+  ], 10, Xt);
+}
+const Qt = /* @__PURE__ */ v(Zt, [["render", Jt]]), M = {
+  DEFAULT: "default",
+  CUSTOM: "custom"
+}, F = {
+  ARROW_KEYS: "arrow-keys",
+  TAB: "tab",
+  NONE: "none"
+};
+const en = {
+  name: "DtItemLayout",
+  props: {
+    /**
+     * Set this prop to render layout as a specific HTML element.
+     */
+    as: {
+      type: String,
+      default: "div"
+    }
+  }
+}, tn = {
+  key: 0,
+  "data-qa": "dt-item-layout-left-wrapper",
+  class: "dt-item-layout--left"
+}, nn = {
+  "data-qa": "dt-item-layout-content-wrapper",
+  class: "dt-item-layout--content"
+}, sn = {
+  key: 0,
+  "data-qa": "dt-item-layout-title-wrapper",
+  class: "dt-item-layout--title"
+}, on = {
+  key: 2,
+  "data-qa": "dt-item-layout-bottom-wrapper",
+  class: "dt-item-layout--bottom"
+}, an = {
+  key: 1,
+  "data-qa": "dt-item-layout-right-wrapper",
+  class: "dt-item-layout--right"
+}, rn = {
+  key: 2,
+  "data-qa": "dt-item-layout-selected-wrapper",
+  class: "dt-item-layout--selected"
+};
+function ln(e, t, n, i, o, s) {
+  return a(), h(O(n.as), { class: "dt-item-layout" }, {
+    default: u(() => [
+      e.$slots.left ? (a(), p("section", tn, [
+        f(e.$slots, "left", {}, void 0, !0)
+      ])) : g("", !0),
+      S("section", nn, [
+        e.$slots.default ? (a(), p("div", sn, [
+          f(e.$slots, "default", {}, void 0, !0)
+        ])) : g("", !0),
+        e.$slots.subtitle ? (a(), p("div", {
+          key: 1,
+          "data-qa": "dt-item-layout-subtitle-wrapper",
+          class: _(["dt-item-layout--subtitle", { "d-mtn2": e.$slots.default }])
+        }, [
+          f(e.$slots, "subtitle", {}, void 0, !0)
+        ], 2)) : g("", !0),
+        e.$slots.bottom ? (a(), p("div", on, [
+          f(e.$slots, "bottom", {}, void 0, !0)
+        ])) : g("", !0)
+      ]),
+      e.$slots.right ? (a(), p("section", an, [
+        f(e.$slots, "right", {}, void 0, !0)
+      ])) : g("", !0),
+      e.$slots.selected ? (a(), p("section", rn, [
+        f(e.$slots, "selected", {}, void 0, !0)
+      ])) : g("", !0)
+    ]),
+    _: 3
+  });
+}
+const X = /* @__PURE__ */ v(en, [["render", ln], ["__scopeId", "data-v-9afad3c4"]]);
+const dn = {
+  name: "DtListItem",
+  components: {
+    DtItemLayout: X,
+    DtIcon: A
+  },
+  /**
+   * Value provided from keyboard_list_navigation.js using id prop.
+   */
+  inject: {
+    highlightId: { default: null }
+  },
+  props: {
+    /**
+     * Id for the item.
+     */
+    id: {
+      type: String,
+      default() {
+        return Xe.getUniqueString();
+      }
+    },
+    /**
+     * String to use for the item's role.
+     */
+    role: {
+      type: String,
+      default: "listitem"
+    },
+    /**
+     * HTML element type (tag name) of the content wrapper element.
+     */
+    elementType: {
+      type: String,
+      default: "li"
+    },
+    /**
+     * The type of child list item to use.
+     * @values default, custom
+     */
+    type: {
+      type: String,
+      default: M.DEFAULT,
+      validator: (e) => Object.values(M).includes(e)
+    },
+    /**
+     * The type of navigation that this component should support.
+     * - "arrow-keys" for items that are navigated with UP/DOWN keys.
+     * - "tab" for items that are navigated using the TAB key.
+     * - "none" for static items that are not interactive.
+     * @values arrow-keys, tab, none
+     */
+    navigationType: {
+      type: String,
+      default: F.NONE,
+      validator: (e) => Object.values(F).includes(e)
+    },
+    /**
+     * Applies selected styles to the list item
+     */
+    selected: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    /**
+     * Key down event
+     *
+     * @event keydown
+     * @type {KeyboardEvent}
+     */
+    "keydown",
+    /**
+     * Native mouse move event
+     *
+     * @event mousemove
+     * @type {MouseEvent}
+     */
+    "mousemove",
+    /**
+     * Native mouse leave event
+     *
+     * @event mouseleave
+     * @type {MouseEvent}
+     */
+    "mouseleave",
+    /**
+     * Mouse down event
+     *
+     * @event mousedown
+     */
+    "mousedown"
+  ],
+  data() {
+    return {
+      injected: !1,
+      mouseHighlighted: !1
+    };
+  },
+  computed: {
+    listItemType() {
+      switch (this.type) {
+        case M.DEFAULT:
+          return X;
+        default:
+          return null;
+      }
+    },
+    listItemListeners() {
+      return {
+        keydown: (e) => {
+          ["enter", "space"].includes(e.code.toLowerCase()) && this.onClick(e), this.$emit("keydown", e);
+        },
+        mousemove: (e) => {
+          this.onMouseHover(e), this.$emit("mousemove", e);
+        },
+        mouseleave: (e) => {
+          this.onMouseLeave(e), this.$emit("mouseleave", e);
+        }
+      };
+    },
+    /**
+     * For keyboard navigation, whether this item is currently highlighted.
+     * An injected highlightId will override the default mouseover highlight.
+     */
+    isHighlighted() {
+      return this.isHoverable ? this.highlightId && this.highlightId() ? this.id === this.highlightId() : this.mouseHighlighted : !1;
+    },
+    isFocusable() {
+      return this.navigationType === F.TAB;
+    },
+    /**
+     * Whether to apply hover styles.
+     */
+    isHoverable() {
+      return this.navigationType !== F.NONE;
+    }
+  },
+  methods: {
+    onClick(e) {
+      this.$emit("click", e);
+    },
+    onMouseHover() {
+      this.mouseHighlighted = !0;
+    },
+    onMouseLeave() {
+      this.mouseHighlighted = !1;
+    }
+  }
+};
+function cn(e, t, n, i, o, s) {
+  const r = d("dt-icon");
+  return a(), h(O(n.elementType), L({
+    id: n.id,
+    class: ["dt-list-item", {
+      "dt-list-item--focusable": s.isFocusable,
+      "dt-list-item--highlighted": s.isHighlighted,
+      "dt-list-item--static": !s.isHoverable
+    }],
+    tabindex: s.isFocusable ? 0 : -1,
+    role: n.role,
+    "aria-selected": s.isHighlighted
+  }, ce(s.listItemListeners)), {
+    default: u(() => [
+      s.listItemType ? (a(), h(O(s.listItemType), { key: 0 }, $e({ _: 2 }, [
+        ue(e.$slots, (c, b) => ({
+          name: b,
+          fn: u(() => [
+            f(e.$slots, b)
+          ])
+        })),
+        n.selected ? {
+          name: "selected",
+          fn: u(() => [
+            m(r, {
+              name: "check",
+              size: "400",
+              class: "dt-list-item--selected-icon"
+            })
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1024)) : f(e.$slots, "default", { key: 1 })
+    ]),
+    _: 3
+  }, 16, ["id", "class", "tabindex", "role", "aria-selected"]);
+}
+const un = /* @__PURE__ */ v(dn, [["render", cn]]), T = {
+  default: "column",
+  column: "column",
+  row: "row",
+  "row-reverse": "row-reverse",
+  "column-reverse": "column-reverse"
+}, _e = ["sm", "md", "lg", "xl"], W = ["0", "100", "200", "300", "400", "500", "600"], J = {
+  none: void 0,
+  small: "d-p4",
+  medium: "d-p8",
+  large: "d-p16"
+}, mn = {
+  none: void 0,
+  small: "d-pl4",
+  medium: "d-pl8",
+  large: "d-pl16"
+}, pn = ["dialog", "menu", "listbox", "tree", "grid"], fn = ["", "anchor"], hn = ["none", "dialog", "first"], gn = ["parent", "body"], yn = [
+  ...Je
+], _n = {
+  name: "PopoverHeaderFooter",
+  components: {
+    DtButton: N,
+    DtIcon: A
+  },
+  props: {
+    // eslint-disable-next-line vue/require-default-prop
+    type: {
+      type: String,
+      validator: function(e) {
+        return ["header", "footer"].includes(e);
+      }
+    },
+    /**
+     * Additional class name for the content wrapper element.
+     */
+    contentClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Determines visibility for close button
+     * @values true, false
+     */
+    showCloseButton: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * A set of props to be passed into the popover's header close button.
+     * Requires an 'ariaLabel' property.
+     */
+    closeButtonProps: {
+      type: Object,
+      default: () => {
+      }
+    }
+  },
+  emits: [
+    /**
+     * Emitted when popover is closed
+     *
+     * @event close
+     * @type { Boolean }
+     */
+    "close"
+  ],
+  data() {
+    return {
+      hasSlotContent: B
+    };
+  },
+  methods: {
+    focusCloseButton() {
+      var t;
+      const e = (t = this.$refs["popover__close-button"]) == null ? void 0 : t.$el;
+      e == null || e.focus();
+    }
+  }
+};
+function vn(e, t, n, i, o, s) {
+  const r = d("dt-icon"), c = d("dt-button");
+  return a(), p("div", {
+    "data-qa": "dt-popover-header-footer",
+    class: _({
+      "d-popover__header": n.type === "header",
+      "d-popover__footer": n.type === "footer"
+    })
+  }, [
+    o.hasSlotContent(e.$slots.content) ? (a(), p("div", {
+      key: 0,
+      "data-qa": "dt-popover-header-footer-content",
+      class: _(["d-to-ellipsis", "d-w100p", n.contentClass])
+    }, [
+      f(e.$slots, "content")
+    ], 2)) : g("", !0),
+    n.showCloseButton ? (a(), h(c, L({
+      key: 1,
+      ref: "popover__close-button",
+      "data-qa": "dt-popover-close",
+      class: "d-p6 d-mr6 d-bc-transparent",
+      importance: "outlined",
+      kind: "muted",
+      circle: ""
+    }, n.closeButtonProps, {
+      onClick: t[0] || (t[0] = (b) => e.$emit("close"))
+    }), {
+      icon: u(() => [
+        m(r, {
+          name: "close",
+          size: "300"
+        })
+      ]),
+      _: 1
+    }, 16)) : g("", !0)
+  ], 2);
+}
+const bn = /* @__PURE__ */ v(_n, [["render", vn]]);
+const Sn = {
+  name: "DtPopover",
+  /********************
+   * CHILD COMPONENTS *
+   ********************/
+  components: {
+    SrOnlyCloseButton: ge,
+    DtLazyShow: Qe,
+    PopoverHeaderFooter: bn
+  },
+  mixins: [Yt, $],
+  props: {
+    /**
+     * Controls whether the popover is shown. Leaving this null will have the popover trigger on click by default.
+     * If you set this value, the default trigger behavior will be disabled, and you can control it as you need.
+     * Supports v-model
+     * @values null, true, false
+     */
+    open: {
+      type: Boolean,
+      default: null
+    },
+    /**
+     * Opens the popover on right click (context menu). If you set this value to `true`,
+     * the default trigger behavior will be disabled.
+     * @values true, false
+     */
+    openOnContext: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Element type (tag name) of the root element of the component.
+     */
+    elementType: {
+      type: String,
+      default: "div"
+    },
+    /**
+     * Named transition when the content display is toggled.
+     * @see DtLazyShow
+     */
+    transition: {
+      type: String,
+      default: "fade"
+    },
+    /**
+     * ARIA role for the content of the popover. Defaults to "dialog".
+     * <a class="d-link" href="https://www.w3.org/TR/wai-aria/#aria-haspopup" target="_blank">aria-haspopup</a>
+     */
+    role: {
+      type: String,
+      default: "dialog",
+      validator: (e) => pn.includes(e)
+    },
+    /**
+     * ID of the element that serves as the label for the popover content.
+     * Defaults to the "anchor" element; this exists to provide a different
+     * ID of the label element if, for example, the anchor slot contains
+     * other items that do not serve as a label. You should provide this
+     * or ariaLabel, but not both.
+     */
+    ariaLabelledby: {
+      type: String,
+      default: null
+    },
+    /**
+     * Descriptive label for the popover content. You should provide this
+     * or ariaLabelledby, but not both.
+     */
+    ariaLabel: {
+      type: String,
+      default: null
+    },
+    /**
+     * A set of props to be passed into the popover's header close button.
+     * Requires an 'ariaLabel' property, when the header popover is visible
+     */
+    closeButtonProps: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Padding size class for the popover content.
+     * @values none, small, medium, large
+     */
+    padding: {
+      type: String,
+      default: "large",
+      validator: (e) => Object.keys(J).some((t) => t === e)
+    },
+    /**
+     * Additional class name for the content wrapper element.
+     */
+    contentClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Width configuration for the popover content. When its value is 'anchor',
+     * the popover content will have the same width as the anchor.
+     * @values null, anchor
+     */
+    contentWidth: {
+      type: String,
+      default: "",
+      validator: (e) => fn.includes(e)
+    },
+    /**
+     * Whether to apply transition on initial render in the content lazy show component.
+     */
+    contentAppear: {
+      type: Boolean,
+      default: null
+    },
+    /**
+     * Tabindex value for the content. Passing null, no tabindex attribute will be set.
+     */
+    contentTabindex: {
+      type: Number || null,
+      default: -1
+    },
+    /**
+     * External anchor id to use in those cases the anchor can't be provided via the slot.
+     * For instance, using the combobox's input as the anchor for the popover.
+     */
+    externalAnchor: {
+      type: String,
+      default: ""
+    },
+    /**
+     * The id of the tooltip
+     */
+    id: {
+      type: String,
+      default() {
+        return H();
+      }
+    },
+    /**
+     *  Displaces the content box from its anchor element
+     *  by the specified number of pixels.
+     *  <a
+     *    class="d-link"
+     *    href="https://atomiks.github.io/tippyjs/v6/all-props/#offset"
+     *    target="_blank"
+     *  >
+     *    Tippy.js docs
+     *  </a>
+     */
+    offset: {
+      type: Array,
+      default: () => [0, 4]
+    },
+    /**
+     * Determines if the popover hides upon clicking the
+     * anchor or outside the content box.
+     * @values true, false
+     */
+    hideOnClick: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Determines modal state. If enabled popover has a modal overlay
+     * preventing interaction with elements below it, but it is invisible.
+     * @values true, false
+     */
+    modal: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * If the popover does not fit in the direction described by "placement",
+     * it will attempt to change its direction to the "fallbackPlacements".
+     * <a
+     *   class="d-link"
+     *   href="https://popper.js.org/docs/v2/modifiers/flip/#fallbackplacements"
+     *   target="_blank"
+     * >
+     *   Popper.js docs
+     * </a>
+     * */
+    fallbackPlacements: {
+      type: Array,
+      default: () => ["auto"]
+    },
+    /**
+     * The direction the popover displays relative to the anchor.
+     * <a
+     *   class="d-link"
+     *   href="https://atomiks.github.io/tippyjs/v6/all-props/#placement"
+     *   target="_blank"
+     * >
+     *   Tippy.js docs
+     * </a>
+     * @values top, top-start, top-end,
+     * right, right-start, right-end,
+     * left, left-start, left-end,
+     * bottom, bottom-start, bottom-end,
+     * auto, auto-start, auto-end
+     */
+    placement: {
+      type: String,
+      default: "bottom-end"
+    },
+    /**
+     * If set to false the dialog will display over top of the anchor when there is insufficient space.
+     * If set to true it will never move from its position relative to the anchor and will clip instead.
+     * <a
+     *   class="d-link"
+     *   href="https://popper.js.org/docs/v2/modifiers/prevent-overflow/#tether"
+     *   target="_blank"
+     * >
+     *   Popper.js docs
+     * </a>
+     * @values true, false
+     */
+    tether: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * If the popover sticks to the anchor. This is usually not needed, but can be needed
+     * if the reference element's position is animating, or to automatically update the popover
+     * position in those cases the DOM layout changes the reference element's position.
+     * `true` enables it, `reference` only checks the "reference" rect for changes and `popper` only
+     * checks the "popper" rect for changes.
+     * <a
+     *   class="d-link"
+     *   href="https://atomiks.github.io/tippyjs/v6/all-props/#sticky"
+     *   target="_blank"
+     * >
+     *   Tippy.js docs
+     * </a>
+     * @values true, false, reference, popper
+     */
+    sticky: {
+      type: [Boolean, String],
+      default: !1,
+      validator: (e) => yn.includes(e)
+    },
+    /**
+     * Determines maximum height for the popover before overflow.
+     * Possible units rem|px|em
+     */
+    maxHeight: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Determines maximum width for the popover before overflow.
+     * Possible units rem|px|%|em
+     */
+    maxWidth: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Determines visibility for close button
+     * @values true, false
+     */
+    showCloseButton: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Additional class name for the header content wrapper element.
+     */
+    headerClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Additional class name for the footer content wrapper element.
+     */
+    footerClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Additional class name for the dialog element.
+     */
+    dialogClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * The element that is focused when the popover is opened. This can be an
+     * HTMLElement within the popover, a string starting with '#' which will
+     * find the element by ID. 'first' which will automatically focus
+     * the first element, or 'dialog' which will focus the dialog window itself.
+     * If the dialog is modal this prop cannot be 'none'.
+     * @values none, dialog, first
+     */
+    initialFocusElement: {
+      type: [String, HTMLElement],
+      default: "first",
+      validator: (e) => hn.includes(e) || e instanceof HTMLElement || e.startsWith("#")
+    },
+    /**
+     * If the popover should open pressing up or down arrow key on the anchor element.
+     * This can be set when not passing open prop.
+     * @values true, false
+     */
+    openWithArrowKeys: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Sets the element to which the popover is going to append to.
+     * 'body' will append to the nearest body (supports shadow DOM).
+     * @values 'body', 'parent', HTMLElement,
+     */
+    appendTo: {
+      type: [HTMLElement, String],
+      default: "body",
+      validator: (e) => gn.includes(e) || e instanceof HTMLElement
+    }
+  },
+  emits: [
+    /**
+     * Native keydown event
+     *
+     * @event keydown
+     * @type {KeyboardEvent}
+     */
+    "keydown",
+    /**
+     * Event fired to sync the open prop with the parent component
+     * @event update:open
+     */
+    "update:open",
+    /**
+     * Emitted when popover is shown or hidden
+     *
+     * @event opened
+     * @type {Boolean | Array}
+     */
+    "opened"
+  ],
+  data() {
+    return {
+      POPOVER_PADDING_CLASSES: J,
+      POPOVER_HEADER_FOOTER_PADDING_CLASSES: mn,
+      intersectionObserver: null,
+      isOutsideViewport: !1,
+      isOpen: !1,
+      toAppear: !1,
+      anchorEl: null,
+      popoverContentEl: null,
+      hasSlotContent: B
+    };
+  },
+  computed: {
+    popoverListeners() {
+      return {
+        keydown: (e) => {
+          this.onKeydown(e);
+        },
+        "after-leave": (e) => {
+          this.onLeaveTransitionComplete();
+        },
+        "after-enter": (e) => {
+          this.onEnterTransitionComplete();
+        }
+      };
+    },
+    calculatedMaxHeight() {
+      return this.isOutsideViewport && this.modal ? "calc(100vh - var(--dt-space-300))" : this.maxHeight;
+    },
+    labelledBy() {
+      return this.ariaLabelledby || !this.ariaLabel && H("DtPopover__anchor");
+    }
+  },
+  watch: {
+    $props: {
+      immediate: !0,
+      deep: !0,
+      handler() {
+        this.validateProps();
+      }
+    },
+    modal(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        zIndex: e ? 650 : this.calculateAnchorZindex()
+      });
+    },
+    offset(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        offset: e
+      });
+    },
+    sticky(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        sticky: e
+      });
+    },
+    fallbackPlacements() {
+      var e;
+      (e = this.tip) == null || e.setProps({
+        popperOptions: this.popperOptions()
+      });
+    },
+    tether() {
+      var e;
+      (e = this.tip) == null || e.setProps({
+        popperOptions: this.popperOptions()
+      });
+    },
+    placement(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        placement: e
+      });
+    },
+    open: {
+      handler: function(e) {
+        e !== null && (this.isOpen = e), e === !0 && (this.toAppear = !0);
+      },
+      immediate: !0
+    },
+    contentAppear: {
+      handler: function(e) {
+        e !== null && (this.toAppear = e);
+      }
+    },
+    isOpen(e, t) {
+      e ? (this.initTippyInstance(), this.tip.show()) : !e && t !== e && (this.removeEventListeners(), this.tip.hide());
+    }
+  },
+  mounted() {
+    const e = this.externalAnchor ? this.$refs.anchor.getRootNode().querySelector(`#${this.externalAnchor}`) : null;
+    this.anchorEl = e ?? this.$refs.anchor.children[0], this.popoverContentEl = this.$refs.content.$el, this.isOpen && (this.initTippyInstance(), this.tip.show()), this.intersectionObserver = new IntersectionObserver(this.hasIntersectedViewport), this.intersectionObserver.observe(this.popoverContentEl);
+  },
+  beforeUnmount() {
+    var e;
+    (e = this.tip) == null || e.destroy(), this.intersectionObserver.disconnect(), this.removeReferences(), this.removeEventListeners();
+  },
+  /******************
+   *     METHODS    *
+   ******************/
+  methods: {
+    hasIntersectedViewport(e) {
+      var i;
+      const t = (i = e == null ? void 0 : e[0]) == null ? void 0 : i.target;
+      if (!t)
+        return;
+      const n = et(t);
+      this.isOutsideViewport = n.bottom || n.top;
+    },
+    popperOptions() {
+      return tt({
+        fallbackPlacements: this.fallbackPlacements,
+        tether: this.tether,
+        hasHideModifierEnabled: !0
+      });
+    },
+    validateProps() {
+      this.modal && this.initialFocusElement === "none" && console.error('If the popover is modal you must set the initialFocusElement prop. Possible values: "dialog", "first", HTMLElement');
+    },
+    calculateAnchorZindex() {
+      var e;
+      return this.$el.getRootNode().querySelector('.d-modal[aria-hidden="false"], .d-modal--transparent[aria-hidden="false"]') || // Special case because we don't have any dialtone drawer component yet. Render at 650 when
+      // anchor of popover is within a drawer.
+      (e = this.anchorEl) != null && e.closest(".d-zi-drawer") ? 650 : 300;
+    },
+    defaultToggleOpen(e) {
+      var t, n, i;
+      if (!this.openOnContext && (this.open === null || this.open === void 0)) {
+        if (!((t = this.anchorEl) != null && t.contains(e.target)) && !((n = this.anchorEl) != null && n.isEqualNode(e.target)) || (i = this.anchorEl) != null && i.disabled)
+          return;
+        this.toggleOpen();
+      }
+    },
+    async onContext(e) {
+      this.openOnContext && (e.preventDefault(), this.isOpen = !0, await this.$nextTick(), this.tip.setProps({
+        placement: "right-start",
+        getReferenceClientRect: () => ({
+          width: 0,
+          height: 0,
+          top: e.clientY,
+          bottom: e.clientY,
+          left: e.clientX,
+          right: e.clientX
+        })
+      }));
+    },
+    toggleOpen() {
+      this.isOpen = !this.isOpen;
+    },
+    onArrowKeyPress(e) {
+      var t;
+      this.open === null && (this.openWithArrowKeys && ((t = this.anchorEl) != null && t.contains(e.target)) && (this.isOpen || (this.isOpen = !0)), this.$emit("keydown", e));
+    },
+    addEventListeners() {
+      window.addEventListener("dt-popover-close", this.closePopover), this.contentWidth === "anchor" && window.addEventListener("resize", this.onResize);
+    },
+    removeEventListeners() {
+      window.removeEventListener("dt-popover-close", this.closePopover), this.contentWidth === "anchor" && window.removeEventListener("resize", this.onResize);
+    },
+    closePopover() {
+      this.isOpen = !1;
+    },
+    /*
+    * Prevents scrolling outside of the currently opened modal popover by:
+    *   - when anchor is not within another popover: setting the body to overflow: hidden
+    *   - when anchor is within another popover: set the popover dialog container to it's non-modal z-index
+    *     since it is no longer the active modal. This puts it underneath the overlay and prevents scrolling.
+    **/
+    preventScrolling() {
+      var e;
+      if (this.modal) {
+        const t = (e = this.anchorEl) == null ? void 0 : e.closest("body, .tippy-box");
+        t.tagName.toLowerCase() === "body" ? (t.classList.add("d-of-hidden"), this.tip.setProps({ offset: this.offset })) : t.classList.add("d-zi-popover");
+      }
+    },
+    /*
+    * Resets the prevent scrolling properties set in preventScrolling() back to normal.
+    **/
+    enableScrolling() {
+      var t, n;
+      const e = (t = this.anchorEl) == null ? void 0 : t.closest("body, .tippy-box");
+      e && (((n = e.tagName) == null ? void 0 : n.toLowerCase()) === "body" ? (e.classList.remove("d-of-hidden"), this.tip.setProps({ offset: this.offset })) : e.classList.remove("d-zi-popover"));
+    },
+    removeReferences() {
+      this.anchorEl = null, this.popoverContentEl = null, this.tip = null;
+    },
+    async onShow() {
+      this.contentWidth === "anchor" && await this.setPopoverContentAnchorWidth(), this.contentWidth === null && (this.popoverContentEl.style.width = "auto"), this.addEventListeners();
+    },
+    async onLeaveTransitionComplete() {
+      var e;
+      this.modal && (await this.focusFirstElement(this.$refs.anchor), await this.$nextTick(), this.enableScrolling()), (e = this.tip) == null || e.unmount(), this.$emit("opened", !1), this.open !== null && this.$emit("update:open", !1);
+    },
+    async onEnterTransitionComplete() {
+      this.focusInitialElement(), await this.$nextTick(), this.preventScrolling(), this.$emit("opened", !0, this.$refs.popover__content), this.open !== null && this.$emit("update:open", !0);
+    },
+    focusInitialElement() {
+      this.initialFocusElement === "dialog" && this.$refs.content.$el.focus(), this.initialFocusElement.startsWith("#") && this.focusInitialElementById(), this.initialFocusElement === "first" && this.focusFirstElementIfNeeded(this.$refs.popover__content), this.initialFocusElement instanceof HTMLElement && this.initialFocusElement.focus();
+    },
+    focusInitialElementById() {
+      var t, n, i;
+      const e = (n = (t = this.$refs.content) == null ? void 0 : t.$el) == null ? void 0 : n.querySelector(this.initialFocusElement);
+      e ? e.focus() : console.warn('Could not find the element specified in dt-popover prop "initialFocusElement". Defaulting to focusing the dialog.'), e ? e.focus() : (i = this.$refs.content) == null || i.$el.focus();
+    },
+    onResize() {
+      this.closePopover();
+    },
+    onClickOutside() {
+      if (!this.hideOnClick)
+        return;
+      this.popoverContentEl.querySelector(".d-popover__anchor--opened") || this.closePopover();
+    },
+    onKeydown(e) {
+      e.key === "Tab" && this.modal && this.focusTrappedTabPress(e, this.popoverContentEl), e.key === "Escape" && this.closePopover(), this.$emit("keydown", e);
+    },
+    async setPopoverContentAnchorWidth() {
+      var e;
+      await this.$nextTick(), this.popoverContentEl.style.width = `${(e = this.anchorEl) == null ? void 0 : e.clientWidth}px`;
+    },
+    focusFirstElementIfNeeded(e) {
+      var n, i;
+      this._getFocusableElements(e, !0).length !== 0 ? this.focusFirstElement(e) : this.showCloseButton ? (n = this.$refs.popover__header) == null || n.focusCloseButton() : (i = this.$refs.content) == null || i.$el.focus();
+    },
+    initTippyInstance() {
+      var e, t;
+      this.tip = nt(this.anchorEl, {
+        popperOptions: this.popperOptions(),
+        contentElement: this.popoverContentEl,
+        placement: this.placement,
+        offset: this.offset,
+        sticky: this.sticky,
+        appendTo: this.appendTo === "body" ? (t = (e = this.anchorEl) == null ? void 0 : e.getRootNode()) == null ? void 0 : t.querySelector("body") : this.appendTo,
+        interactive: !0,
+        trigger: "manual",
+        // We have to manage hideOnClick functionality manually to handle
+        // popover within popover situations.
+        hideOnClick: !1,
+        zIndex: this.modal ? 650 : this.calculateAnchorZindex(),
+        onClickOutside: this.onClickOutside,
+        onShow: this.onShow
+      });
+    }
+  }
+}, En = ["aria-hidden"], Cn = ["id", "tabindex"];
+function kn(e, t, n, i, o, s) {
+  const r = d("popover-header-footer"), c = d("sr-only-close-button"), b = d("dt-lazy-show");
+  return a(), p("div", null, [
+    n.modal && o.isOpen ? (a(), h(We, {
+      key: 0,
+      to: "body"
+    }, [
+      S("div", {
+        class: "d-modal--transparent",
+        "aria-hidden": n.modal && o.isOpen ? "false" : "true",
+        onClick: t[0] || (t[0] = P(() => {
+        }, ["prevent", "stop"]))
+      }, null, 8, En)
+    ])) : g("", !0),
+    (a(), h(O(n.elementType), {
+      ref: "popover",
+      class: _(["d-popover", { "d-popover__anchor--opened": o.isOpen }]),
+      "data-qa": "dt-popover-container"
+    }, {
+      default: u(() => [
+        S("div", {
+          id: !n.ariaLabelledby && s.labelledBy,
+          ref: "anchor",
+          "data-qa": "dt-popover-anchor",
+          tabindex: n.openOnContext ? 0 : void 0,
+          onClickCapture: t[1] || (t[1] = (...y) => s.defaultToggleOpen && s.defaultToggleOpen(...y)),
+          onContextmenu: t[2] || (t[2] = (...y) => s.onContext && s.onContext(...y)),
+          onKeydown: [
+            t[3] || (t[3] = w(P((...y) => s.onArrowKeyPress && s.onArrowKeyPress(...y), ["prevent"]), ["up"])),
+            t[4] || (t[4] = w(P((...y) => s.onArrowKeyPress && s.onArrowKeyPress(...y), ["prevent"]), ["down"])),
+            t[6] || (t[6] = w((y) => e.$emit("keydown", y), ["enter"])),
+            t[7] || (t[7] = w((y) => e.$emit("keydown", y), ["space"]))
+          ],
+          onKeydownCapture: t[5] || (t[5] = w((...y) => s.closePopover && s.closePopover(...y), ["escape"]))
+        }, [
+          f(e.$slots, "anchor", {
+            attrs: {
+              "aria-expanded": o.isOpen.toString(),
+              "aria-controls": n.id,
+              "aria-haspopup": n.role
+            }
+          })
+        ], 40, Cn),
+        m(b, L({
+          id: n.id,
+          ref: "content",
+          role: n.role,
+          "data-qa": "dt-popover",
+          "aria-hidden": `${!o.isOpen}`,
+          "aria-labelledby": s.labelledBy,
+          "aria-label": n.ariaLabel,
+          "aria-modal": `${!n.modal}`,
+          transition: n.transition,
+          show: o.isOpen,
+          appear: o.toAppear,
+          class: ["d-popover__dialog", { "d-popover__dialog--modal": n.modal }, n.dialogClass],
+          style: {
+            "max-height": s.calculatedMaxHeight,
+            "max-width": n.maxWidth
+          },
+          css: e.$attrs.css,
+          tabindex: n.contentTabindex
+        }, ce(s.popoverListeners)), {
+          default: u(() => [
+            o.hasSlotContent(e.$slots.headerContent) || n.showCloseButton ? (a(), h(r, {
+              key: 0,
+              ref: "popover__header",
+              class: _(o.POPOVER_HEADER_FOOTER_PADDING_CLASSES[n.padding]),
+              "content-class": n.headerClass,
+              type: "header",
+              "show-close-button": n.showCloseButton,
+              "close-button-props": n.closeButtonProps,
+              onClose: s.closePopover
+            }, {
+              content: u(() => [
+                f(e.$slots, "headerContent", { close: s.closePopover })
+              ]),
+              _: 3
+            }, 8, ["class", "content-class", "show-close-button", "close-button-props", "onClose"])) : g("", !0),
+            S("div", {
+              ref: "popover__content",
+              "data-qa": "dt-popover-content",
+              class: _([
+                "d-popover__content",
+                o.POPOVER_PADDING_CLASSES[n.padding],
+                n.contentClass
+              ])
+            }, [
+              f(e.$slots, "content", { close: s.closePopover })
+            ], 2),
+            o.hasSlotContent(e.$slots.footerContent) ? (a(), h(r, {
+              key: 1,
+              ref: "popover__footer",
+              type: "footer",
+              class: _(o.POPOVER_HEADER_FOOTER_PADDING_CLASSES[n.padding]),
+              "content-class": n.footerClass
+            }, {
+              content: u(() => [
+                f(e.$slots, "footerContent", { close: s.closePopover })
+              ]),
+              _: 3
+            }, 8, ["class", "content-class"])) : g("", !0),
+            e.showVisuallyHiddenClose ? (a(), h(c, {
+              key: 2,
+              "visually-hidden-close-label": e.visuallyHiddenCloseLabel,
+              onClose: s.closePopover
+            }, null, 8, ["visually-hidden-close-label", "onClose"])) : g("", !0)
+          ]),
+          _: 3
+        }, 16, ["id", "role", "aria-hidden", "aria-labelledby", "aria-label", "aria-modal", "transition", "show", "appear", "class", "style", "css", "tabindex"])
+      ]),
+      _: 3
+    }, 8, ["class"]))
+  ]);
+}
+const In = /* @__PURE__ */ v(Sn, [["render", kn]]), wn = {
+  name: "DtNotice",
+  components: {
+    DtNoticeIcon: xt,
+    DtNoticeContent: Mt,
+    DtNoticeAction: Wt
+  },
+  mixins: [$],
+  props: {
+    /**
+     * Sets an ID on the title element of the component. Useful for aria-describedby
+     * or aria-labelledby or any other reason you may need an id to refer to the title.
+     */
+    titleId: {
+      type: String,
+      default: void 0
+    },
+    /**
+     * Sets an ID on the content element of the component. Useful for aria-describedby
+     * or aria-labelledby or any other reason you may need an id to refer to the content.
+     */
+    contentId: {
+      type: String,
+      default: void 0
+    },
+    /**
+     * Title header of the notice. This can be left blank to remove the title from the notice entirely.
+     */
+    title: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Provides a role for the notice. 'status' is used to communicate a message. 'alert' is used to communicate an
+     * important message that does not contain any interactive elements. 'alertdialog' is used to communicate an
+     * important message that does contain interactive elements.
+     * @values alert, alertdialog, status
+     */
+    role: {
+      type: String,
+      default: "status",
+      validate(e) {
+        return At.includes(e);
+      }
+    },
+    /**
+     * Used in scenarios where the message needs to visually dominate the screen.
+     * This will also change the aria role from status to alert.
+     * @values true, false
+     */
+    important: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Severity level of the notice, sets the icon and background
+     * @values base, error, info, success, warning
+     */
+    kind: {
+      type: String,
+      default: "base",
+      validate(e) {
+        return z.includes(e);
+      }
+    },
+    /**
+     * Props for the notice close button.
+     */
+    closeButtonProps: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Hides the close button from the notice
+     * @values true, false
+     */
+    hideClose: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: [
+    /**
+     * Close button click event
+     *
+     * @event close
+     */
+    "close",
+    /**
+     * Native button click event
+     *
+     * @event click
+     * @type {PointerEvent | KeyboardEvent}
+     */
+    "click"
+  ],
+  computed: {
+    noticeClass() {
+      return [
+        "d-notice",
+        {
+          error: "d-notice--error",
+          info: "d-notice--info",
+          success: "d-notice--success",
+          warning: "d-notice--warning",
+          base: "d-notice--base"
+        }[this.kind],
+        { "d-notice--important": this.important }
+      ];
+    }
+  }
+};
+function On(e, t, n, i, o, s) {
+  const r = d("dt-notice-icon"), c = d("dt-notice-content"), b = d("dt-notice-action");
+  return a(), p("aside", {
+    class: _(s.noticeClass),
+    "data-qa": "notice"
+  }, [
+    m(r, { kind: n.kind }, {
+      default: u(() => [
+        f(e.$slots, "icon")
+      ]),
+      _: 3
+    }, 8, ["kind"]),
+    m(c, {
+      "title-id": n.titleId,
+      "content-id": n.contentId,
+      title: n.title,
+      role: n.role
+    }, {
+      titleOverride: u(() => [
+        f(e.$slots, "titleOverride")
+      ]),
+      default: u(() => [
+        f(e.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["title-id", "content-id", "title", "role"]),
+    m(b, {
+      "hide-close": n.hideClose,
+      "close-button-props": n.closeButtonProps,
+      "visually-hidden-close": e.visuallyHiddenClose,
+      "visually-hidden-close-label": e.visuallyHiddenCloseLabel,
+      onClose: t[0] || (t[0] = (y) => e.$emit("close"))
+    }, {
+      default: u(() => [
+        f(e.$slots, "action")
+      ]),
+      _: 3
+    }, 8, ["hide-close", "close-button-props", "visually-hidden-close", "visually-hidden-close-label"])
+  ], 2);
+}
+const Tn = /* @__PURE__ */ v(wn, [["render", On]]);
+function Q(e) {
+  return e === T.default;
+}
+function ee(e) {
+  if (x(e) === "string")
+    return Q(e) ? null : T[e];
+  if (x(e) === "object") {
+    const { default: t } = e;
+    return Q(t) ? null : T[t];
+  } else
+    return null;
+}
+function x(e) {
+  return typeof e;
+}
+function An(e) {
+  return ee(e) ? `d-stack--${T[ee(e)]}` : null;
+}
+function Pn(e) {
+  return x(e) === "object" ? [
+    ..._e.map((t) => e[t] ? `d-stack--${t}--${e[t]}` : null)
+  ] : null;
+}
+function Ln(e) {
+  return W.includes(e) ? `d-stack--gap-${e}` : null;
+}
+function jn(e) {
+  if (x(e) === "string")
+    return Object.keys(T).includes(e);
+  if (x(e) === "object") {
+    const { default: t } = e;
+    return Object.keys(T).includes(t);
+  } else
+    return null;
+}
+function Dn(e) {
+  return W.includes(e);
+}
+const xn = {
+  name: "DtStack",
+  props: {
+    /**
+     * Set this prop to the direction to stack the items.
+     * You can override the default direction with 'default' key.
+     * All the undefined breakpoints will have 'default' value.
+     * By default, for the column direction it will have `justify-content: flex-start`
+     * and for the row direction `align-items: center`. This can be overriden
+     * by utility classes.
+     */
+    direction: {
+      type: [String, Object],
+      default: "column",
+      validator: (e) => jn(e)
+    },
+    /**
+     * Set this prop to render stack as a specific HTML element.
+     */
+    as: {
+      type: String,
+      default: "div"
+    },
+    /**
+     * Set this prop to have the space between each stack item
+     * @values 0, 100, 200, 300, 400, 500, 600
+     */
+    gap: {
+      type: String,
+      default: "0",
+      validator: (e) => Dn(e)
+    }
+  },
+  data() {
+    return {
+      DT_STACK_DIRECTION: T,
+      DT_STACK_GAP: W,
+      DT_STACK_RESPONSIVE_BREAKPOINTS: _e
+    };
+  },
+  computed: {
+    stackGap() {
+      return Ln(this.gap);
+    },
+    defaultDirection() {
+      return An(this.direction);
+    },
+    stackResponsive() {
+      return Pn(this.direction);
+    }
+  }
+};
+function Rn(e, t, n, i, o, s) {
+  return a(), h(O(n.as), {
+    class: _([
+      "d-stack",
+      s.defaultDirection,
+      s.stackResponsive,
+      s.stackGap
+    ])
+  }, {
+    default: u(() => [
+      f(e.$slots, "default")
+    ]),
+    _: 3
+  }, 8, ["class"]);
+}
+const ve = /* @__PURE__ */ v(xn, [["render", Rn]]), Fn = {
+  name: "EmojiComponent",
+  components: {
+    NodeViewWrapper: oe,
+    DtEmoji: le
+  },
+  props: ie
+};
+function Nn(e, t, n, i, o, s) {
+  const r = d("dt-emoji"), c = d("node-view-wrapper");
+  return a(), h(c, { class: "d-d-inline-block" }, {
+    default: u(() => [
+      m(r, {
+        size: "300",
+        code: e.node.attrs.code
+      }, null, 8, ["code"])
+    ]),
+    _: 1
+  });
+}
+const Bn = /* @__PURE__ */ v(Fn, [["render", Nn]]);
+const Vn = {
+  name: "SuggestionList",
+  components: {
+    DtListItem: un
+  },
+  props: {
+    items: {
+      type: Array,
+      required: !0
+    },
+    command: {
+      type: Function,
+      required: !0
+    },
+    itemComponent: {
+      type: Object,
+      required: !0
+    },
+    itemType: {
+      type: String,
+      required: !0
+    }
+  },
+  data() {
+    return {
+      selectedIndex: 0
+    };
+  },
+  watch: {
+    items() {
+      this.selectedIndex = 0;
+    }
+  },
+  methods: {
+    onKeyDown({ event: e }) {
+      return e.key === "ArrowUp" ? (this.upHandler(), !0) : e.key === "ArrowDown" ? (this.downHandler(), !0) : e.key === "Enter" ? (this.enterHandler(), !0) : !1;
+    },
+    upHandler() {
+      this.selectedIndex = (this.selectedIndex + this.items.length - 1) % this.items.length, this.scrollActiveElementIntoView();
+    },
+    downHandler() {
+      this.selectedIndex = (this.selectedIndex + 1) % this.items.length, this.scrollActiveElementIntoView();
+    },
+    scrollActiveElementIntoView() {
+      const e = this.$refs.suggestionList.querySelector(".dt-list-item--highlighted");
+      e && e.scrollIntoView({
+        behaviour: "smooth",
+        block: "center"
+      });
+    },
+    enterHandler() {
+      this.selectItem(this.selectedIndex);
+    },
+    selectItem(e) {
+      const t = this.items[e];
+      switch (this.itemType) {
+        case "emoji":
+          this.command(t);
+          return;
+        case "mention":
+          this.command({ name: t.name, id: t.contactId, avatarSrc: t.avatarSrc });
+          break;
+      }
+    }
+  }
+}, Mn = { class: "d-popover__dialog" }, Hn = {
+  ref: "suggestionList",
+  class: "dt-suggestion-list"
+};
+function qn(e, t, n, i, o, s) {
+  const r = d("dt-list-item");
+  return a(), p("div", Mn, [
+    Ue(S("ul", Hn, [
+      (a(!0), p(me, null, ue(n.items, (c, b) => (a(), h(r, {
+        key: c.id,
+        class: _([
+          "dt-suggestion-list--item",
+          { "dt-list-item--highlighted": b === o.selectedIndex }
+        ]),
+        "navigation-type": "arrow-keys",
+        onClick: (y) => s.selectItem(b),
+        onKeydown: P(s.onKeyDown, ["prevent", "stop"])
+      }, {
+        default: u(() => [
+          (a(), h(O(n.itemComponent), { item: c }, null, 8, ["item"]))
+        ]),
+        _: 2
+      }, 1032, ["class", "onClick", "onKeydown"]))), 128))
+    ], 512), [
+      [Ge, n.items.length]
+    ])
+  ]);
+}
+const be = /* @__PURE__ */ v(Vn, [["render", qn]]), Kn = {
+  name: "EmojiSuggestion",
+  components: {
+    DtEmoji: le,
+    DtStack: ve
+  },
+  props: {
+    item: {
+      type: Object,
+      required: !0
+    }
+  }
+};
+function zn(e, t, n, i, o, s) {
+  const r = d("dt-emoji"), c = d("dt-stack");
+  return a(), h(c, {
+    direction: "row",
+    gap: "400"
+  }, {
+    default: u(() => [
+      m(r, {
+        size: "200",
+        code: n.item.code
+      }, null, 8, ["code"]),
+      R(" " + E(n.item.code), 1)
+    ]),
+    _: 1
+  });
+}
+const $n = /* @__PURE__ */ v(Kn, [["render", zn]]), Wn = {
+  items: ({ query: e }) => e.length < 2 ? [] : Object.values(He).filter(function(i) {
+    return !!i.shortname.substring(1, i.shortname.length - 1).startsWith(e.toLowerCase());
+  }).map((i) => ({ id: i.unicode_character, code: i.shortname })),
+  command: ({ editor: e, range: t, props: n }) => {
+    var s, r;
+    const i = e.view.state.selection.$to.nodeAfter;
+    ((s = i == null ? void 0 : i.text) == null ? void 0 : s.startsWith(" ")) && (t.to += 1), e.chain().focus().insertContentAt(t, [
+      {
+        type: "emoji",
+        attrs: n
+      },
+      {
+        type: "text",
+        text: " "
+      }
+    ]).run(), (r = window.getSelection()) == null || r.collapseToEnd();
+  },
+  render: () => {
+    let e, t;
+    return {
+      onStart: (n) => {
+        e = new ae(be, {
+          props: {
+            itemComponent: pe($n),
+            itemType: "emoji",
+            ...n
+          },
+          editor: n.editor
+        }), n.clientRect && (t = he("body", {
+          getReferenceClientRect: n.clientRect,
+          appendTo: () => document.body,
+          content: e.element,
+          showOnCreate: !0,
+          interactive: !0,
+          trigger: "manual",
+          placement: "bottom-start",
+          contentElement: null,
+          zIndex: 650
+        }));
+      },
+      onUpdate(n) {
+        e.updateProps(n), n.clientRect && t[0].setProps({
+          getReferenceClientRect: n.clientRect
+        });
+      },
+      onKeyDown(n) {
+        var i;
+        return n.event.key === "Escape" ? (t[0].hide(), !0) : (i = e.ref) == null ? void 0 : i.onKeyDown(n);
+      },
+      onExit() {
+        t[0].destroy(), e.destroy();
+      }
+    };
+  }
+}, Un = new fe("emoji"), Gn = /:\w+:$/, Yn = /:\w+:/g, Zn = /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])$/, Xn = /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g, te = (e) => {
+  if (e && de(e[0]))
+    return {
+      index: e.index,
+      text: e[0],
+      match: e
+    };
+}, Jn = (e) => [...e.matchAll(Yn)].filter((n) => de(n[0])).map((n) => ({
+  index: n.index,
+  text: n[0],
+  match: n
+})), Qn = je.create({
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      suggestion: {
+        char: ":",
+        pluginKey: Un
+      }
+    };
+  },
+  name: "emoji",
+  group: "inline",
+  inline: !0,
+  selectable: !0,
+  addNodeView() {
+    return re(Bn);
+  },
+  addAttributes() {
+    return {
+      code: {
+        default: null
+      },
+      id: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "emoji-component"
+      }
+    ];
+  },
+  renderText({ node: e }) {
+    return e.attrs.code;
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["emoji-component", K(this.options.HTMLAttributes, e), 0];
+  },
+  addInputRules() {
+    return [
+      // shortcode input
+      U({
+        find: (e) => {
+          const t = e.match(Gn);
+          return te(t);
+        },
+        type: this.type,
+        getAttributes(e) {
+          return {
+            code: e[0]
+          };
+        }
+      }),
+      U({
+        find: (e) => {
+          const t = e.match(Zn);
+          return te(t);
+        },
+        type: this.type,
+        getAttributes(e) {
+          const t = qe(e[0]).unicode_output;
+          return {
+            code: String.fromCodePoint(parseInt(t, 16)),
+            label: "emoji"
+          };
+        }
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      G({
+        find: Jn,
+        type: this.type,
+        getAttributes(e) {
+          return {
+            code: e[0]
+          };
+        }
+      }),
+      G({
+        find: Xn,
+        type: this.type,
+        getAttributes(e) {
+          return {
+            code: e[0]
+          };
+        }
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      rt({
+        editor: this.editor,
+        ...this.options.suggestion,
+        ...Wn
+      })
+    ];
+  }
+});
+function es(e, t, n = () => !0) {
+  const i = [];
+  t.lastIndex = 0;
+  let o;
+  for (; o = t.exec(e); )
+    n(e, o) && i.push(o);
+  return i;
+}
+function ts(e, t) {
+  return !["#", "@"].includes(e.charAt(t.index)) && !["#", "@"].includes(e.charAt(t.index - 1));
+}
+function ns(e) {
+  const t = new RegExp(
+    "(?:" + [
+      `[!?.,:;'"]`,
+      "(?:&|&amp;)(?:lt|gt|quot|apos|raquo|laquo|rsaquo|lsaquo);)+$"
+    ].join("|"),
+    "g"
+  );
+  return e.replace(t, "");
+}
+function ss(e, t) {
+  const n = e.slice(0, t + 1).search(/\S+\s*$/), i = e.slice(t).search(/\s/);
+  if (i < 0) {
+    const o = e.slice(n);
+    return {
+      text: o,
+      from: n,
+      to: n + o.length
+    };
+  }
+  return {
+    text: e.slice(n, i + t),
+    from: n,
+    to: i + t
+  };
+}
+function q(e, t, n, i) {
+  const o = ss(e, t);
+  if (i.lastIndex = 0, !i.test(o.text))
+    return o;
+  const s = n === "left" ? o.from - 1 : o.to + 1;
+  return s <= 0 || s >= e.length || s === t ? o : q(e, s, n, i);
+}
+function os(e, t, n, i) {
+  const o = Math.max(e.from - 1, 0), s = Math.min(e.to + 1, t.content.size), r = De(o, s, t);
+  for (const c of r)
+    c.mark.type === i && n.removeMark(c.from, c.to, i);
+}
+const ne = st(1, 15);
+function se(e, t, n, i, o, s) {
+  if (!e)
+    return;
+  let r = n - t - 1;
+  r = r < 0 ? 0 : r;
+  const c = i - t, b = q(
+    e,
+    r,
+    "left",
+    ne
+  ), y = q(
+    e,
+    c,
+    "right",
+    ne
+  ), k = e.slice(b.from, y.to);
+  es(k, ot, ts).forEach((j) => {
+    const I = ns(j[0]), l = t + b.from + j.index + 1, Ce = l + I.length;
+    o.addMark(l, Ce, s.create());
+  });
+}
+function is(e) {
+  let t = !1;
+  return new at({
+    key: new fe("autolink"),
+    appendTransaction: (n, i, o) => {
+      const s = n.some((k) => k.docChanged) && !i.doc.eq(o.doc);
+      if (t && !s)
+        return;
+      const { tr: r } = o, { textContent: c } = o.doc;
+      t || se(c, 0, 0, c.length, r, e.type), t = !0;
+      const b = xe(
+        i.doc,
+        [...n]
+      );
+      return Re(b).forEach(({ oldRange: k, newRange: C }) => {
+        os(C, o.doc, r, e.type), Fe(
+          o.doc,
+          C,
+          (I) => I.isTextblock
+        ).forEach(({ node: I, pos: l }) => {
+          se(
+            I.textContent,
+            l,
+            k.from,
+            C.to,
+            r,
+            e.type
+          );
+        });
+      }), r;
+    }
+  });
+}
+const as = {
+  class: "d-link d-c-text d-d-inline-block",
+  rel: "noopener noreferrer nofollow"
+}, rs = Ne.create({
+  name: "Link",
+  renderHTML({ HTMLAttributes: e }) {
+    return [
+      "a",
+      K(
+        this.options.HTMLAttributes,
+        e,
+        as
+      ),
+      0
+    ];
+  },
+  renderText({ node: e }) {
+    return e.attrs.text;
+  },
+  addProseMirrorPlugins() {
+    return [
+      is({ type: this.type })
+    ];
+  }
+});
+const ls = {
+  name: "MentionComponent",
+  components: {
+    NodeViewWrapper: oe,
+    DtLink: Qt
+  },
+  props: ie,
+  computed: {
+    text() {
+      return "@" + this.$props.node.attrs.name;
+    }
+  }
+};
+function ds(e, t, n, i, o, s) {
+  const r = d("dt-link"), c = d("node-view-wrapper");
+  return a(), h(c, { class: "d-d-inline-block" }, {
+    default: u(() => [
+      m(r, {
+        kind: "inverted",
+        class: "dt-link--mention",
+        href: null
+      }, {
+        default: u(() => [
+          R(E(s.text), 1)
+        ]),
+        _: 1
+      })
+    ]),
+    _: 1
+  });
+}
+const cs = /* @__PURE__ */ v(ls, [["render", ds]]), us = lt.extend({
+  addNodeView() {
+    return re(cs);
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "mention-component"
+      }
+    ];
+  },
+  addAttributes() {
+    return {
+      name: {
+        default: ""
+      },
+      avatarSrc: {
+        default: ""
+      },
+      id: {
+        default: ""
+      }
+    };
+  },
+  renderText({ node: e }) {
+    return "@ " + e.attrs.name;
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["mention-component", K(this.options.HTMLAttributes, e), 0];
+  }
+}), Se = [
+  "text",
+  "json",
+  "html"
+], Ee = [
+  "start",
+  "end",
+  "all"
+], ms = {
+  name: "MentionSuggestion",
+  components: {
+    DtAvatar: Tt,
+    DtStack: ve
+  },
+  props: {
+    item: {
+      type: Object,
+      required: !0
+    }
+  },
+  computed: {
+    name() {
+      return this.item.name;
+    },
+    avatarSrc() {
+      return this.item.avatarSrc;
+    }
+  }
+};
+function ps(e, t, n, i, o, s) {
+  const r = d("dt-avatar"), c = d("dt-stack");
+  return a(), h(c, {
+    direction: "row",
+    gap: "400"
+  }, {
+    default: u(() => [
+      m(r, {
+        "full-name": s.name,
+        "image-src": s.avatarSrc,
+        size: "xs"
+      }, null, 8, ["full-name", "image-src"]),
+      R(" " + E(s.name), 1)
+    ]),
+    _: 1
+  });
+}
+const fs = /* @__PURE__ */ v(ms, [["render", ps]]), hs = {
+  // This function comes from the user and passed to the editor directly.
+  // This will also activate the mention plugin on the editor
+  // items: ({ query }) => { return [] },
+  render: () => {
+    let e, t;
+    return {
+      onStart: (n) => {
+        e = new ae(be, {
+          // // using vue 2:
+          // parent: this,
+          // propsData: props,
+          // using vue 3:
+          props: {
+            itemComponent: pe(fs),
+            itemType: "mention",
+            ...n
+          },
+          editor: n.editor
+        }), n.clientRect && (t = he("body", {
+          getReferenceClientRect: n.clientRect,
+          appendTo: () => document.body,
+          content: e.element,
+          showOnCreate: !0,
+          interactive: !0,
+          trigger: "manual",
+          placement: "bottom-start"
+        }));
+      },
+      onUpdate(n) {
+        e.updateProps(n), n.clientRect && t[0].setProps({
+          getReferenceClientRect: n.clientRect
+        });
+      },
+      onKeyDown(n) {
+        var i;
+        return n.event.key === "Escape" ? (t[0].hide(), !0) : (i = e.ref) == null ? void 0 : i.onKeyDown(n);
+      },
+      onExit() {
+        t[0].destroy(), e.destroy();
+      }
+    };
+  }
+};
+const gs = {
+  name: "DtRichTextEditor",
+  components: {
+    EditorContent: ke
+  },
+  props: {
+    /**
+     * Value of the input. The object format should match TipTap's JSON
+     * document structure: https://tiptap.dev/guide/output#option-1-json
+     */
+    modelValue: {
+      type: [Object, String],
+      default: ""
+    },
+    /**
+     * Whether the input is editable
+     */
+    editable: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Descriptive label for the input element
+     */
+    inputAriaLabel: {
+      type: String,
+      required: !0
+    },
+    /**
+     * Additional class name for the input element. Only accepts a String value
+     * because this is passed to the editor via options. For multiple classes,
+     * join them into one string, e.g. "d-p8 d-hmx96"
+     */
+    inputClass: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Whether the input should receive focus after the component has been
+     * mounted. Either one of `start`, `end`, `all` or a Boolean or a Number.
+     * - `start`  Sets the focus to the beginning of the input
+     * - `end`    Sets the focus to the end of the input
+     * - `all`    Selects the whole contents of the input
+     * - `Number` Sets the focus to a specific position in the input
+     * - `true`   Defaults to `start`
+     * - `false`  Disables autofocus
+     * @values true, false, start, end, all, number
+     */
+    autoFocus: {
+      type: [Boolean, String, Number],
+      default: !1,
+      validator(e) {
+        return typeof e == "string" ? Ee.includes(e) : !0;
+      }
+    },
+    /**
+     * The output format that the editor uses when emitting the "@input" event.
+     * One of `text`, `json`, `html`. See https://tiptap.dev/guide/output for
+     * examples.
+     * @values text, json, html
+     */
+    outputFormat: {
+      type: String,
+      default: "text",
+      validator(e) {
+        return Se.includes(e);
+      }
+    },
+    /**
+     * Placeholder text
+     */
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Enables the Link extension and optionally passes configurations to it
+     */
+    link: {
+      type: [Boolean, Object],
+      default: !1
+    },
+    /**
+     * suggestion object containing the items query function.
+     * The valid keys passed into this object can be found here: https://tiptap.dev/api/utilities/suggestion
+     *
+     * The only required key is the items function which is used to query the contacts for suggestion.
+     * items({ query }) => { return [ContactObject]; }
+     * ContactObject format:
+     * { name: string, avatarSrc: string, id: string }
+     *
+     * When null, it does not add the plugin.
+     */
+    mentionSuggestion: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: [
+    /**
+     * Editor input event
+     * @event input
+     * @type {String|JSON}
+     */
+    "input",
+    /**
+     * Event to sync the value with the parent
+     * @event input
+     * @type {String|JSON}
+     */
+    "update:modelValue",
+    /**
+     * Editor blur event
+     * @event blur
+     * @type {FocusEvent}
+     */
+    "blur",
+    /**
+     * Editor focus event
+     * @event focus
+     * @type {FocusEvent}
+     */
+    "focus"
+  ],
+  data() {
+    return {
+      editor: null,
+      popoverOpened: !1
+    };
+  },
+  computed: {
+    extensions() {
+      const e = [we, Oe, Ae, Le];
+      if (this.link && e.push(this.getExtension(rs, this.link)), e.push(
+        Pe.configure({ placeholder: this.placeholder })
+      ), e.push(
+        Te.extend({
+          addKeyboardShortcuts() {
+            return {
+              Enter: () => !0,
+              "Shift-Enter": () => this.editor.commands.first(({ commands: t }) => [
+                () => t.newlineInCode(),
+                () => t.createParagraphNear(),
+                () => t.liftEmptyBlock(),
+                () => t.splitBlock()
+              ])
+            };
+          }
+        })
+      ), this.mentionSuggestion) {
+        const t = { ...this.mentionSuggestion, ...hs };
+        e.push(us.configure({ suggestion: t }));
+      }
+      return e.push(Qn), e;
+    },
+    inputAttrs() {
+      const e = {
+        "aria-label": this.inputAriaLabel,
+        "aria-multiline": !0,
+        role: "textbox"
+      };
+      return this.editable || (e["aria-readonly"] = !0), e;
+    }
+  },
+  /**
+    * Because the Editor instance is initialized when mounted it does not get
+    * updated props automatically, so the ones that can change after mount have
+    * to be hooked up to the Editor's own API.
+    */
+  watch: {
+    editable(e) {
+      this.editor.setEditable(e), this.updateEditorAttributes({ "aria-readonly": !e });
+    },
+    inputClass(e) {
+      this.updateEditorAttributes({ class: e });
+    },
+    inputAriaLabel(e) {
+      this.updateEditorAttributes({ "aria-label": e });
+    },
+    extensions() {
+      this.destroyEditor(), this.createEditor();
+    },
+    modelValue(e) {
+      let t = this.getOutput();
+      this.outputFormat === "json" && (e = JSON.stringify(e), t = JSON.stringify(t)), e !== t && this.editor.commands.setContent(e, !1);
+    }
+  },
+  created() {
+    this.createEditor();
+  },
+  beforeUnmount() {
+    this.destroyEditor();
+  },
+  methods: {
+    createEditor() {
+      this.editor = new Ie({
+        autofocus: this.autoFocus,
+        content: this.modelValue,
+        editable: this.editable,
+        extensions: this.extensions,
+        editorProps: {
+          attributes: {
+            ...this.inputAttrs,
+            class: this.inputClass
+          }
+        }
+      }), this.addEditorListeners();
+    },
+    destroyEditor() {
+      this.editor.destroy();
+    },
+    /**
+     * The Editor exposes event hooks that we have to map our emits into. See
+     * https://tiptap.dev/api/events for all events.
+     */
+    addEditorListeners() {
+      this.editor.on("update", () => {
+        const e = this.getOutput();
+        this.$emit("input", e), this.$emit("update:modelValue", e);
+      }), this.editor.on("focus", ({ event: e }) => {
+        this.$emit("focus", e);
+      }), this.editor.on("blur", ({ event: e }) => {
+        this.$emit("blur", e);
+      });
+    },
+    getOutput() {
+      switch (this.outputFormat) {
+        case "json":
+          return this.editor.getJSON();
+        case "html":
+          return this.editor.getHTML();
+        case "text":
+        default:
+          return this.editor.getText();
+      }
+    },
+    getExtension(e, t) {
+      var n;
+      return typeof t == "boolean" ? e : (n = e.configure) == null ? void 0 : n.call(e, t);
+    },
+    updateEditorAttributes(e) {
+      this.editor.setOptions({ editorProps: { attributes: e } });
+    },
+    focusEditor() {
+      this.editor.commands.focus();
+    }
+  }
+};
+function ys(e, t, n, i, o, s) {
+  const r = d("editor-content");
+  return a(), h(r, {
+    editor: o.editor,
+    "data-qa": "dt-rich-text-editor"
+  }, null, 8, ["editor"]);
+}
+const _s = /* @__PURE__ */ v(gs, [["render", ys]]);
+const vs = {
+  name: "DtRecipeMessageInput",
+  components: {
+    DtButton: N,
+    DtEmojiPicker: Ke,
+    DtIcon: A,
+    DtInput: ze,
+    DtNotice: Tn,
+    DtPopover: In,
+    DtRichTextEditor: _s,
+    DtTooltip: it
+  },
+  mixins: [],
+  inheritAttrs: !1,
+  props: {
+    /**
+     * Value of the input. The object format should match TipTap's JSON
+     * document structure: https://tiptap.dev/guide/output#option-1-json
+     */
+    modelValue: {
+      type: [Object, String],
+      default: ""
+    },
+    /**
+     * Whether the input is editable
+     */
+    editable: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Descriptive label for the input element
+     */
+    inputAriaLabel: {
+      type: String,
+      required: !0,
+      default: ""
+    },
+    /**
+     * Additional class name for the input element. Only accepts a String value
+     * because this is passed to the editor via options. For multiple classes,
+     * join them into one string, e.g. "d-p8 d-hmx96"
+     */
+    inputClass: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Whether the input should receive focus after the component has been
+     * mounted. Either one of `start`, `end`, `all` or a Boolean or a Number.
+     * - `start`  Sets the focus to the beginning of the input
+     * - `end`    Sets the focus to the end of the input
+     * - `all`    Selects the whole contents of the input
+     * - `Number` Sets the focus to a specific position in the input
+     * - `true`   Defaults to `start`
+     * - `false`  Disables autofocus
+     * @values true, false, start, end, all, number
+     */
+    autoFocus: {
+      type: [Boolean, String, Number],
+      default: !1,
+      validator(e) {
+        return typeof e == "string" ? Ee.includes(e) : !0;
+      }
+    },
+    /**
+     * The output format that the editor uses when emitting the "@input" event.
+     * One of `text`, `json`, `html`. See https://tiptap.dev/guide/output for
+     * examples.
+     * @values text, json, html
+     */
+    outputFormat: {
+      type: String,
+      default: "text",
+      validator(e) {
+        return Se.includes(e);
+      }
+    },
+    /**
+     * Enables the Link extension and optionally passes configurations to it
+     */
+    link: {
+      type: [Boolean, Object],
+      default: !1
+    },
+    /**
+     * Placeholder text
+     */
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Disable Send Button
+     */
+    disableSend: {
+      type: Boolean,
+      default: !1
+    },
+    // Character limit props
+    /**
+     * Enable character Limit warning
+     */
+    hasCharacterLimit: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Max number of characters allowed
+     */
+    characterLimitCount: {
+      type: Number,
+      default: 1500
+    },
+    /**
+     * Number after which warning for max limit appears
+     */
+    characterLimitWarning: {
+      type: Number,
+      default: 500
+    },
+    /**
+     * Character limit warning message
+     */
+    characterLimitWarningMessage: {
+      type: String,
+      default: ""
+    },
+    // Error related props
+    /**
+     * Show error notice
+     * This should be turned to false after notice-close event is fired.
+     */
+    showNotice: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * message in the notice
+     */
+    noticeMessage: {
+      type: String,
+      default: ""
+    },
+    /**
+     * kind of notice to manage color
+     * @values base, error, info, success, warning
+     */
+    noticeKind: {
+      type: String,
+      default: "error",
+      validate(e) {
+        return z.includes(e);
+      }
+    },
+    /**
+     * Content area needs to dynamically adjust height based on the conversation area height.
+     * can be vh|px|rem|em|%
+     */
+    maxHeight: {
+      type: String,
+      default: "unset"
+    },
+    // Emoji picker props
+    /**
+     * tab labels for emoji
+     */
+    emojiTabSetLabels: {
+      type: Array,
+      default: () => [
+        "Most recently used",
+        "Smileys and people",
+        "Nature",
+        "Food",
+        "Activity",
+        "Travel",
+        "Objects",
+        "Symbols",
+        "Flags"
+      ]
+    },
+    emojiSkinSelectorButtonTooltipLabel: {
+      type: String,
+      default: "Change default skin tone"
+    },
+    emojiSearchNoResultsLabel: {
+      type: String,
+      default: "No results"
+    },
+    emojiSearchResultsLabel: {
+      type: String,
+      default: "Search results"
+    },
+    emojiSearchPlaceholderLabel: {
+      type: String,
+      default: "Search..."
+    },
+    /**
+     * Emoji button tooltip label
+     */
+    emojiTooltipMessage: {
+      type: String,
+      default: "Emoji"
+    },
+    // Aria label for buttons
+    /**
+     * Emoji button aria label
+     */
+    emojiButtonAriaLabel: {
+      type: String,
+      default: "emoji button"
+    },
+    imageButtonAriaLabel: {
+      type: String,
+      default: "image button"
+    },
+    /**
+     * Image button tooltip label
+     */
+    imageTooltipLabel: {
+      type: String,
+      default: "Attach Image"
+    },
+    sendButtonAriaLabel: {
+      type: String,
+      default: "send button"
+    },
+    /**
+     * Send button tooltip label
+     */
+    sendTooltipLabel: {
+      type: String,
+      default: "Send"
+    }
+  },
+  emits: [
+    /**
+     * Fires when send button is clicked
+     *
+     * @event submit
+     * @type {String}
+     */
+    "submit",
+    /**
+     * Fires when media is selected from image button
+     *
+     * @event select-media
+     * @type {Array}
+     */
+    "select-media",
+    /**
+     * Fires when media is dropped into the message input
+     *
+     * @event add-media
+     * @type {Array}
+     */
+    "add-media",
+    /**
+     * Fires when notice is closed by user.
+     * Listen to this event to toggle showNotice on usage.
+     *
+     * @event notice-close
+     * @type {Boolean}
+     */
+    "notice-close"
+  ],
+  data() {
+    return {
+      skinTone: "Default",
+      internalInputValue: this.modelValue,
+      // internal input content
+      hasFocus: !1,
+      imagePickerFocus: !1,
+      emojiPickerFocus: !1,
+      sendButtonFocus: !1,
+      emojiPickerOpened: !1
+    };
+  },
+  computed: {
+    inputLength() {
+      return this.internalInputValue.length;
+    },
+    displayCharacterLimitWarning() {
+      return this.hasCharacterLimit && this.characterLimitCount - this.inputLength <= this.characterLimitWarning;
+    },
+    isSendDisabled() {
+      return this.inputLength === 0 || this.disableSend || this.hasCharacterLimit && this.inputLength > this.characterLimitCount;
+    },
+    computedCloseButtonProps() {
+      return {
+        ariaLabel: "Close"
+      };
+    },
+    noticeClasses() {
+      return [
+        "dt-message-input-notice",
+        "d-ps-relative",
+        "d-t8",
+        "d-bbr0",
+        "d-pt4",
+        "d-pb8",
+        "d-pr12",
+        "d-pl16",
+        "d-bs-none",
+        "d-fs-100",
+        "d-wmx-unset"
+      ];
+    },
+    emojiPickerHovered() {
+      return this.emojiPickerFocus || this.emojiPickerOpened;
+    }
+  },
+  watch: {
+    modelValue(e) {
+      this.internalInputValue = e;
+    }
+  },
+  methods: {
+    onDrag(e) {
+      e.stopPropagation(), e.preventDefault();
+    },
+    onDrop(e) {
+      e.stopPropagation(), e.preventDefault();
+      const t = e.dataTransfer, i = Array.from(t.files).map((o) => o.name);
+      this.$emit("add-media", i);
+    },
+    onSelectEmoji(e) {
+      if (!e) {
+        this.emojiPickerOpened = !1;
+        return;
+      }
+      this.$refs.richTextEditor.editor.commands.insertContent({
+        type: "emoji",
+        attrs: {
+          code: e.shortname
+        }
+      }), this.emojiPickerOpened = !1;
+    },
+    onSelectImage() {
+      this.$refs.messageInputImageUpload.$refs.input.click();
+    },
+    onImageUpload(e) {
+      this.$emit("select-media", e);
+    },
+    toggleEmojiPicker() {
+      this.emojiPickerOpened = !this.emojiPickerOpened;
+    },
+    onSend() {
+      this.isSendDisabled || this.$emit("submit", this.internalInputValue);
+    },
+    noticeClose() {
+      this.$emit("notice-close", !0);
+    },
+    focus() {
+      this.$refs.richTextEditor.focusEditor(), this.hasFocus = !0;
+    }
+  }
+}, bs = { class: "d-ps-relative d-bar8 d-bgc-white" }, Ss = { class: "d-d-flex d-jc-space-between d-mx8 d-my4" }, Es = { class: "d-d-flex" }, Cs = { class: "d-d-flex" }, ks = {
+  key: 0,
+  class: "d-fc-error d-mr16 d-as-center dt-message-input--remaining-char",
+  "data-qa": "dt-message-input-character-limit"
+}, Is = { class: "d-d-flex d-jc-space-between d-h24 d-ai-center" }, ws = { "data-qa": "dt-message-input-footer-left" }, Os = { "data-qa": "dt-message-input-footer-right" };
+function Ts(e, t, n, i, o, s) {
+  const r = d("dt-icon"), c = d("dt-notice"), b = d("dt-rich-text-editor"), y = d("dt-button"), k = d("dt-input"), C = d("dt-tooltip"), j = d("dt-emoji-picker"), I = d("dt-popover");
+  return a(), p(me, null, [
+    n.showNotice ? (a(), h(c, {
+      key: 0,
+      "data-qa": "dt-message-input-error-notice",
+      class: _(s.noticeClasses),
+      kind: n.noticeKind,
+      "close-button-props": s.computedCloseButtonProps,
+      onClose: s.noticeClose
+    }, {
+      icon: u(() => [
+        m(r, {
+          size: "300",
+          name: "alert-circle"
+        })
+      ]),
+      default: u(() => [
+        R(E(n.noticeMessage) + " ", 1)
+      ]),
+      _: 1
+    }, 8, ["class", "kind", "close-button-props", "onClose"])) : g("", !0),
+    S("div", bs, [
+      S("div", {
+        "data-qa": "dt-message-input",
+        role: "presentation",
+        class: _(["d-d-flex d-fd-column d-bar8 d-baw1 d-ba d-c-text", { "d-bc-black-500 d-bs-sm": o.hasFocus, "d-bc-default": !o.hasFocus }]),
+        onClick: t[17] || (t[17] = (l) => e.$refs.richTextEditor.focusEditor()),
+        onDragEnter: t[18] || (t[18] = (...l) => s.onDrag && s.onDrag(...l)),
+        onDragOver: t[19] || (t[19] = (...l) => s.onDrag && s.onDrag(...l)),
+        onDrop: t[20] || (t[20] = (...l) => s.onDrop && s.onDrop(...l)),
+        onKeydown: t[21] || (t[21] = w(P((...l) => s.onSend && s.onSend(...l), ["exact"]), ["enter"])),
+        onFocusin: t[22] || (t[22] = (l) => o.hasFocus = !0),
+        onFocusout: t[23] || (t[23] = (l) => o.hasFocus = !1)
+      }, [
+        S("div", {
+          class: "d-of-auto d-mx16 d-mt8 d-mb4",
+          style: Ye({ "max-height": n.maxHeight })
+        }, [
+          m(b, L({
+            ref: "richTextEditor",
+            modelValue: o.internalInputValue,
+            "onUpdate:modelValue": t[0] || (t[0] = (l) => o.internalInputValue = l),
+            editable: n.editable,
+            "input-aria-label": n.inputAriaLabel,
+            "input-class": n.inputClass,
+            "output-format": n.outputFormat,
+            "auto-focus": n.autoFocus,
+            link: n.link,
+            placeholder: n.placeholder
+          }, e.$attrs, {
+            onFocus: t[1] || (t[1] = (l) => o.hasFocus = !0),
+            onBlur: t[2] || (t[2] = (l) => o.hasFocus = !1)
+          }), null, 16, ["modelValue", "editable", "input-aria-label", "input-class", "output-format", "auto-focus", "link", "placeholder"])
+        ], 4),
+        f(e.$slots, "middle"),
+        S("section", Ss, [
+          S("div", Es, [
+            m(C, {
+              placement: "top-start",
+              message: n.imageTooltipLabel,
+              offset: [-4, -4]
+            }, {
+              anchor: u(() => [
+                m(y, {
+                  "data-qa": "dt-message-input-image-btn",
+                  size: "sm",
+                  circle: "",
+                  kind: o.imagePickerFocus ? "default" : "muted",
+                  importance: "clear",
+                  "aria-label": n.imageButtonAriaLabel,
+                  onClick: s.onSelectImage,
+                  onMouseenter: t[3] || (t[3] = (l) => o.imagePickerFocus = !0),
+                  onMouseleave: t[4] || (t[4] = (l) => o.imagePickerFocus = !1),
+                  onFocusin: t[5] || (t[5] = (l) => o.imagePickerFocus = !0),
+                  onFocusout: t[6] || (t[6] = (l) => o.imagePickerFocus = !1)
+                }, {
+                  icon: u(() => [
+                    m(r, {
+                      name: "image",
+                      size: "300"
+                    })
+                  ]),
+                  _: 1
+                }, 8, ["kind", "aria-label", "onClick"]),
+                m(k, {
+                  ref: "messageInputImageUpload",
+                  "data-qa": "dt-message-input-image-input",
+                  type: "file",
+                  class: "d-ps-absolute",
+                  multiple: "",
+                  hidden: "",
+                  onInput: s.onImageUpload
+                }, null, 8, ["onInput"])
+              ]),
+              _: 1
+            }, 8, ["message"]),
+            m(I, {
+              "data-qa": "dt-message-input-emoji-picker-popover",
+              open: o.emojiPickerOpened,
+              "initial-focus-element": "#searchInput",
+              padding: "none",
+              onOpened: t[12] || (t[12] = (l) => {
+                o.emojiPickerOpened = l;
+              })
+            }, {
+              anchor: u(() => [
+                m(C, {
+                  message: n.emojiTooltipMessage,
+                  offset: [0, -4]
+                }, {
+                  anchor: u(() => [
+                    m(y, {
+                      "data-qa": "dt-message-input-emoji-picker-btn",
+                      size: "sm",
+                      circle: "",
+                      kind: s.emojiPickerHovered ? "default" : "muted",
+                      importance: "clear",
+                      "aria-label": n.emojiButtonAriaLabel,
+                      offset: [0, 0],
+                      onClick: s.toggleEmojiPicker,
+                      onMouseenter: t[7] || (t[7] = (l) => o.emojiPickerFocus = !0),
+                      onMouseleave: t[8] || (t[8] = (l) => o.emojiPickerFocus = !1),
+                      onFocusin: t[9] || (t[9] = (l) => o.emojiPickerFocus = !0),
+                      onFocusout: t[10] || (t[10] = (l) => o.emojiPickerFocus = !1)
+                    }, {
+                      icon: u(() => [
+                        m(r, {
+                          name: s.emojiPickerHovered ? "very-satisfied" : "satisfied",
+                          size: "300"
+                        }, null, 8, ["name"])
+                      ]),
+                      _: 1
+                    }, 8, ["kind", "aria-label", "onClick"])
+                  ]),
+                  _: 1
+                }, 8, ["message"])
+              ]),
+              content: u(() => [
+                m(j, {
+                  "tab-set-labels": n.emojiTabSetLabels,
+                  "skin-selector-button-tooltip-label": n.emojiSkinSelectorButtonTooltipLabel,
+                  "search-no-results-label": n.emojiSearchNoResultsLabel,
+                  "search-results-label": n.emojiSearchResultsLabel,
+                  "search-placeholder-label": n.emojiSearchPlaceholderLabel,
+                  "skin-tone": o.skinTone,
+                  onSkinTone: t[11] || (t[11] = (l) => o.skinTone = l),
+                  onSelectedEmoji: s.onSelectEmoji
+                }, null, 8, ["tab-set-labels", "skin-selector-button-tooltip-label", "search-no-results-label", "search-results-label", "search-placeholder-label", "skin-tone", "onSelectedEmoji"])
+              ]),
+              _: 1
+            }, 8, ["open"])
+          ]),
+          S("div", Cs, [
+            s.displayCharacterLimitWarning ? (a(), h(C, {
+              key: 0,
+              enabled: n.characterLimitWarningMessage && n.characterLimitCount - s.inputLength < 0,
+              placement: "top-end",
+              message: n.characterLimitWarningMessage,
+              offset: [10, -8]
+            }, {
+              anchor: u(() => [
+                s.displayCharacterLimitWarning ? (a(), p("p", ks, E(n.characterLimitCount - s.inputLength), 1)) : g("", !0)
+              ]),
+              _: 1
+            }, 8, ["enabled", "message"])) : g("", !0),
+            m(C, {
+              placement: "top-end",
+              message: n.sendTooltipLabel,
+              show: !s.isSendDisabled && o.sendButtonFocus,
+              offset: [6, -4]
+            }, {
+              anchor: u(() => [
+                m(y, {
+                  "data-qa": "dt-message-input-send-btn",
+                  size: "sm",
+                  kind: s.isSendDisabled ? "muted" : "default",
+                  circle: "",
+                  importance: "primary",
+                  class: _({
+                    "message-input-button__disabled d-fc-muted": s.isSendDisabled
+                  }),
+                  "aria-label": n.sendButtonAriaLabel,
+                  "aria-disabled": s.isSendDisabled,
+                  onClick: s.onSend,
+                  onMouseenter: t[13] || (t[13] = (l) => o.sendButtonFocus = !0),
+                  onMouseleave: t[14] || (t[14] = (l) => o.sendButtonFocus = !1),
+                  onFocusin: t[15] || (t[15] = (l) => o.sendButtonFocus = !0),
+                  onFocusout: t[16] || (t[16] = (l) => o.sendButtonFocus = !1)
+                }, {
+                  icon: u(() => [
+                    m(r, {
+                      name: "send",
+                      size: "300"
+                    })
+                  ]),
+                  _: 1
+                }, 8, ["kind", "class", "aria-label", "aria-disabled", "onClick"])
+              ]),
+              _: 1
+            }, 8, ["message", "show"])
+          ])
+        ])
+      ], 34),
+      S("section", Is, [
+        S("div", ws, [
+          f(e.$slots, "footerLeft")
+        ]),
+        S("div", Os, [
+          f(e.$slots, "footerRight")
+        ])
+      ])
+    ])
+  ], 64);
+}
+const Ws = /* @__PURE__ */ v(vs, [["render", Ts]]);
+export {
+  V as A,
+  xt as D,
+  F as L,
+  Yt as M,
+  z as N,
+  gn as P,
+  $ as S,
+  Mt as a,
+  Wt as b,
+  Qt as c,
+  un as d,
+  W as e,
+  In as f,
+  ge as g,
+  fn as h,
+  Tt as i,
+  X as j,
+  gt as k,
+  yt as l,
+  Y as m,
+  _t as n,
+  vt as o,
+  Z as p,
+  Tn as q,
+  J as r,
+  mn as s,
+  pn as t,
+  hn as u,
+  ht as v,
+  D as w,
+  ct as x,
+  ve as y,
+  Ws as z
+};