@nextcloud/vue 9.0.0-alpha.1 → 9.0.0-alpha.2

package/dist/chunks/NcRichContenteditable-B5yMDhrw.mjs

@@ -0,0 +1,664 @@
+import "../assets/NcRichContenteditable-guxSvwzF.css";
+import { r as v, v as C, B as T, a as b } from "./_l10n-D1NkaqfQ.mjs";
+import { generateUrl as A } from "@nextcloud/router";
+import { N as w } from "./NcUserStatusIcon-CyAVexsF.mjs";
+import { resolveComponent as S, openBlock as a, createElementBlock as d, createElementVNode as p, normalizeClass as _, normalizeStyle as I, toDisplayString as h, createBlock as E, createCommentVNode as g, resolveDirective as x, withDirectives as k, mergeProps as V, withKeys as u, withModifiers as c } from "vue";
+import { _ as y } from "./_plugin-vue_export-helper-CHgC5LLL.mjs";
+import { r as D } from "./index-DiIhxz0J.mjs";
+import "../Directives/Tooltip.mjs";
+import { a as M, e as N } from "./emoji-k4gWHxrE.mjs";
+import "@vueuse/core";
+import { d as O, g as R } from "./referencePickerModal-CpPoSMom.mjs";
+import "../Functions/registerReference.mjs";
+import "@nextcloud/axios";
+/* empty css                                                                     */
+import "./NcLoadingIcon-C5Ohiq97.mjs";
+import "./NcCheckboxRadioSwitch.vue_vue_type_style_index_0_scoped_48c28b96_lang-CHo5e7Ze.mjs";
+import { G as f } from "./GenRandomId-BW3iYFf9.mjs";
+import "unist-builder";
+import "unist-util-visit";
+import "unified";
+import "remark-parse";
+import "remark-gfm";
+import "remark-breaks";
+import "remark-rehype";
+import "rehype-react";
+import "rehype-external-links";
+import "./NcEmptyContent-CYEf8Lje.mjs";
+import "./NcSelect-qdi4yiIe.mjs";
+import "./NcTextField-CSVHVoW3.mjs";
+import "./NcButton-BOed2DnZ.mjs";
+import "../Components/NcModal.mjs";
+import "@nextcloud/event-bus";
+import $ from "tributejs/dist/tribute.esm.js";
+import F from "debounce";
+import U from "string-length";
+import { VTooltip as j } from "floating-vue";
+const B = {
+  name: "NcAutoCompleteResult",
+  components: {
+    NcUserStatusIcon: w
+  },
+  props: {
+    /**
+     * @deprecated Use `label` instead
+     */
+    title: {
+      type: String,
+      required: !1,
+      default: null
+    },
+    label: {
+      type: String,
+      required: !1,
+      default: null
+    },
+    subline: {
+      type: String,
+      default: null
+    },
+    id: {
+      type: String,
+      default: null
+    },
+    icon: {
+      type: String,
+      required: !0
+    },
+    iconUrl: {
+      type: String,
+      default: null
+    },
+    source: {
+      type: String,
+      required: !0
+    },
+    status: {
+      type: [Object, Array],
+      default: () => ({})
+    }
+  },
+  computed: {
+    avatarUrl() {
+      return this.iconUrl ? this.iconUrl : this.id && this.source === "users" ? this.getAvatarUrl(this.id, 44) : null;
+    },
+    // For backwards compatibility
+    labelWithFallback() {
+      return this.label || this.title;
+    }
+  },
+  methods: {
+    getAvatarUrl(i, e) {
+      return A("/avatar/{user}/{size}", {
+        user: i,
+        size: e
+      });
+    }
+  }
+}, L = { class: "autocomplete-result" }, K = {
+  key: 0,
+  class: "autocomplete-result__status autocomplete-result__status--icon"
+}, W = { class: "autocomplete-result__content" }, P = ["title"], q = {
+  key: 0,
+  class: "autocomplete-result__subline"
+};
+function H(i, e, t, r, o, n) {
+  const l = S("NcUserStatusIcon");
+  return a(), d("div", L, [
+    p("div", {
+      class: _([[t.icon, "autocomplete-result__icon--".concat(n.avatarUrl ? "with-avatar" : "")], "autocomplete-result__icon"]),
+      style: I(n.avatarUrl ? { backgroundImage: "url(".concat(n.avatarUrl, ")") } : null)
+    }, [
+      t.status.icon ? (a(), d("span", K, h(t.status && t.status.icon || ""), 1)) : t.status.status && t.status.status !== "offline" ? (a(), E(l, {
+        key: 1,
+        class: "autocomplete-result__status",
+        status: t.status.status
+      }, null, 8, ["status"])) : g("", !0)
+    ], 6),
+    p("span", W, [
+      p("span", {
+        class: "autocomplete-result__title",
+        title: n.labelWithFallback
+      }, h(n.labelWithFallback), 9, P),
+      t.subline ? (a(), d("span", q, h(t.subline), 1)) : g("", !0)
+    ])
+  ]);
+}
+const z = /* @__PURE__ */ y(B, [["render", H], ["__scopeId", "data-v-9cff39ed"]]);
+v(T, C);
+const G = {
+  "material-design-icon": "_material-design-icon_6omw8_26",
+  "tribute-container": "_tribute-container_6omw8_34",
+  "tribute-container__item": "_tribute-container__item_6omw8_44",
+  "tribute-container--focus-visible": "_tribute-container--focus-visible_6omw8_61",
+  "tribute-container-autocomplete": "_tribute-container-autocomplete_6omw8_65",
+  "tribute-container-emoji": "_tribute-container-emoji_6omw8_71",
+  "tribute-container-link": "_tribute-container-link_6omw8_72",
+  "tribute-item": "_tribute-item_6omw8_77",
+  "tribute-item__emoji": "_tribute-item__emoji_6omw8_83",
+  "tribute-item__title": "_tribute-item__title_6omw8_96",
+  "tribute-item__icon": "_tribute-item__icon_6omw8_101"
+}, X = ["d", "D", "p", "P", "s", "S", "x", "X", ")", "(", "|", "/"], m = [];
+X.forEach((i) => {
+  m.push(":" + i), m.push(":-" + i);
+});
+const J = {
+  name: "NcRichContenteditable",
+  directives: {
+    tooltip: j
+  },
+  mixins: [D],
+  inheritAttrs: !1,
+  props: {
+    /**
+     * The ID attribute of the content editable
+     */
+    id: {
+      type: String,
+      default: () => f(7)
+    },
+    /**
+     * Visual label of the contenteditable
+     */
+    label: {
+      type: String,
+      default: ""
+    },
+    modelValue: {
+      type: String,
+      default: "",
+      required: !0
+    },
+    placeholder: {
+      type: String,
+      default: b("Write a message …")
+    },
+    autoComplete: {
+      type: Function,
+      default: () => []
+    },
+    menuContainer: {
+      type: Element,
+      default: () => document.body
+    },
+    /**
+     * Make the contenteditable looks like a textarea or not.
+     * Default looks like a single-line input.
+     * This also handle the default enter/shift+enter behaviour.
+     * if multiline, enter = newline; otherwise enter = submit
+     * shift+enter always add a new line. ctrl+enter always submits
+     */
+    multiline: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Is the content editable ?
+     */
+    contenteditable: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Disable the editing and show specific disabled design
+     */
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Max allowed length
+     */
+    maxlength: {
+      type: Number,
+      default: null
+    },
+    /**
+     * Enable or disable emoji autocompletion
+     */
+    emojiAutocomplete: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Enable or disable link autocompletion
+     */
+    linkAutocomplete: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * CSS class to apply to the root element.
+     */
+    class: {
+      type: [String, Array, Object],
+      default: ""
+    }
+  },
+  emits: [
+    "submit",
+    "paste",
+    "update:modelValue",
+    "smart-picker-submit"
+  ],
+  setup() {
+    const i = f(5);
+    return {
+      // Constants
+      labelId: "nc-rich-contenteditable-".concat(i, "-label"),
+      tributeId: "nc-rich-contenteditable-".concat(i, "-tribute"),
+      /**
+       * Non-reactive property to store Tribute instance
+       *
+       * @type {import('tributejs').default | null}
+       */
+      tribute: null,
+      tributeStyleMutationObserver: null
+    };
+  },
+  data() {
+    return {
+      // Represent the raw untrimmed text of the contenteditable
+      // serves no other purpose than to check whether the
+      // content is empty or not
+      localValue: this.modelValue,
+      // Is in text composition session in IME
+      isComposing: !1,
+      // Tribute autocomplete
+      isAutocompleteOpen: !1,
+      autocompleteActiveId: void 0,
+      isTributeIntegrationDone: !1
+    };
+  },
+  computed: {
+    /**
+     * Is the current trimmed value empty?
+     *
+     * @return {boolean}
+     */
+    isEmptyValue() {
+      return !this.localValue || this.localValue.trim() === "";
+    },
+    /**
+     * Is this Firefox? 🙄
+     *
+     * @return {boolean}
+     */
+    isFF() {
+      return !!navigator.userAgent.match(/firefox/i);
+    },
+    /**
+     * Is the current value over maxlength?
+     *
+     * @return {boolean}
+     */
+    isOverMaxlength() {
+      return this.isEmptyValue || !this.maxlength ? !1 : U(this.localValue) > this.maxlength;
+    },
+    /**
+     * Tooltip to show if characters count is over limit
+     *
+     * @return {string}
+     */
+    tooltipString() {
+      return this.isOverMaxlength ? {
+        content: b("Message limit of {count} characters reached", { count: this.maxlength }),
+        shown: !0,
+        trigger: "manual"
+      } : null;
+    },
+    /**
+     * Edit is only allowed when contenteditableis true and disabled is false
+     *
+     * @return {boolean}
+     */
+    canEdit() {
+      return this.contenteditable && !this.disabled;
+    },
+    /**
+     * Compute debounce function for the autocomplete function
+     */
+    debouncedAutoComplete() {
+      return F(async (i, e) => {
+        this.autoComplete(i, e);
+      }, 100);
+    }
+  },
+  watch: {
+    /**
+     * If the parent value change, we compare the plain text rendering
+     * If it's different, we render everything and update the main content
+     */
+    modelValue() {
+      const i = this.$refs.contenteditable.innerHTML;
+      this.modelValue.trim() !== this.parseContent(i).trim() && this.updateContent(this.modelValue);
+    }
+  },
+  mounted() {
+    this.initializeTribute(), this.updateContent(this.modelValue), this.$refs.contenteditable.contentEditable = this.canEdit;
+  },
+  beforeUnmount() {
+    this.tribute && this.tribute.detach(this.$refs.contenteditable), this.tributeStyleMutationObserver && this.tributeStyleMutationObserver.disconnect();
+  },
+  methods: {
+    /**
+     * Focus the richContenteditable
+     *
+     * @public
+     */
+    focus() {
+      this.$refs.contenteditable.focus();
+    },
+    initializeTribute() {
+      const i = (t) => '<div id="nc-rich-contenteditable-tribute-item-'.concat(f(5), '" class="').concat(this.$style["tribute-item"], '" role="option">').concat(t, "</div>"), e = [];
+      e.push({
+        // Allow spaces in the middle of mentions
+        allowSpaces: !0,
+        fillAttr: "id",
+        // Search against id and label (display name) (fallback to title for v8.0.0..8.6.1 compatibility)
+        lookup: (t) => {
+          var r;
+          return "".concat(t.id, " ").concat((r = t.label) != null ? r : t.title);
+        },
+        // Where to inject the menu popup
+        menuContainer: this.menuContainer,
+        // Popup mention autocompletion templates
+        menuItemTemplate: (t) => i(this.renderComponentHtml(t.original, z)),
+        // Hide if no results
+        noMatchTemplate: () => '<span class="hidden"></span>',
+        // Inner display of mentions
+        selectTemplate: (t) => {
+          var r;
+          return this.genSelectTemplate((r = t == null ? void 0 : t.original) == null ? void 0 : r.id);
+        },
+        // Autocompletion results
+        values: this.debouncedAutoComplete,
+        // Class added to the menu container
+        containerClass: "".concat(this.$style["tribute-container"], " ").concat(this.$style["tribute-container-autocomplete"]),
+        // Class added to each list item
+        itemClass: this.$style["tribute-container__item"]
+      }), this.emojiAutocomplete && e.push({
+        trigger: ":",
+        // Don't use the tribute search function at all
+        // We pass search results as values (see below)
+        lookup: (t, r) => r,
+        // Where to inject the menu popup
+        menuContainer: this.menuContainer,
+        // Popup mention autocompletion templates
+        menuItemTemplate: (t) => m.includes(t.original) ? t.original : i('<span class="'.concat(this.$style["tribute-item__emoji"], '">').concat(t.original.native, "</span> :").concat(t.original.short_name)),
+        // Hide if no results
+        noMatchTemplate: () => b("No emoji found"),
+        // Display raw emoji along with its name
+        selectTemplate: (t) => m.includes(t.original) ? t.original : (M(t.original), t.original.native),
+        // Pass the search results as values
+        values: (t, r) => {
+          const o = N(t);
+          m.includes(":" + t) && o.unshift(":" + t), r(o);
+        },
+        // Class added to the menu container
+        containerClass: "".concat(this.$style["tribute-container"], " ").concat(this.$style["tribute-container-emoji"]),
+        // Class added to each list item
+        itemClass: this.$style["tribute-container__item"]
+      }), this.linkAutocomplete && e.push({
+        trigger: "/",
+        // Don't use the tribute search function at all
+        // We pass search results as values (see below)
+        lookup: (t, r) => r,
+        // Where to inject the menu popup
+        menuContainer: this.menuContainer,
+        // Popup mention autocompletion templates
+        menuItemTemplate: (t) => i('<img class="'.concat(this.$style["tribute-item__icon"], '" src="').concat(t.original.icon_url, '"> <span class="').concat(this.$style["tribute-item__title"], '">').concat(t.original.title, "</span>")),
+        // Hide if no results
+        noMatchTemplate: () => b("No link provider found"),
+        selectTemplate: this.getLink,
+        // Pass the search results as values
+        values: (t, r) => r(O(t)),
+        // Class added to the menu container
+        containerClass: "".concat(this.$style["tribute-container"], " ").concat(this.$style["tribute-container-link"]),
+        // Class added to each list item
+        itemClass: this.$style["tribute-container__item"]
+      }), this.tribute = new $({ collection: e }), this.tribute.attach(this.$refs.contenteditable);
+    },
+    getLink(i) {
+      return R(i.original.id).then((e) => {
+        const t = document.getElementById("tmp-smart-picker-result-node"), r = {
+          result: e,
+          insertText: !0
+        };
+        if (this.$emit("smart-picker-submit", r), r.insertText) {
+          const o = document.createTextNode(e);
+          t.replaceWith(o), this.setCursorAfter(o), this.updateValue(this.$refs.contenteditable.innerHTML);
+        } else
+          t.remove();
+      }).catch((e) => {
+        console.debug("Smart picker promise rejected:", e);
+        const t = document.getElementById("tmp-smart-picker-result-node");
+        this.setCursorAfter(t), t.remove();
+      }), '<span id="tmp-smart-picker-result-node"></span>';
+    },
+    setCursorAfter(i) {
+      const e = document.createRange();
+      e.setEndAfter(i), e.collapse();
+      const t = window.getSelection();
+      t.removeAllRanges(), t.addRange(e);
+    },
+    moveCursorToEnd() {
+      if (!document.createRange)
+        return;
+      const i = document.createRange();
+      i.selectNodeContents(this.$refs.contenteditable), i.collapse(!1);
+      const e = window.getSelection();
+      e.removeAllRanges(), e.addRange(i);
+    },
+    /**
+     * Re-emit the input event to the parent
+     *
+     * @param {Event} event the input event
+     */
+    onInput(i) {
+      this.updateValue(i.target.innerHTML);
+    },
+    /**
+     * When pasting, sanitize the content, extract text
+     * and render it again
+     *
+     * @param {Event} event the paste event
+     * @fires Event paste the original paste event
+     */
+    onPaste(i) {
+      if (!this.canEdit)
+        return;
+      i.preventDefault();
+      const e = i.clipboardData;
+      if (this.$emit("paste", i), e.files.length !== 0 || !Object.values(e.items).find((l) => l == null ? void 0 : l.type.startsWith("text")))
+        return;
+      const t = e.getData("text"), r = window.getSelection();
+      if (!r.rangeCount) {
+        this.updateValue(t);
+        return;
+      }
+      const o = r.getRangeAt(0);
+      r.deleteFromDocument(), o.insertNode(document.createTextNode(t));
+      const n = document.createRange();
+      n.setStart(i.target, o.endOffset), n.collapse(!0), r.removeAllRanges(), r.addRange(n), this.updateValue(this.$refs.contenteditable.innerHTML);
+    },
+    /**
+     * Update the value text from the provided html
+     *
+     * @param {string} htmlOrText the html content (or raw text with @mentions)
+     */
+    updateValue(i) {
+      const e = this.parseContent(i);
+      this.localValue = e, this.$emit("update:modelValue", e);
+    },
+    /**
+     * Update content and local value
+     *
+     * @param {string} value the message value
+     */
+    updateContent(i) {
+      const e = this.renderContent(i);
+      this.$refs.contenteditable.innerHTML = e, this.localValue = i;
+    },
+    /**
+     * Because FF have a decade old bug preventing contenteditable=false
+     * to properly be deleted on backspace, we have to hack 👀
+     * https://stackoverflow.com/a/59383394/3885878
+     * https://stackoverflow.com/a/30574622
+     *
+     * @param {Event} event the delete keydown event
+     */
+    onDelete(i) {
+      if (!this.isFF || !window.getSelection || !this.canEdit)
+        return;
+      const e = window.getSelection(), t = i.target;
+      if (!e.isCollapsed || !e.rangeCount)
+        return;
+      const r = e.getRangeAt(e.rangeCount - 1);
+      if (r.commonAncestorContainer.nodeType === 3 && r.startOffset > 0)
+        return;
+      const o = document.createRange();
+      if (e.anchorNode !== t)
+        o.selectNodeContents(t), o.setEndBefore(e.anchorNode);
+      else if (e.anchorOffset > 0)
+        o.setEnd(t, e.anchorOffset);
+      else
+        return;
+      o.setStart(t, o.endOffset - 1);
+      const n = o.cloneContents().lastChild;
+      n && n.contentEditable === "false" && (o.deleteContents(), i.preventDefault());
+    },
+    /**
+     * Enter key pressed. Submits if not multiline
+     *
+     * @param {Event} event the keydown event
+     */
+    onEnter(i) {
+      this.multiline || this.isOverMaxlength || this.tribute.isActive || this.isComposing || (i.preventDefault(), i.stopPropagation(), this.$emit("submit", i));
+    },
+    /**
+     * Ctrl + Enter key pressed is used to submit
+     *
+     * @param {Event} event the keydown event
+     */
+    onCtrlEnter(i) {
+      this.isOverMaxlength || this.$emit("submit", i);
+    },
+    onKeyUp(i) {
+      i.stopImmediatePropagation();
+    },
+    /**
+     * Get HTML element with Tribute.js container
+     * @return {HTMLElement}
+     */
+    getTributeContainer() {
+      return this.tribute.menu;
+    },
+    /**
+     * Get the currently selected item element id in Tribute.js container
+     * @return {HTMLElement}
+     */
+    getTributeSelectedItem() {
+      return this.getTributeContainer().querySelector('.highlight [id^="nc-rich-contenteditable-tribute-item-"]');
+    },
+    /**
+     * Handle Tribute activation
+     * @param {boolean} isActive - is active
+     */
+    onTributeActive(i) {
+      this.isAutocompleteOpen = i, i ? (this.getTributeContainer().setAttribute("class", this.tribute.current.collection.containerClass || this.$style["tribute-container"]), this.setupTributeIntegration()) : (this.debouncedAutoComplete.clear(), this.autocompleteActiveId = void 0, this.setTributeFocusVisible(!1));
+    },
+    onTributeArrowKeyDown() {
+      this.isAutocompleteOpen && (this.setTributeFocusVisible(!0), this.onTributeSelectedItemWillChange());
+    },
+    onTributeSelectedItemWillChange() {
+      requestAnimationFrame(() => {
+        var i;
+        this.autocompleteActiveId = (i = this.getTributeSelectedItem()) == null ? void 0 : i.id;
+      });
+    },
+    setupTributeIntegration() {
+      if (this.isTributeIntegrationDone)
+        return;
+      this.isTributeIntegrationDone = !0;
+      const i = this.getTributeContainer();
+      i.id = this.tributeId, i.setAttribute("role", "listbox"), i.children[0].setAttribute("role", "presentation"), this.tributeStyleMutationObserver = new MutationObserver(([{ target: t }]) => {
+        t.style.display !== "none" && this.onTributeSelectedItemWillChange();
+      }).observe(i, {
+        attributes: !0,
+        attributeFilter: ["style"]
+      }), i.addEventListener("mousemove", () => {
+        this.setTributeFocusVisible(!1), this.onTributeSelectedItemWillChange();
+      }, { passive: !0 });
+    },
+    /**
+     * Set tribute-container--focus-visible class on the Tribute container when the user navigates the listbox via keyboard.
+     *
+     * Because the real focus is kept on the textbox, we cannot use the :focus-visible pseudo-class
+     * to style selected options in the autocomplete listbox.
+     *
+     * @param {boolean} withFocusVisible - should the focus-visible class be added
+     */
+    setTributeFocusVisible(i) {
+      i ? this.getTributeContainer().classList.add(this.$style["tribute-container--focus-visible"]) : this.getTributeContainer().classList.remove(this.$style["tribute-container--focus-visible"]);
+    }
+  }
+}, Q = ["id", "contenteditable", "aria-labelledby", "aria-placeholder", "aria-controls", "aria-expanded", "aria-activedescendant"], Y = ["id"];
+function Z(i, e, t, r, o, n) {
+  const l = x("tooltip");
+  return a(), d("div", {
+    class: _(["rich-contenteditable", i.$props.class])
+  }, [
+    k(p("div", V({
+      id: t.id,
+      ref: "contenteditable",
+      class: [{
+        "rich-contenteditable__input--empty": n.isEmptyValue,
+        "rich-contenteditable__input--multiline": t.multiline,
+        "rich-contenteditable__input--has-label": t.label,
+        "rich-contenteditable__input--overflow": n.isOverMaxlength,
+        "rich-contenteditable__input--disabled": t.disabled
+      }, "rich-contenteditable__input"],
+      contenteditable: n.canEdit,
+      "aria-labelledby": t.label ? r.labelId : void 0,
+      "aria-placeholder": t.placeholder,
+      "aria-multiline": "true",
+      role: "textbox",
+      "aria-haspopup": "listbox",
+      "aria-autocomplete": "inline",
+      "aria-controls": r.tributeId,
+      "aria-expanded": o.isAutocompleteOpen ? "true" : "false",
+      "aria-activedescendant": o.autocompleteActiveId
+    }, i.$attrs, {
+      onFocus: e[0] || (e[0] = (...s) => n.moveCursorToEnd && n.moveCursorToEnd(...s)),
+      onInput: e[1] || (e[1] = (...s) => n.onInput && n.onInput(...s)),
+      onCompositionstart: e[2] || (e[2] = (s) => o.isComposing = !0),
+      onCompositionend: e[3] || (e[3] = (s) => o.isComposing = !1),
+      onKeydown: [
+        e[4] || (e[4] = u((...s) => n.onDelete && n.onDelete(...s), ["delete"])),
+        e[5] || (e[5] = u(c((...s) => n.onEnter && n.onEnter(...s), ["exact"]), ["enter"])),
+        e[6] || (e[6] = u(c((...s) => n.onCtrlEnter && n.onCtrlEnter(...s), ["ctrl", "exact", "stop", "prevent"]), ["enter"])),
+        e[9] || (e[9] = u(c((...s) => n.onTributeArrowKeyDown && n.onTributeArrowKeyDown(...s), ["exact", "stop"]), ["up"])),
+        e[10] || (e[10] = u(c((...s) => n.onTributeArrowKeyDown && n.onTributeArrowKeyDown(...s), ["exact", "stop"]), ["down"]))
+      ],
+      onPaste: e[7] || (e[7] = (...s) => n.onPaste && n.onPaste(...s)),
+      onKeyupCapture: e[8] || (e[8] = c((...s) => n.onKeyUp && n.onKeyUp(...s), ["stop", "prevent"])),
+      onTributeActiveTrue: e[11] || (e[11] = (s) => n.onTributeActive(!0)),
+      onTributeActiveFalse: e[12] || (e[12] = (s) => n.onTributeActive(!1))
+    }), null, 16, Q), [
+      [l, n.tooltipString]
+    ]),
+    t.label ? (a(), d("div", {
+      key: 0,
+      id: r.labelId,
+      class: "rich-contenteditable__label"
+    }, h(t.label), 9, Y)) : g("", !0)
+  ], 2);
+}
+const tt = {
+  $style: G
+}, Ft = /* @__PURE__ */ y(J, [["render", Z], ["__cssModules", tt], ["__scopeId", "data-v-fc292f76"]]);
+export {
+  z as N,
+  Ft as a
+};