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

package/dist/chunks/NcRichContenteditable-D0CUoF_V.cjs

@@ -0,0 +1,653 @@
+var K = require("../assets/NcRichContenteditable-guxSvwzF.css");
+const u = require("./_l10n-CEec8lDL.cjs"), g = require("@nextcloud/router"), _ = require("./NcUserStatusIcon-Cvm2x61l.cjs"), n = require("vue"), p = require("./_plugin-vue_export-helper-CTzpuyvq.cjs"), y = require("./index-w3db8-kv.cjs");
+require("../Directives/Tooltip.cjs");
+const b = require("./emoji-DEH9dtOa.cjs");
+require("@vueuse/core");
+const h = require("./referencePickerModal-DioghF2j.cjs");
+require("../Functions/registerReference.cjs");
+require("@nextcloud/axios");
+;/* empty css                                                                      */
+require("./NcLoadingIcon-DkXGgGqQ.cjs");
+require("./NcCheckboxRadioSwitch.vue_vue_type_style_index_0_scoped_48c28b96_lang-CE3l0hQS.cjs");
+const d = require("./GenRandomId-B2O1GMbH.cjs");
+require("unist-builder");
+require("unist-util-visit");
+require("unified");
+require("remark-parse");
+require("remark-gfm");
+require("remark-breaks");
+require("remark-rehype");
+require("rehype-react");
+require("rehype-external-links");
+require("./NcEmptyContent-DmwlAinq.cjs");
+require("./NcSelect-DXYUyhQf.cjs");
+require("./NcTextField-Byh4JMan.cjs");
+require("./NcButton-CR5WPHh9.cjs");
+require("../Components/NcModal.cjs");
+require("@nextcloud/event-bus");
+const C = require("tributejs/dist/tribute.esm.js"), v = require("debounce"), T = require("string-length"), w = require("floating-vue"), m = (t) => t && t.__esModule ? t : { default: t }, A = /* @__PURE__ */ m(C), S = /* @__PURE__ */ m(v), I = /* @__PURE__ */ m(T), q = {
+  name: "NcAutoCompleteResult",
+  components: {
+    NcUserStatusIcon: _.NcUserStatusIcon
+  },
+  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(t, i) {
+      return g.generateUrl("/avatar/{user}/{size}", {
+        user: t,
+        size: i
+      });
+    }
+  }
+}, E = { class: "autocomplete-result" }, k = {
+  key: 0,
+  class: "autocomplete-result__status autocomplete-result__status--icon"
+}, V = { class: "autocomplete-result__content" }, x = ["title"], M = {
+  key: 0,
+  class: "autocomplete-result__subline"
+};
+function N(t, i, e, o, s, r) {
+  const a = n.resolveComponent("NcUserStatusIcon");
+  return n.openBlock(), n.createElementBlock("div", E, [
+    n.createElementVNode("div", {
+      class: n.normalizeClass([[e.icon, "autocomplete-result__icon--".concat(r.avatarUrl ? "with-avatar" : "")], "autocomplete-result__icon"]),
+      style: n.normalizeStyle(r.avatarUrl ? { backgroundImage: "url(".concat(r.avatarUrl, ")") } : null)
+    }, [
+      e.status.icon ? (n.openBlock(), n.createElementBlock("span", k, n.toDisplayString(e.status && e.status.icon || ""), 1)) : e.status.status && e.status.status !== "offline" ? (n.openBlock(), n.createBlock(a, {
+        key: 1,
+        class: "autocomplete-result__status",
+        status: e.status.status
+      }, null, 8, ["status"])) : n.createCommentVNode("", !0)
+    ], 6),
+    n.createElementVNode("span", V, [
+      n.createElementVNode("span", {
+        class: "autocomplete-result__title",
+        title: r.labelWithFallback
+      }, n.toDisplayString(r.labelWithFallback), 9, x),
+      e.subline ? (n.openBlock(), n.createElementBlock("span", M, n.toDisplayString(e.subline), 1)) : n.createCommentVNode("", !0)
+    ])
+  ]);
+}
+const f = /* @__PURE__ */ p._export_sfc(q, [["render", N], ["__scopeId", "data-v-9cff39ed"]]);
+u.register(u.t27, u.t30);
+const D = {
+  "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"
+}, R = ["d", "D", "p", "P", "s", "S", "x", "X", ")", "(", "|", "/"], c = [];
+R.forEach((t) => {
+  c.push(":" + t), c.push(":-" + t);
+});
+const O = {
+  name: "NcRichContenteditable",
+  directives: {
+    tooltip: w.VTooltip
+  },
+  mixins: [y.richEditor],
+  inheritAttrs: !1,
+  props: {
+    /**
+     * The ID attribute of the content editable
+     */
+    id: {
+      type: String,
+      default: () => d.GenRandomId(7)
+    },
+    /**
+     * Visual label of the contenteditable
+     */
+    label: {
+      type: String,
+      default: ""
+    },
+    modelValue: {
+      type: String,
+      default: "",
+      required: !0
+    },
+    placeholder: {
+      type: String,
+      default: u.t("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 t = d.GenRandomId(5);
+    return {
+      // Constants
+      labelId: "nc-rich-contenteditable-".concat(t, "-label"),
+      tributeId: "nc-rich-contenteditable-".concat(t, "-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 : I.default(this.localValue) > this.maxlength;
+    },
+    /**
+     * Tooltip to show if characters count is over limit
+     *
+     * @return {string}
+     */
+    tooltipString() {
+      return this.isOverMaxlength ? {
+        content: u.t("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 S.default(async (t, i) => {
+        this.autoComplete(t, i);
+      }, 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 t = this.$refs.contenteditable.innerHTML;
+      this.modelValue.trim() !== this.parseContent(t).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 t = (e) => '<div id="nc-rich-contenteditable-tribute-item-'.concat(d.GenRandomId(5), '" class="').concat(this.$style["tribute-item"], '" role="option">').concat(e, "</div>"), i = [];
+      i.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: (e) => {
+          var o;
+          return "".concat(e.id, " ").concat((o = e.label) != null ? o : e.title);
+        },
+        // Where to inject the menu popup
+        menuContainer: this.menuContainer,
+        // Popup mention autocompletion templates
+        menuItemTemplate: (e) => t(this.renderComponentHtml(e.original, f)),
+        // Hide if no results
+        noMatchTemplate: () => '<span class="hidden"></span>',
+        // Inner display of mentions
+        selectTemplate: (e) => {
+          var o;
+          return this.genSelectTemplate((o = e == null ? void 0 : e.original) == null ? void 0 : o.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 && i.push({
+        trigger: ":",
+        // Don't use the tribute search function at all
+        // We pass search results as values (see below)
+        lookup: (e, o) => o,
+        // Where to inject the menu popup
+        menuContainer: this.menuContainer,
+        // Popup mention autocompletion templates
+        menuItemTemplate: (e) => c.includes(e.original) ? e.original : t('<span class="'.concat(this.$style["tribute-item__emoji"], '">').concat(e.original.native, "</span> :").concat(e.original.short_name)),
+        // Hide if no results
+        noMatchTemplate: () => u.t("No emoji found"),
+        // Display raw emoji along with its name
+        selectTemplate: (e) => c.includes(e.original) ? e.original : (b.emojiAddRecent(e.original), e.original.native),
+        // Pass the search results as values
+        values: (e, o) => {
+          const s = b.emojiSearch(e);
+          c.includes(":" + e) && s.unshift(":" + e), o(s);
+        },
+        // 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 && i.push({
+        trigger: "/",
+        // Don't use the tribute search function at all
+        // We pass search results as values (see below)
+        lookup: (e, o) => o,
+        // Where to inject the menu popup
+        menuContainer: this.menuContainer,
+        // Popup mention autocompletion templates
+        menuItemTemplate: (e) => t('<img class="'.concat(this.$style["tribute-item__icon"], '" src="').concat(e.original.icon_url, '"> <span class="').concat(this.$style["tribute-item__title"], '">').concat(e.original.title, "</span>")),
+        // Hide if no results
+        noMatchTemplate: () => u.t("No link provider found"),
+        selectTemplate: this.getLink,
+        // Pass the search results as values
+        values: (e, o) => o(h.searchProvider(e)),
+        // 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 A.default({ collection: i }), this.tribute.attach(this.$refs.contenteditable);
+    },
+    getLink(t) {
+      return h.getLinkWithPicker(t.original.id).then((i) => {
+        const e = document.getElementById("tmp-smart-picker-result-node"), o = {
+          result: i,
+          insertText: !0
+        };
+        if (this.$emit("smart-picker-submit", o), o.insertText) {
+          const s = document.createTextNode(i);
+          e.replaceWith(s), this.setCursorAfter(s), this.updateValue(this.$refs.contenteditable.innerHTML);
+        } else
+          e.remove();
+      }).catch((i) => {
+        console.debug("Smart picker promise rejected:", i);
+        const e = document.getElementById("tmp-smart-picker-result-node");
+        this.setCursorAfter(e), e.remove();
+      }), '<span id="tmp-smart-picker-result-node"></span>';
+    },
+    setCursorAfter(t) {
+      const i = document.createRange();
+      i.setEndAfter(t), i.collapse();
+      const e = window.getSelection();
+      e.removeAllRanges(), e.addRange(i);
+    },
+    moveCursorToEnd() {
+      if (!document.createRange)
+        return;
+      const t = document.createRange();
+      t.selectNodeContents(this.$refs.contenteditable), t.collapse(!1);
+      const i = window.getSelection();
+      i.removeAllRanges(), i.addRange(t);
+    },
+    /**
+     * Re-emit the input event to the parent
+     *
+     * @param {Event} event the input event
+     */
+    onInput(t) {
+      this.updateValue(t.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(t) {
+      if (!this.canEdit)
+        return;
+      t.preventDefault();
+      const i = t.clipboardData;
+      if (this.$emit("paste", t), i.files.length !== 0 || !Object.values(i.items).find((a) => a == null ? void 0 : a.type.startsWith("text")))
+        return;
+      const e = i.getData("text"), o = window.getSelection();
+      if (!o.rangeCount) {
+        this.updateValue(e);
+        return;
+      }
+      const s = o.getRangeAt(0);
+      o.deleteFromDocument(), s.insertNode(document.createTextNode(e));
+      const r = document.createRange();
+      r.setStart(t.target, s.endOffset), r.collapse(!0), o.removeAllRanges(), o.addRange(r), 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(t) {
+      const i = this.parseContent(t);
+      this.localValue = i, this.$emit("update:modelValue", i);
+    },
+    /**
+     * Update content and local value
+     *
+     * @param {string} value the message value
+     */
+    updateContent(t) {
+      const i = this.renderContent(t);
+      this.$refs.contenteditable.innerHTML = i, this.localValue = t;
+    },
+    /**
+     * 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(t) {
+      if (!this.isFF || !window.getSelection || !this.canEdit)
+        return;
+      const i = window.getSelection(), e = t.target;
+      if (!i.isCollapsed || !i.rangeCount)
+        return;
+      const o = i.getRangeAt(i.rangeCount - 1);
+      if (o.commonAncestorContainer.nodeType === 3 && o.startOffset > 0)
+        return;
+      const s = document.createRange();
+      if (i.anchorNode !== e)
+        s.selectNodeContents(e), s.setEndBefore(i.anchorNode);
+      else if (i.anchorOffset > 0)
+        s.setEnd(e, i.anchorOffset);
+      else
+        return;
+      s.setStart(e, s.endOffset - 1);
+      const r = s.cloneContents().lastChild;
+      r && r.contentEditable === "false" && (s.deleteContents(), t.preventDefault());
+    },
+    /**
+     * Enter key pressed. Submits if not multiline
+     *
+     * @param {Event} event the keydown event
+     */
+    onEnter(t) {
+      this.multiline || this.isOverMaxlength || this.tribute.isActive || this.isComposing || (t.preventDefault(), t.stopPropagation(), this.$emit("submit", t));
+    },
+    /**
+     * Ctrl + Enter key pressed is used to submit
+     *
+     * @param {Event} event the keydown event
+     */
+    onCtrlEnter(t) {
+      this.isOverMaxlength || this.$emit("submit", t);
+    },
+    onKeyUp(t) {
+      t.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(t) {
+      this.isAutocompleteOpen = t, t ? (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 t;
+        this.autocompleteActiveId = (t = this.getTributeSelectedItem()) == null ? void 0 : t.id;
+      });
+    },
+    setupTributeIntegration() {
+      if (this.isTributeIntegrationDone)
+        return;
+      this.isTributeIntegrationDone = !0;
+      const t = this.getTributeContainer();
+      t.id = this.tributeId, t.setAttribute("role", "listbox"), t.children[0].setAttribute("role", "presentation"), this.tributeStyleMutationObserver = new MutationObserver(([{ target: e }]) => {
+        e.style.display !== "none" && this.onTributeSelectedItemWillChange();
+      }).observe(t, {
+        attributes: !0,
+        attributeFilter: ["style"]
+      }), t.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(t) {
+      t ? this.getTributeContainer().classList.add(this.$style["tribute-container--focus-visible"]) : this.getTributeContainer().classList.remove(this.$style["tribute-container--focus-visible"]);
+    }
+  }
+}, B = ["id", "contenteditable", "aria-labelledby", "aria-placeholder", "aria-controls", "aria-expanded", "aria-activedescendant"], U = ["id"];
+function $(t, i, e, o, s, r) {
+  const a = n.resolveDirective("tooltip");
+  return n.openBlock(), n.createElementBlock("div", {
+    class: n.normalizeClass(["rich-contenteditable", t.$props.class])
+  }, [
+    n.withDirectives(n.createElementVNode("div", n.mergeProps({
+      id: e.id,
+      ref: "contenteditable",
+      class: [{
+        "rich-contenteditable__input--empty": r.isEmptyValue,
+        "rich-contenteditable__input--multiline": e.multiline,
+        "rich-contenteditable__input--has-label": e.label,
+        "rich-contenteditable__input--overflow": r.isOverMaxlength,
+        "rich-contenteditable__input--disabled": e.disabled
+      }, "rich-contenteditable__input"],
+      contenteditable: r.canEdit,
+      "aria-labelledby": e.label ? o.labelId : void 0,
+      "aria-placeholder": e.placeholder,
+      "aria-multiline": "true",
+      role: "textbox",
+      "aria-haspopup": "listbox",
+      "aria-autocomplete": "inline",
+      "aria-controls": o.tributeId,
+      "aria-expanded": s.isAutocompleteOpen ? "true" : "false",
+      "aria-activedescendant": s.autocompleteActiveId
+    }, t.$attrs, {
+      onFocus: i[0] || (i[0] = (...l) => r.moveCursorToEnd && r.moveCursorToEnd(...l)),
+      onInput: i[1] || (i[1] = (...l) => r.onInput && r.onInput(...l)),
+      onCompositionstart: i[2] || (i[2] = (l) => s.isComposing = !0),
+      onCompositionend: i[3] || (i[3] = (l) => s.isComposing = !1),
+      onKeydown: [
+        i[4] || (i[4] = n.withKeys((...l) => r.onDelete && r.onDelete(...l), ["delete"])),
+        i[5] || (i[5] = n.withKeys(n.withModifiers((...l) => r.onEnter && r.onEnter(...l), ["exact"]), ["enter"])),
+        i[6] || (i[6] = n.withKeys(n.withModifiers((...l) => r.onCtrlEnter && r.onCtrlEnter(...l), ["ctrl", "exact", "stop", "prevent"]), ["enter"])),
+        i[9] || (i[9] = n.withKeys(n.withModifiers((...l) => r.onTributeArrowKeyDown && r.onTributeArrowKeyDown(...l), ["exact", "stop"]), ["up"])),
+        i[10] || (i[10] = n.withKeys(n.withModifiers((...l) => r.onTributeArrowKeyDown && r.onTributeArrowKeyDown(...l), ["exact", "stop"]), ["down"]))
+      ],
+      onPaste: i[7] || (i[7] = (...l) => r.onPaste && r.onPaste(...l)),
+      onKeyupCapture: i[8] || (i[8] = n.withModifiers((...l) => r.onKeyUp && r.onKeyUp(...l), ["stop", "prevent"])),
+      onTributeActiveTrue: i[11] || (i[11] = (l) => r.onTributeActive(!0)),
+      onTributeActiveFalse: i[12] || (i[12] = (l) => r.onTributeActive(!1))
+    }), null, 16, B), [
+      [a, r.tooltipString]
+    ]),
+    e.label ? (n.openBlock(), n.createElementBlock("div", {
+      key: 0,
+      id: o.labelId,
+      class: "rich-contenteditable__label"
+    }, n.toDisplayString(e.label), 9, U)) : n.createCommentVNode("", !0)
+  ], 2);
+}
+const j = {
+  $style: D
+}, F = /* @__PURE__ */ p._export_sfc(O, [["render", $], ["__cssModules", j], ["__scopeId", "data-v-fc292f76"]]);
+exports.NcAutoCompleteResult = f;
+exports.NcRichContenteditable = F;