@dialpad/dialtone 9.35.0-beta.2 → 9.36.0

package/dist/vue2/lib/rich-text-editor.cjs

@@ -0,0 +1,1728 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue2 = require("@tiptap/vue-2");
+const Blockquote = require("@tiptap/extension-blockquote");
+const CodeBlock = require("@tiptap/extension-code-block");
+const Document = require("@tiptap/extension-document");
+const HardBreak = require("@tiptap/extension-hard-break");
+const Paragraph = require("@tiptap/extension-paragraph");
+const Placeholder = require("@tiptap/extension-placeholder");
+const Bold = require("@tiptap/extension-bold");
+const BulletList = require("@tiptap/extension-bullet-list");
+const Italic = require("@tiptap/extension-italic");
+const TipTapLink = require("@tiptap/extension-link");
+const ListItem = require("@tiptap/extension-list-item");
+const OrderedList = require("@tiptap/extension-ordered-list");
+const Strike = require("@tiptap/extension-strike");
+const Underline = require("@tiptap/extension-underline");
+const Text = require("@tiptap/extension-text");
+const TextAlign = require("@tiptap/extension-text-align");
+const core = require("@tiptap/core");
+const _pluginVue2_normalizer = require("../chunks/_plugin-vue2_normalizer-1aBeR4AK.js");
+const lib_emoji = require("./emoji.cjs");
+const common_emoji = require("../common/emoji.cjs");
+const state = require("@tiptap/pm/state");
+const Suggestion = require("@tiptap/suggestion");
+const dialtoneEmojis = require("@dialpad/dialtone-emojis");
+const lib_listItem = require("./list-item.cjs");
+const lib_stack = require("./stack.cjs");
+const tippy = require("tippy.js");
+const common_utils = require("../common/utils.cjs");
+const Mention = require("@tiptap/extension-mention");
+const lib_link = require("./link.cjs");
+const lib_avatar = require("./avatar.cjs");
+const DtIconHash = require("@dialpad/dialtone-icons/vue2/hash");
+const DtIconLock = require("@dialpad/dialtone-icons/vue2/lock");
+const emojiRegex = require("emoji-regex");
+require("./skeleton.cjs");
+require("../chunks/icon_constants-QYpmdE0R.js");
+require("@dialpad/dialtone-icons/icons.json");
+require("emoji-toolkit/emoji_strategy.json");
+require("../chunks/list_item_constants-EiqkqZvP.js");
+require("./item-layout.cjs");
+require("./icon.cjs");
+require("@dialpad/dialtone-icons/vue2");
+require("../chunks/stack_constants-SMzMWnAQ.js");
+require("../common/constants.cjs");
+require("vue");
+require("../chunks/link_constants-Huj7D_hm.js");
+require("./presence.cjs");
+const _sfc_main$9 = {
+  name: "EmojiComponent",
+  components: {
+    NodeViewWrapper: vue2.NodeViewWrapper,
+    DtEmoji: lib_emoji.DtEmoji
+  },
+  props: vue2.nodeViewProps
+};
+var _sfc_render$9 = function render() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("node-view-wrapper", { staticClass: "d-d-inline-block d-va-bottom d-lh0" }, [_c("dt-emoji", { attrs: { "size": "500", "code": _vm.node.attrs.code } })], 1);
+};
+var _sfc_staticRenderFns$9 = [];
+var __component__$9 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$9,
+  _sfc_render$9,
+  _sfc_staticRenderFns$9,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const EmojiComponent = __component__$9.exports;
+const _sfc_main$8 = {
+  name: "SuggestionList",
+  components: {
+    DtListItem: lib_listItem.DtListItem
+  },
+  props: {
+    items: {
+      type: Array,
+      required: true
+    },
+    command: {
+      type: Function,
+      required: true
+    },
+    itemComponent: {
+      type: Object,
+      required: true
+    },
+    itemType: {
+      type: String,
+      required: true
+    }
+  },
+  data() {
+    return {
+      selectedIndex: 0
+    };
+  },
+  watch: {
+    items() {
+      this.selectedIndex = 0;
+    }
+  },
+  methods: {
+    onKeyDown({ event }) {
+      if (event.key === "ArrowUp") {
+        this.upHandler();
+        return true;
+      }
+      if (event.key === "ArrowDown") {
+        this.downHandler();
+        return true;
+      }
+      if (event.key === "Enter" || event.key === "Tab") {
+        event.preventDefault();
+        this.selectHandler();
+        event.stopPropagation();
+        return true;
+      }
+      return false;
+    },
+    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 activeElement = this.$refs.suggestionList.querySelector(".dt-list-item--highlighted");
+      if (activeElement) {
+        activeElement.scrollIntoView({
+          behaviour: "smooth",
+          block: "center"
+        });
+      }
+    },
+    selectHandler() {
+      this.selectItem(this.selectedIndex);
+    },
+    selectItem(index) {
+      const item = this.items[index];
+      switch (this.itemType) {
+        case "emoji":
+          this.command(item);
+          return;
+        case "mention":
+          this.command({ name: item.name, id: item.id, avatarSrc: item.avatarSrc });
+          break;
+        case "channel":
+          this.command({ name: item.name, id: item.id });
+          break;
+        case "slash-command":
+          this.command({ command: item.command });
+          break;
+      }
+    }
+  }
+};
+var _sfc_render$8 = function render2() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "d-popover__dialog" }, [_c("ul", { directives: [{ name: "show", rawName: "v-show", value: _vm.items.length, expression: "items.length" }], ref: "suggestionList", staticClass: "dt-suggestion-list" }, _vm._l(_vm.items, function(item, index) {
+    return _c("dt-list-item", { key: item.id, class: [
+      "dt-suggestion-list--item",
+      { "dt-list-item--highlighted": index === _vm.selectedIndex }
+    ], attrs: { "navigation-type": "arrow-keys" }, on: { "click": function($event) {
+      return _vm.selectItem(index);
+    }, "keydown": function($event) {
+      $event.preventDefault();
+      $event.stopPropagation();
+      return _vm.onKeyDown.apply(null, arguments);
+    } } }, [_c(_vm.itemComponent, { tag: "component", attrs: { "item": item } })], 1);
+  }), 1)]);
+};
+var _sfc_staticRenderFns$8 = [];
+var __component__$8 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$8,
+  _sfc_render$8,
+  _sfc_staticRenderFns$8,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const SuggestionList = __component__$8.exports;
+const _sfc_main$7 = {
+  name: "EmojiSuggestion",
+  components: {
+    DtEmoji: lib_emoji.DtEmoji,
+    DtStack: lib_stack.DtStack
+  },
+  props: {
+    item: {
+      type: Object,
+      required: true
+    }
+  }
+};
+var _sfc_render$7 = function render3() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("dt-stack", { attrs: { "direction": "row", "gap": "400" } }, [_c("dt-emoji", { attrs: { "size": "200", "code": _vm.item.code } }), _vm._v(" " + _vm._s(_vm.item.code) + " ")], 1);
+};
+var _sfc_staticRenderFns$7 = [];
+var __component__$7 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$7,
+  _sfc_render$7,
+  _sfc_staticRenderFns$7,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const EmojiSuggestion = __component__$7.exports;
+const suggestionOptions = {
+  items: ({ query }) => {
+    if (query.length < 2) {
+      return [];
+    }
+    const emojiList = Object.values(dialtoneEmojis.emojisIndexed);
+    const filteredEmoji = emojiList.filter(function(item) {
+      if (item.shortname.substring(1, item.shortname.length - 1).startsWith(query.toLowerCase())) {
+        return true;
+      }
+      return false;
+    });
+    return filteredEmoji.map((item) => {
+      return { id: item.unicode_character, code: item.shortname };
+    });
+  },
+  command: ({ editor, range, props }) => {
+    var _a, _b;
+    const nodeAfter = editor.view.state.selection.$to.nodeAfter;
+    const overrideSpace = (_a = nodeAfter == null ? void 0 : nodeAfter.text) == null ? void 0 : _a.startsWith(" ");
+    if (overrideSpace) {
+      range.to += 1;
+    }
+    editor.chain().focus().insertContentAt(range, [
+      {
+        type: "emoji",
+        attrs: props
+      },
+      {
+        type: "text",
+        text: " "
+      }
+    ]).run();
+    (_b = window.getSelection()) == null ? void 0 : _b.collapseToEnd();
+  },
+  render: () => {
+    let component;
+    let popup;
+    return {
+      onStart: (props) => {
+        component = new vue2.VueRenderer(SuggestionList, {
+          parent: void 0,
+          propsData: {
+            itemComponent: EmojiSuggestion,
+            itemType: "emoji",
+            ...props
+          },
+          editor: props.editor
+        });
+        if (!props.clientRect) {
+          return;
+        }
+        popup = tippy("body", {
+          getReferenceClientRect: props.clientRect,
+          appendTo: () => document.body,
+          content: component.element,
+          showOnCreate: true,
+          interactive: true,
+          trigger: "manual",
+          placement: "top-start",
+          contentElement: null,
+          zIndex: 650
+        });
+      },
+      onUpdate(props) {
+        component.updateProps(props);
+        if (!props.clientRect) {
+          return;
+        }
+        popup[0].setProps({
+          getReferenceClientRect: props.clientRect
+        });
+      },
+      onKeyDown(props) {
+        var _a;
+        if (props.event.key === "Escape") {
+          popup[0].hide();
+          return true;
+        }
+        return (_a = component.ref) == null ? void 0 : _a.onKeyDown(props);
+      },
+      onExit() {
+        popup[0].destroy();
+        component.destroy();
+      }
+    };
+  }
+};
+const EmojiPluginKey = new state.PluginKey("emoji");
+const inputShortCodeRegex = new RegExp("(^| |(?<=:))(:\\w+:)$");
+const inputUnicodeRegex = /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])$/;
+const pasteUnicodeRegex = /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g;
+const inputRuleMatch = (match) => {
+  if (match && common_emoji.codeToEmojiData(match[0])) {
+    const text = match[2] || match[0];
+    return {
+      index: match.index,
+      text,
+      match
+    };
+  }
+};
+const shortCodePasteMatch = (text) => {
+  const matches = [...text.matchAll(common_emoji.emojiShortCodeRegex)];
+  return matches.filter((match) => common_emoji.codeToEmojiData(match[0])).map((match) => ({
+    index: match.index,
+    text: match[0],
+    match
+  }));
+};
+const Emoji = core.Node.create({
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      suggestion: {
+        char: ":",
+        pluginKey: EmojiPluginKey
+      }
+    };
+  },
+  name: "emoji",
+  group: "inline",
+  inline: true,
+  selectable: true,
+  addNodeView() {
+    return vue2.VueNodeViewRenderer(EmojiComponent);
+  },
+  addAttributes() {
+    return {
+      code: {
+        default: null
+      },
+      id: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "emoji-component"
+      }
+    ];
+  },
+  renderText({ node }) {
+    return node.attrs.code;
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["emoji-component", core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  addInputRules() {
+    return [
+      // shortcode input
+      core.nodeInputRule({
+        find: (text) => {
+          const match = text.match(inputShortCodeRegex);
+          if (!match)
+            return;
+          return inputRuleMatch(match);
+        },
+        type: this.type,
+        getAttributes(attrs) {
+          return {
+            code: attrs[0]
+          };
+        }
+      }),
+      core.nodeInputRule({
+        find: (text) => {
+          const match = text.match(inputUnicodeRegex);
+          if (!match)
+            return;
+          return inputRuleMatch(match);
+        },
+        type: this.type,
+        getAttributes(attrs) {
+          const unicode = common_emoji.codeToEmojiData(attrs[0]).unicode_output;
+          const emoji = String.fromCodePoint(parseInt(unicode, 16));
+          return {
+            code: emoji,
+            label: "emoji"
+          };
+        }
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      core.nodePasteRule({
+        find: shortCodePasteMatch,
+        type: this.type,
+        getAttributes(attrs) {
+          return {
+            code: attrs[0]
+          };
+        }
+      }),
+      core.nodePasteRule({
+        find: pasteUnicodeRegex,
+        type: this.type,
+        getAttributes(attrs) {
+          return {
+            code: attrs[0]
+          };
+        }
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      Suggestion({
+        editor: this.editor,
+        ...this.options.suggestion,
+        ...suggestionOptions
+      })
+    ];
+  }
+});
+function getRegexMatches(text, regex, validator = () => true) {
+  const matches = [];
+  regex.lastIndex = 0;
+  let match;
+  while (match = regex.exec(text)) {
+    if (validator(text, match)) {
+      matches.push(match);
+    }
+  }
+  return matches;
+}
+function hasValidPrefix(text, match) {
+  return !["#", "@"].includes(text.charAt(match.index)) && !["#", "@"].includes(text.charAt(match.index - 1));
+}
+function trimEndPunctiation(string) {
+  const endPunctuationRegex = new RegExp(
+    "(?:" + [
+      `[!?.,:;'"]`,
+      "(?:&|&amp;)(?:lt|gt|quot|apos|raquo|laquo|rsaquo|lsaquo);)+$"
+    ].join("|"),
+    "g"
+  );
+  return string.replace(endPunctuationRegex, "");
+}
+function getWordAt(text, index) {
+  const left = text.slice(0, index + 1).search(/\S+\s*$/);
+  const right = text.slice(index).search(/\s/);
+  if (right < 0) {
+    const word = text.slice(left);
+    return {
+      text: word,
+      from: left,
+      to: left + word.length
+    };
+  }
+  return {
+    text: text.slice(left, right + index),
+    from: left,
+    to: right + index
+  };
+}
+function getWordAtUntil(text, index, direction, regex) {
+  const word = getWordAt(text, index);
+  regex.lastIndex = 0;
+  if (!regex.test(word.text)) {
+    return word;
+  }
+  const newIndex = direction === "left" ? word.from - 1 : word.to + 1;
+  if (newIndex <= 0 || newIndex >= text.length || newIndex === index) {
+    return word;
+  }
+  return getWordAtUntil(text, newIndex, direction, regex);
+}
+function removeMarks(range, doc, tr, type) {
+  const from = Math.max(range.from - 1, 0);
+  const to = Math.min(range.to + 1, doc.content.size);
+  const marksInRange = core.getMarksBetween(from, to, doc);
+  for (const mark of marksInRange) {
+    if (mark.mark.type !== type) {
+      continue;
+    }
+    tr.removeMark(mark.from, mark.to, type);
+  }
+}
+const partialPhoneNumberRegex = common_utils.getPhoneNumberRegex(1, 15);
+function addMarks(text, pos, from, to, tr, type) {
+  if (!text) {
+    return;
+  }
+  let rangeFrom = from - pos - 1;
+  rangeFrom = rangeFrom < 0 ? 0 : rangeFrom;
+  const rangeTo = to - pos;
+  const firstWordInRange = getWordAtUntil(
+    text,
+    rangeFrom,
+    "left",
+    partialPhoneNumberRegex
+  );
+  const lastWordInRange = getWordAtUntil(
+    text,
+    rangeTo,
+    "right",
+    partialPhoneNumberRegex
+  );
+  const wordsInRange = text.slice(firstWordInRange.from, lastWordInRange.to);
+  const matches = getRegexMatches(wordsInRange, common_utils.linkRegex, hasValidPrefix);
+  matches.forEach((match) => {
+    const word = trimEndPunctiation(match[0]);
+    const from2 = pos + firstWordInRange.from + match.index + 1;
+    const to2 = from2 + word.length;
+    tr.addMark(from2, to2, type.create());
+  });
+}
+function autolink(options) {
+  let hasInitialized = false;
+  return new state.Plugin({
+    key: new state.PluginKey("autolink"),
+    appendTransaction: (transactions, oldState, newState) => {
+      const contentChanged = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
+      if (hasInitialized && !contentChanged) {
+        return;
+      }
+      const { tr } = newState;
+      const { textContent } = newState.doc;
+      if (!hasInitialized) {
+        addMarks(textContent, 0, 0, textContent.length, tr, options.type);
+      }
+      hasInitialized = true;
+      const transform = core.combineTransactionSteps(
+        oldState.doc,
+        [...transactions]
+      );
+      const changes = core.getChangedRanges(transform);
+      changes.forEach(({ oldRange, newRange }) => {
+        removeMarks(newRange, newState.doc, tr, options.type);
+        const paragraphs = core.findChildrenInRange(
+          newState.doc,
+          newRange,
+          (node) => node.isTextblock
+        );
+        paragraphs.forEach(({ node, pos }) => {
+          addMarks(
+            node.textContent,
+            pos,
+            oldRange.from,
+            newRange.to,
+            tr,
+            options.type
+          );
+        });
+      });
+      return tr;
+    }
+  });
+}
+const defaultAttributes = {
+  class: "d-link d-c-text d-d-inline-block d-wb-break-all",
+  rel: "noopener noreferrer nofollow"
+};
+const Link = core.Mark.create({
+  name: "Link",
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "a",
+      core.mergeAttributes(
+        this.options.HTMLAttributes,
+        HTMLAttributes,
+        defaultAttributes
+      ),
+      0
+    ];
+  },
+  renderText({ node }) {
+    return node.attrs.text;
+  },
+  addProseMirrorPlugins() {
+    return [
+      autolink({ type: this.type })
+    ];
+  }
+});
+const _sfc_main$6 = {
+  name: "MentionComponent",
+  components: {
+    NodeViewWrapper: vue2.NodeViewWrapper,
+    DtLink: lib_link.DtLink
+  },
+  props: vue2.nodeViewProps,
+  computed: {
+    text() {
+      return "@" + this.$props.node.attrs.name;
+    }
+  }
+};
+var _sfc_render$6 = function render4() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("node-view-wrapper", { staticClass: "d-d-inline-block" }, [_c("dt-link", { attrs: { "kind": "mention" } }, [_vm._v(" " + _vm._s(_vm.text) + " ")])], 1);
+};
+var _sfc_staticRenderFns$6 = [];
+var __component__$6 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$6,
+  _sfc_render$6,
+  _sfc_staticRenderFns$6,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const MentionComponent = __component__$6.exports;
+const mentionRegex = /@([\w.-]+)[^\w.-]?/g;
+const mentionPasteMatch = (text, suggestions) => {
+  const matches = [...text.matchAll(mentionRegex)];
+  return matches.filter((match) => suggestions.some(({ id }) => id === match[1].trim())).map((match) => {
+    let mention = match[1];
+    if (!mention.endsWith(" "))
+      mention += " ";
+    return {
+      index: match.index,
+      text: mention,
+      match
+    };
+  });
+};
+const mentionInputMatch = (text, suggestions) => {
+  const match = text.match(/@([\w.-]+)[^\w.-]$/);
+  if (!match || !suggestions.some(({ id }) => id === match[1]))
+    return;
+  return {
+    index: match.index,
+    text: match[0],
+    match
+  };
+};
+const MentionPlugin = Mention.extend({
+  name: "mention",
+  group: "inline",
+  inline: true,
+  addNodeView() {
+    return vue2.VueNodeViewRenderer(MentionComponent);
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "mention-component"
+      }
+    ];
+  },
+  addAttributes() {
+    return {
+      name: {
+        default: ""
+      },
+      avatarSrc: {
+        default: ""
+      },
+      id: {
+        default: ""
+      }
+    };
+  },
+  renderText({ node }) {
+    return `@${node.attrs.id}`;
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["mention-component", core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  addInputRules() {
+    var _a;
+    const suggestions = (_a = this.options.suggestion) == null ? void 0 : _a.items({ query: "" });
+    return [
+      core.nodeInputRule({
+        find: (text) => mentionInputMatch(text, suggestions),
+        type: this.type,
+        getAttributes(attrs) {
+          return suggestions.find(({ id }) => id === attrs[0].replace("@", "").trim());
+        }
+      })
+    ];
+  },
+  addPasteRules() {
+    var _a;
+    const suggestions = (_a = this.options.suggestion) == null ? void 0 : _a.items({ query: "" });
+    return [
+      core.nodePasteRule({
+        find: (text) => mentionPasteMatch(text, suggestions),
+        type: this.type,
+        getAttributes(attrs) {
+          return suggestions.find(({ id }) => id === attrs[0].trim());
+        }
+      })
+    ];
+  }
+}).configure({
+  suggestion: {
+    char: "@",
+    pluginKey: new state.PluginKey("mentionSuggestion")
+  }
+});
+const _sfc_main$5 = {
+  name: "ChannelComponent",
+  components: {
+    NodeViewWrapper: vue2.NodeViewWrapper,
+    DtLink: lib_link.DtLink
+  },
+  props: vue2.nodeViewProps,
+  computed: {
+    text() {
+      return "#" + this.$props.node.attrs.name;
+    }
+  }
+};
+var _sfc_render$5 = function render5() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("node-view-wrapper", { staticClass: "d-d-inline-block" }, [_c("dt-link", { attrs: { "kind": "mention" } }, [_vm._v(" " + _vm._s(_vm.text) + " ")])], 1);
+};
+var _sfc_staticRenderFns$5 = [];
+var __component__$5 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$5,
+  _sfc_render$5,
+  _sfc_staticRenderFns$5,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const ChannelComponent = __component__$5.exports;
+const channelRegex = /#([\w-]+)[^\w-]?/g;
+const channelPasteMatch = (text, suggestions) => {
+  const matches = [...text.matchAll(channelRegex)];
+  return matches.filter((match) => suggestions.some(({ id }) => id === match[1].trim())).map((match) => {
+    let channel = match[1];
+    if (!channel.endsWith(" "))
+      channel += " ";
+    return {
+      index: match.index,
+      text: channel,
+      match
+    };
+  });
+};
+const channelInputMatch = (text, suggestions) => {
+  const match = text.match(/#([\w-]+)[^\w-]$/);
+  if (!match || !suggestions.some(({ id }) => id === match[1]))
+    return;
+  return {
+    index: match.index,
+    text: match[0],
+    match
+  };
+};
+const ChannelPlugin = Mention.extend({
+  name: "channel",
+  group: "inline",
+  inline: true,
+  addNodeView() {
+    return vue2.VueNodeViewRenderer(ChannelComponent);
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "channel-component"
+      }
+    ];
+  },
+  addAttributes() {
+    return {
+      name: {
+        default: ""
+      },
+      id: {
+        default: ""
+      },
+      locked: {
+        default: false
+      }
+    };
+  },
+  renderText({ node }) {
+    return `#${node.attrs.id}`;
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["channel-component", core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  addInputRules() {
+    var _a;
+    const suggestions = (_a = this.options.suggestion) == null ? void 0 : _a.items({ query: "" });
+    return [
+      core.nodeInputRule({
+        find: (text) => channelInputMatch(text, suggestions),
+        type: this.type,
+        getAttributes(attrs) {
+          return suggestions.find(({ id }) => id === attrs[0].replace("#", "").trim());
+        }
+      })
+    ];
+  },
+  addPasteRules() {
+    var _a;
+    const suggestions = (_a = this.options.suggestion) == null ? void 0 : _a.items({ query: "" });
+    return [
+      core.nodePasteRule({
+        find: (text) => channelPasteMatch(text, suggestions),
+        type: this.type,
+        getAttributes(attrs) {
+          return suggestions.find(({ id }) => id === attrs[0].trim());
+        }
+      })
+    ];
+  }
+}).configure({
+  suggestion: {
+    char: "#",
+    pluginKey: new state.PluginKey("channelSuggestion")
+  }
+});
+const _sfc_main$4 = {
+  name: "SlashCommandsComponent",
+  components: {
+    NodeViewWrapper: vue2.NodeViewWrapper
+  },
+  props: vue2.nodeViewProps,
+  emits: ["selected-command"],
+  computed: {
+    text() {
+      return "/" + this.$props.node.attrs.command;
+    }
+  },
+  created() {
+    this.$parent.$emit("selected-command", this.$props.node.attrs.command);
+  }
+};
+var _sfc_render$4 = function render6() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("node-view-wrapper", { staticClass: "d-d-inline-block" }, [_vm._v(" " + _vm._s(_vm.text) + " ")]);
+};
+var _sfc_staticRenderFns$4 = [];
+var __component__$4 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$4,
+  _sfc_render$4,
+  _sfc_staticRenderFns$4,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const SlashCommandComponent = __component__$4.exports;
+const slashCommandPasteMatch = (text, slashCommandRegex) => {
+  const matches = [...text.matchAll(slashCommandRegex)];
+  return matches.map((match) => {
+    let slashCommand = match[2];
+    if (!slashCommand.endsWith(" "))
+      slashCommand += " ";
+    return {
+      index: match.index,
+      text: slashCommand,
+      match
+    };
+  });
+};
+const SlashCommandPlugin = Mention.extend({
+  name: "slash-commands",
+  group: "inline",
+  inline: true,
+  addNodeView() {
+    return vue2.VueNodeViewRenderer(SlashCommandComponent);
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "command-component"
+      }
+    ];
+  },
+  addAttributes() {
+    return {
+      command: {
+        default: ""
+      },
+      parametersExample: {
+        default: ""
+      },
+      description: {
+        default: ""
+      }
+    };
+  },
+  renderText({ node }) {
+    return `/${node.attrs.command}`;
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["command-component", core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  addInputRules() {
+    var _a;
+    const suggestions = (_a = this.options.suggestion) == null ? void 0 : _a.items({ query: "" }).map((suggestion) => suggestion.command);
+    const slashCommandRegex = new RegExp(`^((?:\\/)(${suggestions.join("|")})) $`);
+    return [
+      core.nodeInputRule({
+        find: slashCommandRegex,
+        type: this.type,
+        getAttributes(attrs) {
+          return { command: attrs[2] };
+        }
+      })
+    ];
+  },
+  addPasteRules() {
+    var _a;
+    const suggestions = (_a = this.options.suggestion) == null ? void 0 : _a.items({ query: "" }).map((suggestion) => suggestion.command);
+    const slashCommandRegex = new RegExp(`^((?:\\/)(${suggestions.join("|")})) ?$`, "g");
+    return [
+      core.nodePasteRule({
+        find: (text) => slashCommandPasteMatch(text, slashCommandRegex),
+        type: this.type,
+        getAttributes(attrs) {
+          return { command: attrs[0].trim() };
+        }
+      })
+    ];
+  }
+}).configure({
+  suggestion: {
+    char: "/",
+    pluginKey: new state.PluginKey("slashCommandSuggestion")
+  }
+});
+const RICH_TEXT_EDITOR_OUTPUT_FORMATS = [
+  "text",
+  "json",
+  "html"
+];
+const RICH_TEXT_EDITOR_AUTOFOCUS_TYPES = [
+  "start",
+  "end",
+  "all"
+];
+const RICH_TEXT_EDITOR_SUPPORTED_LINK_PROTOCOLS = [
+  "https",
+  "http",
+  "ftp",
+  "ftps",
+  "sftp",
+  "mailto"
+];
+const _sfc_main$3 = {
+  name: "MentionSuggestion",
+  components: {
+    DtAvatar: lib_avatar.DtAvatar,
+    DtStack: lib_stack.DtStack
+  },
+  props: {
+    item: {
+      type: Object,
+      required: true
+    }
+  },
+  computed: {
+    name() {
+      return this.item.name;
+    },
+    avatarSrc() {
+      return this.item.avatarSrc;
+    }
+  }
+};
+var _sfc_render$3 = function render7() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("dt-stack", { attrs: { "direction": "row", "gap": "400" } }, [_c("dt-avatar", { attrs: { "full-name": _vm.name, "image-src": _vm.avatarSrc, "image-alt": _vm.name, "size": "xs" } }), _vm._v(" " + _vm._s(_vm.name) + " ")], 1);
+};
+var _sfc_staticRenderFns$3 = [];
+var __component__$3 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$3,
+  _sfc_render$3,
+  _sfc_staticRenderFns$3,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const MentionSuggestion = __component__$3.exports;
+const mentionSuggestion = {
+  // 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 [] },
+  allowSpaces: true,
+  render: () => {
+    let component;
+    let popup;
+    return {
+      onStart: (props) => {
+        component = new vue2.VueRenderer(SuggestionList, {
+          parent: void 0,
+          propsData: {
+            itemComponent: MentionSuggestion,
+            itemType: "mention",
+            ...props
+          },
+          editor: props.editor
+        });
+        if (!props.clientRect) {
+          return;
+        }
+        popup = tippy("body", {
+          getReferenceClientRect: props.clientRect,
+          appendTo: () => document.body,
+          content: component.element,
+          showOnCreate: true,
+          interactive: true,
+          trigger: "manual",
+          placement: "top-start"
+        });
+      },
+      onUpdate(props) {
+        component.updateProps(props);
+        if (!props.clientRect) {
+          return;
+        }
+        popup[0].setProps({
+          getReferenceClientRect: props.clientRect
+        });
+      },
+      onKeyDown(props) {
+        if (props.event.key === "Escape") {
+          popup[0].hide();
+          return true;
+        }
+        return component == null ? void 0 : component.ref.onKeyDown(props);
+      },
+      onExit() {
+        popup[0].destroy();
+        component.destroy();
+      }
+    };
+  }
+};
+const _sfc_main$2 = {
+  name: "ChannelSuggestion",
+  components: {
+    DtStack: lib_stack.DtStack,
+    DtIconHash,
+    DtIconLock
+  },
+  props: {
+    item: {
+      type: Object,
+      required: true
+    }
+  },
+  computed: {
+    name() {
+      return this.item.name;
+    }
+  }
+};
+var _sfc_render$2 = function render8() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("dt-stack", { attrs: { "direction": "row", "gap": "400" } }, [!_vm.item.locked ? _c("dt-icon-hash", { attrs: { "size": "300" } }) : _c("dt-icon-lock", { attrs: { "size": "300" } }), _c("span", [_vm._v(_vm._s(_vm.name))])], 1);
+};
+var _sfc_staticRenderFns$2 = [];
+var __component__$2 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$2,
+  _sfc_render$2,
+  _sfc_staticRenderFns$2,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const ChannelSuggestion = __component__$2.exports;
+const channelSuggestion = {
+  // 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 [] },
+  allowSpaces: true,
+  render: () => {
+    let component;
+    let popup;
+    return {
+      onStart: (props) => {
+        component = new vue2.VueRenderer(SuggestionList, {
+          parent: void 0,
+          propsData: {
+            itemComponent: ChannelSuggestion,
+            itemType: "channel",
+            ...props
+          },
+          editor: props.editor
+        });
+        if (!props.clientRect) {
+          return;
+        }
+        popup = tippy("body", {
+          getReferenceClientRect: props.clientRect,
+          appendTo: () => document.body,
+          content: component.element,
+          showOnCreate: true,
+          interactive: true,
+          trigger: "manual",
+          placement: "top-start"
+        });
+      },
+      onUpdate(props) {
+        component.updateProps(props);
+        if (!props.clientRect) {
+          return;
+        }
+        popup[0].setProps({
+          getReferenceClientRect: props.clientRect
+        });
+      },
+      onKeyDown(props) {
+        if (props.event.key === "Escape") {
+          popup[0].hide();
+          return true;
+        }
+        return component == null ? void 0 : component.ref.onKeyDown(props);
+      },
+      onExit() {
+        popup[0].destroy();
+        component.destroy();
+      }
+    };
+  }
+};
+const _sfc_main$1 = {
+  name: "SlashCommandSuggestion",
+  props: {
+    item: {
+      type: Object,
+      required: true
+    }
+  },
+  computed: {
+    command() {
+      return this.item.command;
+    },
+    description() {
+      return this.item.description;
+    },
+    parametersExample() {
+      return this.item.parametersExample;
+    }
+  }
+};
+var _sfc_render$1 = function render9() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", [_c("div", { staticClass: "d-body--md-compact" }, [_c("span", [_vm._v("/" + _vm._s(_vm.command))]), _vm.parametersExample ? _c("span", [_vm._v(" " + _vm._s(_vm.parametersExample))]) : _vm._e()]), _c("div", { staticClass: "d-body--sm" }, [_vm._v(" " + _vm._s(_vm.description) + " ")])]);
+};
+var _sfc_staticRenderFns$1 = [];
+var __component__$1 = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main$1,
+  _sfc_render$1,
+  _sfc_staticRenderFns$1,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const SlashCommandSuggestion = __component__$1.exports;
+const slashCommandSuggestion = {
+  // 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 [] },
+  allowSpaces: true,
+  startOfLine: true,
+  render: () => {
+    let component;
+    let popup;
+    return {
+      onStart: (props) => {
+        component = new vue2.VueRenderer(SuggestionList, {
+          parent: void 0,
+          propsData: {
+            itemComponent: SlashCommandSuggestion,
+            itemType: "slash-command",
+            ...props
+          },
+          editor: props.editor
+        });
+        if (!props.clientRect) {
+          return;
+        }
+        popup = tippy("body", {
+          getReferenceClientRect: props.clientRect,
+          appendTo: () => document.body,
+          content: component.element,
+          showOnCreate: true,
+          interactive: true,
+          trigger: "manual",
+          placement: "top-start"
+        });
+      },
+      onUpdate(props) {
+        component.updateProps(props);
+        if (!props.clientRect) {
+          return;
+        }
+        popup[0].setProps({
+          getReferenceClientRect: props.clientRect
+        });
+      },
+      onKeyDown(props) {
+        if (props.event.key === "Escape") {
+          popup[0].hide();
+          return true;
+        }
+        return component == null ? void 0 : component.ref.onKeyDown(props);
+      },
+      onExit() {
+        popup[0].destroy();
+        component.destroy();
+      }
+    };
+  }
+};
+const _sfc_main = {
+  name: "DtRichTextEditor",
+  components: {
+    EditorContent: vue2.EditorContent
+  },
+  props: {
+    /**
+     * Value of the input. The object format should match TipTap's JSON
+     * document structure: https://tiptap.dev/guide/output#option-1-json
+     */
+    value: {
+      type: [Object, String],
+      default: ""
+    },
+    /**
+     * Whether the input is editable
+     */
+    editable: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * Whether the input allows for line breaks to be introduced in the text.
+     */
+    allowLineBreaks: {
+      type: Boolean,
+      default: false
+    },
+    /**
+     * Descriptive label for the input element
+     */
+    inputAriaLabel: {
+      type: String,
+      required: true
+    },
+    /**
+     * 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: false,
+      validator(autoFocus) {
+        if (typeof autoFocus === "string") {
+          return RICH_TEXT_EDITOR_AUTOFOCUS_TYPES.includes(autoFocus);
+        }
+        return true;
+      }
+    },
+    /**
+     * 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(outputFormat) {
+        return RICH_TEXT_EDITOR_OUTPUT_FORMATS.includes(outputFormat);
+      }
+    },
+    /**
+     * Placeholder text
+     */
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Enables the Link extension and optionally passes configurations to it
+     */
+    link: {
+      type: [Boolean, Object],
+      default: false
+    },
+    /**
+     * 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
+    },
+    /**
+     * 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 channels for suggestion.
+     * items({ query }) => { return [ChannelObject]; }
+     * ChannelObject format:
+     * { name: string, id: string, locked: boolean }
+     *
+     * When null, it does not add the plugin. Setting locked to true will display a lock rather than hash.
+     */
+    channelSuggestion: {
+      type: Object,
+      default: null
+    },
+    /**
+     * 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 slash commands for suggestion.
+     * items({ query }) => { return [SlashCommandObject]; }
+     * SlashCommandObject format:
+     * { command: string, description: string, parametersExample?: string }
+     * The "parametersExample" parameter is optional, and describes an example
+     * of the parameters that command can take.
+     *
+     * When null, it does not add the plugin.
+     */
+    slashCommandSuggestion: {
+      type: Object,
+      default: null
+    },
+    /**
+     * Whether the input allows for block quote.
+     */
+    allowBlockquote: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * Whether the input allows for bold to be introduced in the text.
+     */
+    allowBold: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * Whether the input allows for bullet list to be introduced in the text.
+    */
+    allowBulletList: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * Whether the input allows for italic to be introduced in the text.
+     */
+    allowItalic: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * Whether the input allows for strike to be introduced in the text.
+     */
+    allowStrike: {
+      type: Boolean,
+      default: true
+    },
+    /**
+     * Whether the input allows for underline to be introduced in the text.
+     */
+    allowUnderline: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: [
+    /**
+     * Editor input event
+     * @event input
+     * @type {String|JSON}
+     */
+    "input",
+    /**
+     * Event to sync the value with the parent
+     * @event update:value
+     * @type {String|JSON}
+     */
+    "update:value",
+    /**
+     * Editor blur event
+     * @event blur
+     * @type {FocusEvent}
+     */
+    "blur",
+    /**
+     * Editor focus event
+     * @event focus
+     * @type {FocusEvent}
+     */
+    "focus",
+    /**
+     * Fires when a slash command is selected
+     *
+     * @event selected-command
+     * @type {String}
+     */
+    "selected-command"
+  ],
+  data() {
+    return {
+      editor: null,
+      popoverOpened: false,
+      internalValue: this.value
+    };
+  },
+  computed: {
+    // eslint-disable-next-line complexity
+    extensions() {
+      const extensions = [Document, Paragraph, Text];
+      if (this.link) {
+        extensions.push(this.getExtension(Link, this.link));
+      }
+      if (this.allowBlockquote) {
+        extensions.push(Blockquote);
+      }
+      if (this.allowBold) {
+        extensions.push(Bold);
+      }
+      if (this.allowBulletList) {
+        extensions.push(BulletList);
+        extensions.push(ListItem);
+        extensions.push(OrderedList.configure({
+          itemTypeName: "listItem"
+        }));
+      }
+      if (this.allowItalic) {
+        extensions.push(Italic);
+      }
+      if (this.allowStrike) {
+        extensions.push(Strike);
+      }
+      if (this.allowUnderline) {
+        extensions.push(Underline);
+      }
+      extensions.push(
+        Placeholder.configure({ placeholder: this.placeholder })
+      );
+      if (!this.allowLineBreaks) {
+        extensions.push(
+          HardBreak.extend({
+            addKeyboardShortcuts() {
+              return {
+                Enter: () => true,
+                "Shift-Enter": () => this.editor.commands.first(({ commands }) => [
+                  () => commands.newlineInCode(),
+                  () => commands.createParagraphNear(),
+                  () => commands.liftEmptyBlock(),
+                  () => commands.splitBlock()
+                ])
+              };
+            }
+          })
+        );
+      }
+      extensions.push(TipTapLink.extend({ inclusive: false }).configure({
+        autolink: true,
+        protocols: RICH_TEXT_EDITOR_SUPPORTED_LINK_PROTOCOLS
+      }));
+      if (this.mentionSuggestion) {
+        const suggestionObject = { ...this.mentionSuggestion, ...mentionSuggestion };
+        extensions.push(MentionPlugin.configure({ suggestion: suggestionObject }));
+      }
+      if (this.channelSuggestion) {
+        const suggestionObject = { ...this.channelSuggestion, ...channelSuggestion };
+        extensions.push(ChannelPlugin.configure({ suggestion: suggestionObject }));
+      }
+      if (this.slashCommandSuggestion) {
+        const suggestionObject = { ...this.slashCommandSuggestion, ...slashCommandSuggestion };
+        extensions.push(SlashCommandPlugin.configure({ suggestion: suggestionObject }));
+      }
+      extensions.push(Emoji);
+      extensions.push(TextAlign.configure({
+        types: ["paragraph"],
+        defaultAlignment: "left"
+      }));
+      extensions.push(CodeBlock.configure({
+        HTMLAttributes: {
+          class: "dt-rich-text-editor--code-block"
+        }
+      }));
+      return extensions;
+    },
+    inputAttrs() {
+      const attrs = {
+        "aria-label": this.inputAriaLabel,
+        "aria-multiline": true,
+        role: "textbox"
+      };
+      if (!this.editable) {
+        attrs["aria-readonly"] = true;
+      }
+      return attrs;
+    }
+  },
+  /**
+    * 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(isEditable) {
+      this.editor.setEditable(isEditable);
+      this.updateEditorAttributes({ "aria-readonly": !isEditable });
+    },
+    inputClass(newClass) {
+      this.updateEditorAttributes({ class: newClass });
+    },
+    inputAriaLabel(newLabel) {
+      this.updateEditorAttributes({ "aria-label": newLabel });
+    },
+    extensions() {
+      this.destroyEditor();
+      this.createEditor();
+    },
+    value(newValue) {
+      let currentValue = this.getOutput();
+      if (this.outputFormat === "json") {
+        newValue = JSON.stringify(newValue);
+        currentValue = JSON.stringify(currentValue);
+      }
+      if (newValue === currentValue) {
+        return;
+      }
+      this.internalValue = newValue;
+      this.insertContent();
+    }
+  },
+  created() {
+    this.createEditor();
+  },
+  beforeUnmount() {
+    this.destroyEditor();
+  },
+  methods: {
+    onSelectedCommand(command) {
+      this.$emit("selected-command", command);
+    },
+    createEditor() {
+      this.editor = new vue2.Editor({
+        autofocus: this.autoFocus,
+        editable: this.editable,
+        extensions: this.extensions,
+        editorProps: {
+          attributes: {
+            ...this.inputAttrs,
+            class: this.inputClass
+          }
+        }
+      });
+      this.insertContent();
+      this.addEditorListeners();
+    },
+    /**
+     * This function is necessary as tiptap doesn't render the content passed
+     * directly through `editor.commands.setContent` the content passed down to it
+     * should be already parsed. So We're parsing the elements into it's corresponding
+     * HTML version before setting it.
+     */
+    insertContent() {
+      this.parseMentions();
+      this.parseChannels();
+      this.parseEmojis();
+      this.editor.commands.setContent(this.internalValue, true);
+    },
+    parseEmojis() {
+      const matches = new Set(
+        [...this.value.matchAll(emojiRegex()), ...this.value.matchAll(common_emoji.emojiShortCodeRegex)].map((match) => match[0].trim())
+      );
+      if (!matches)
+        return;
+      matches.forEach((match) => {
+        const emoji = common_emoji.codeToEmojiData(match);
+        if (!emoji)
+          return;
+        this.internalValue = this.internalValue.replace(new RegExp(`${match}`, "g"), `<emoji-component code="${emoji.shortname}"></emoji-component>`);
+      });
+    },
+    parseChannels() {
+      if (!this.channelSuggestion)
+        return;
+      const suggestions = this.channelSuggestion.items({ query: "" });
+      const matches = [...this.value.matchAll(channelRegex)].filter((match) => suggestions.some(({ id }) => id === match[1]));
+      if (!matches)
+        return;
+      matches.forEach((match) => {
+        const channel = suggestions.find(({ id }) => id === match[1]);
+        this.internalValue = this.internalValue.replace(
+          `#${match[1]}`,
+          /** The space at the beginning is important as tiptap removes that while rendering.
+           *  So if multiple mentions, channels or emojis are next to each other it will fail
+           */
+          ` <channel-component name="${channel.name}" id="${channel.id}"></channel-component>`
+        );
+      });
+    },
+    parseMentions() {
+      if (!this.mentionSuggestion)
+        return;
+      const suggestions = this.mentionSuggestion.items({ query: "" });
+      const matches = [...this.value.matchAll(mentionRegex)].filter((match) => suggestions.some(({ id }) => id === match[1]));
+      if (!matches)
+        return;
+      matches.forEach((match) => {
+        const mention = suggestions.find(({ id }) => id === match[1]);
+        this.internalValue = this.internalValue.replace(`@${match[1]}`, ` <mention-component name="${mention.name}" id="${mention.id}"></mention-component>`);
+      });
+    },
+    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 value = this.getOutput();
+        this.$emit("input", value);
+        this.$emit("update:value", value);
+      });
+      this.editor.on("focus", ({ event }) => {
+        this.$emit("focus", event);
+      });
+      this.editor.on("blur", ({ event }) => {
+        this.$emit("blur", event);
+      });
+    },
+    getOutput() {
+      switch (this.outputFormat) {
+        case "json":
+          return this.editor.getJSON();
+        case "html":
+          return this.editor.getHTML();
+        case "text":
+        default:
+          return this.editor.getText();
+      }
+    },
+    getExtension(extension, options) {
+      var _a;
+      if (typeof options === "boolean") {
+        return extension;
+      }
+      return (_a = extension.configure) == null ? void 0 : _a.call(extension, options);
+    },
+    updateEditorAttributes(attributes) {
+      this.editor.setOptions({ editorProps: { attributes } });
+    },
+    focusEditor() {
+      this.editor.commands.focus();
+    }
+  }
+};
+var _sfc_render = function render10() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("editor-content", { staticClass: "dt-rich-text-editor", attrs: { "editor": _vm.editor, "data-qa": "dt-rich-text-editor" }, on: { "selected-command": _vm.onSelectedCommand } });
+};
+var _sfc_staticRenderFns = [];
+var __component__ = /* @__PURE__ */ _pluginVue2_normalizer.normalizeComponent(
+  _sfc_main,
+  _sfc_render,
+  _sfc_staticRenderFns,
+  false,
+  null,
+  null,
+  null,
+  null
+);
+const DtRichTextEditor = __component__.exports;
+exports.DtRichTextEditor = DtRichTextEditor;
+exports.RICH_TEXT_EDITOR_AUTOFOCUS_TYPES = RICH_TEXT_EDITOR_AUTOFOCUS_TYPES;
+exports.RICH_TEXT_EDITOR_OUTPUT_FORMATS = RICH_TEXT_EDITOR_OUTPUT_FORMATS;
+//# sourceMappingURL=rich-text-editor.cjs.map