@edifice.io/react 2.6.8 → 2.6.9-chore-tiptap-v3.20261013175230

package/dist/node_modules/.pnpm/@tiptap_extension-floating-menu@3.32.0_@floating-ui_dom@1.6.0_@tiptap_core@3.32.0_@tiptap_pm@3.32.0__@tiptap_pm@3.32.0/node_modules/@tiptap/extension-floating-menu/dist/index.js

@@ -0,0 +1,159 @@
+import { getText, getTextSerializersFromSchema, posToDOMRect, Extension } from "@tiptap/core";
+import { flip, shift, offset, arrow, size, autoPlacement, hide, inline, computePosition } from "@floating-ui/dom";
+import { Plugin, PluginKey } from "../../../../../prosemirror-state@1.4.4/node_modules/prosemirror-state/dist/index.js";
+var FloatingMenuView = class {
+  getTextContent(node) {
+    return getText(node, { textSerializers: getTextSerializersFromSchema(this.editor.schema) });
+  }
+  get middlewares() {
+    const middlewares = [];
+    return this.floatingUIOptions.flip && middlewares.push(flip(typeof this.floatingUIOptions.flip != "boolean" ? this.floatingUIOptions.flip : void 0)), this.floatingUIOptions.shift && middlewares.push(shift(typeof this.floatingUIOptions.shift != "boolean" ? this.floatingUIOptions.shift : void 0)), this.floatingUIOptions.offset && middlewares.push(offset(typeof this.floatingUIOptions.offset != "boolean" ? this.floatingUIOptions.offset : void 0)), this.floatingUIOptions.arrow && middlewares.push(arrow(this.floatingUIOptions.arrow)), this.floatingUIOptions.size && middlewares.push(size(typeof this.floatingUIOptions.size != "boolean" ? this.floatingUIOptions.size : void 0)), this.floatingUIOptions.autoPlacement && middlewares.push(autoPlacement(typeof this.floatingUIOptions.autoPlacement != "boolean" ? this.floatingUIOptions.autoPlacement : void 0)), this.floatingUIOptions.hide && middlewares.push(hide(typeof this.floatingUIOptions.hide != "boolean" ? this.floatingUIOptions.hide : void 0)), this.floatingUIOptions.inline && middlewares.push(inline(typeof this.floatingUIOptions.inline != "boolean" ? this.floatingUIOptions.inline : void 0)), middlewares;
+  }
+  constructor({ editor, element, view, pluginKey = "floatingMenu", updateDelay = 250, resizeDelay = 60, options, appendTo, shouldShow }) {
+    var _options$scrollTarget;
+    this.preventHide = !1, this.isVisible = !1, this.scrollTarget = window, this.shouldShow = ({ view: view2, state }) => {
+      const { selection } = state, { $anchor, empty } = selection, isRootDepth = $anchor.depth === 1, isEmptyTextBlock = $anchor.parent.isTextblock && !$anchor.parent.type.spec.code && !$anchor.parent.textContent && $anchor.parent.childCount === 0 && !this.getTextContent($anchor.parent);
+      return !(!view2.hasFocus() || !empty || !isRootDepth || !isEmptyTextBlock || !this.editor.isEditable);
+    }, this.floatingUIOptions = {
+      strategy: "absolute",
+      placement: "right",
+      offset: 8,
+      flip: {},
+      shift: {},
+      arrow: !1,
+      size: !1,
+      autoPlacement: !1,
+      hide: !1,
+      inline: !1
+    }, this.updateHandler = (view2, selectionChanged, docChanged, oldState) => {
+      const { composing } = view2;
+      if (!(composing || !selectionChanged && !docChanged)) {
+        if (!this.getShouldShow(oldState)) {
+          this.hide();
+          return;
+        }
+        this.updatePosition(), this.show();
+      }
+    }, this.mousedownHandler = () => {
+      this.preventHide = !0;
+    }, this.focusHandler = () => {
+      setTimeout(() => this.update(this.editor.view));
+    }, this.blurHandler = ({ event }) => {
+      var _this$element$parentN;
+      if (this.preventHide) {
+        this.preventHide = !1;
+        return;
+      }
+      event != null && event.relatedTarget && (!((_this$element$parentN = this.element.parentNode) === null || _this$element$parentN === void 0) && _this$element$parentN.contains(event.relatedTarget)) || (event == null ? void 0 : event.relatedTarget) !== this.editor.view.dom && this.hide();
+    }, this.transactionHandler = ({ transaction: tr }) => {
+      const meta = tr.getMeta(this.pluginKey);
+      meta === "updatePosition" ? this.updatePosition() : meta && typeof meta == "object" && meta.type === "updateOptions" ? this.updateOptions(meta.options) : meta === "hide" ? this.hide() : meta === "show" && (this.updatePosition(), this.show());
+    }, this.resizeHandler = () => {
+      this.resizeDebounceTimer && clearTimeout(this.resizeDebounceTimer), this.resizeDebounceTimer = window.setTimeout(() => {
+        this.updatePosition();
+      }, this.resizeDelay);
+    }, this.editor = editor, this.element = element, this.view = view, this.pluginKey = pluginKey, this.updateDelay = updateDelay, this.resizeDelay = resizeDelay, this.appendTo = appendTo, this.scrollTarget = (_options$scrollTarget = options == null ? void 0 : options.scrollTarget) !== null && _options$scrollTarget !== void 0 ? _options$scrollTarget : window, this.floatingUIOptions = {
+      ...this.floatingUIOptions,
+      ...options
+    }, this.element.tabIndex = 0, shouldShow && (this.shouldShow = shouldShow), this.element.addEventListener("mousedown", this.mousedownHandler, { capture: !0 }), this.editor.on("focus", this.focusHandler), this.editor.on("blur", this.blurHandler), this.editor.on("transaction", this.transactionHandler), window.addEventListener("resize", this.resizeHandler), this.scrollTarget.addEventListener("scroll", this.resizeHandler), this.update(view, view.state), this.getShouldShow() && (this.show(), this.updatePosition());
+  }
+  getShouldShow(oldState) {
+    var _this$shouldShow;
+    const { state } = this.view, { selection } = state, { ranges } = selection, from = Math.min(...ranges.map((range) => range.$from.pos)), to = Math.max(...ranges.map((range) => range.$to.pos));
+    return (_this$shouldShow = this.shouldShow) === null || _this$shouldShow === void 0 ? void 0 : _this$shouldShow.call(this, {
+      editor: this.editor,
+      view: this.view,
+      state,
+      oldState,
+      from,
+      to
+    });
+  }
+  updateOptions(newProps) {
+    if (newProps.updateDelay !== void 0 && (this.updateDelay = newProps.updateDelay), newProps.resizeDelay !== void 0 && (this.resizeDelay = newProps.resizeDelay), newProps.appendTo !== void 0 && (this.appendTo = newProps.appendTo), newProps.shouldShow !== void 0 && newProps.shouldShow && (this.shouldShow = newProps.shouldShow), newProps.options !== void 0) {
+      var _newProps$options$scr;
+      const newScrollTarget = (_newProps$options$scr = newProps.options.scrollTarget) !== null && _newProps$options$scr !== void 0 ? _newProps$options$scr : window;
+      newScrollTarget !== this.scrollTarget && (this.scrollTarget.removeEventListener("scroll", this.resizeHandler), this.scrollTarget = newScrollTarget, this.scrollTarget.addEventListener("scroll", this.resizeHandler)), this.floatingUIOptions = {
+        ...this.floatingUIOptions,
+        ...newProps.options
+      };
+    }
+  }
+  updatePosition() {
+    var _this$view;
+    if (!(!((_this$view = this.view) === null || _this$view === void 0 || (_this$view = _this$view.dom) === null || _this$view === void 0) && _this$view.parentNode)) return;
+    const { selection } = this.editor.state, domRect = posToDOMRect(this.view, selection.from, selection.to);
+    computePosition({
+      getBoundingClientRect: () => domRect,
+      getClientRects: () => [domRect]
+    }, this.element, {
+      placement: this.floatingUIOptions.placement,
+      strategy: this.floatingUIOptions.strategy,
+      middleware: this.middlewares
+    }).then(({ x, y, strategy, middlewareData }) => {
+      var _middlewareData$hide, _middlewareData$hide2;
+      if (!((_middlewareData$hide = middlewareData.hide) === null || _middlewareData$hide === void 0) && _middlewareData$hide.referenceHidden || !((_middlewareData$hide2 = middlewareData.hide) === null || _middlewareData$hide2 === void 0) && _middlewareData$hide2.escaped) {
+        this.element.style.visibility = "hidden";
+        return;
+      }
+      this.element.style.visibility = "visible", this.element.style.width = "max-content", this.element.style.position = strategy, this.element.style.left = `${x}px`, this.element.style.top = `${y}px`, this.isVisible && this.floatingUIOptions.onUpdate && this.floatingUIOptions.onUpdate();
+    });
+  }
+  update(view, oldState) {
+    const selectionChanged = !(oldState != null && oldState.selection.eq(view.state.selection)), docChanged = !(oldState != null && oldState.doc.eq(view.state.doc));
+    this.updateHandler(view, selectionChanged, docChanged, oldState);
+  }
+  show() {
+    var _ref;
+    if (this.isVisible) return;
+    this.element.style.visibility = "visible", this.element.style.opacity = "1";
+    const appendToElement = typeof this.appendTo == "function" ? this.appendTo() : this.appendTo;
+    (_ref = appendToElement ?? this.view.dom.parentElement) === null || _ref === void 0 || _ref.appendChild(this.element), this.floatingUIOptions.onShow && this.floatingUIOptions.onShow(), this.isVisible = !0;
+  }
+  hide() {
+    this.isVisible && (this.element.style.visibility = "hidden", this.element.style.opacity = "0", this.element.remove(), this.floatingUIOptions.onHide && this.floatingUIOptions.onHide(), this.isVisible = !1);
+  }
+  destroy() {
+    this.hide(), this.element.removeEventListener("mousedown", this.mousedownHandler, { capture: !0 }), window.removeEventListener("resize", this.resizeHandler), this.scrollTarget.removeEventListener("scroll", this.resizeHandler), this.editor.off("focus", this.focusHandler), this.editor.off("blur", this.blurHandler), this.editor.off("transaction", this.transactionHandler), this.floatingUIOptions.onDestroy && this.floatingUIOptions.onDestroy();
+  }
+};
+const FloatingMenuPlugin = (options) => new Plugin({
+  key: typeof options.pluginKey == "string" ? new PluginKey(options.pluginKey) : options.pluginKey,
+  view: (view) => new FloatingMenuView({
+    view,
+    ...options
+  })
+});
+Extension.create({
+  name: "floatingMenu",
+  addOptions() {
+    return {
+      element: null,
+      options: {},
+      pluginKey: "floatingMenu",
+      updateDelay: void 0,
+      resizeDelay: void 0,
+      appendTo: void 0,
+      shouldShow: null
+    };
+  },
+  addCommands() {
+    return { updateFloatingMenuPosition: () => ({ tr, dispatch }) => (dispatch && tr.setMeta(this.options.pluginKey, "updatePosition"), !0) };
+  },
+  addProseMirrorPlugins() {
+    return this.options.element ? [FloatingMenuPlugin({
+      pluginKey: this.options.pluginKey,
+      editor: this.editor,
+      element: this.options.element,
+      updateDelay: this.options.updateDelay,
+      resizeDelay: this.options.resizeDelay,
+      options: this.options.options,
+      appendTo: this.options.appendTo,
+      shouldShow: this.options.shouldShow
+    })] : [];
+  }
+});
+export {
+  FloatingMenuPlugin,
+  FloatingMenuView
+};

package/dist/node_modules/.pnpm/@tiptap_react@3.32.0_@floating-ui_dom@1.6.0_@tiptap_core@3.32.0_@tiptap_pm@3.32.0__@tiptap_pm_6inmb43gajy4fnlwtngbwkv7um/node_modules/@tiptap/react/dist/menus/index.js

@@ -0,0 +1,341 @@
+import { BubbleMenuPlugin } from "@tiptap/extension-bubble-menu";
+import { useCurrentEditor } from "@tiptap/react";
+import React, { useRef, useState, useEffect, useLayoutEffect } from "react";
+import { createPortal } from "react-dom";
+import { PluginKey } from "../../../../../../prosemirror-state@1.4.4/node_modules/prosemirror-state/dist/index.js";
+import { FloatingMenuPlugin } from "../../../../../../@tiptap_extension-floating-menu@3.32.0_@floating-ui_dom@1.6.0_@tiptap_core@3.32.0_@tiptap_pm@3.32.0__@tiptap_pm@3.32.0/node_modules/@tiptap/extension-floating-menu/dist/index.js";
+function getAutoPluginKey(pluginKey, defaultName) {
+  return pluginKey ?? new PluginKey(defaultName);
+}
+const useIsomorphicLayoutEffect = typeof window < "u" ? useLayoutEffect : useEffect, PLUGIN_MANAGED_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+  "left",
+  "opacity",
+  "position",
+  "top",
+  "visibility",
+  "width"
+]), UNITLESS_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "columnCount",
+  "columns",
+  "fillOpacity",
+  "flex",
+  "flexGrow",
+  "flexShrink",
+  "fontWeight",
+  "gridArea",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnStart",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowStart",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom"
+]), ATTRIBUTE_EXCLUSIONS = /* @__PURE__ */ new Set([
+  "children",
+  "className",
+  "style"
+]), DIRECT_PROPERTY_KEYS = /* @__PURE__ */ new Set(["tabIndex"]), FORWARDED_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
+  "accessKey",
+  "autoCapitalize",
+  "contentEditable",
+  "contextMenu",
+  "dir",
+  "draggable",
+  "enterKeyHint",
+  "hidden",
+  "id",
+  "lang",
+  "nonce",
+  "role",
+  "slot",
+  "spellCheck",
+  "tabIndex",
+  "title",
+  "translate"
+]), SPECIAL_EVENT_NAMES = {
+  Blur: "focusout",
+  DoubleClick: "dblclick",
+  Focus: "focusin",
+  MouseEnter: "mouseenter",
+  MouseLeave: "mouseleave"
+};
+function isEventProp(key, value) {
+  return /^on[A-Z]/.test(key) && typeof value == "function";
+}
+function toAttributeName(key) {
+  return key.startsWith("aria-") || key.startsWith("data-"), key;
+}
+function isForwardedAttributeKey(key) {
+  return key.startsWith("aria-") || key.startsWith("data-") || FORWARDED_ATTRIBUTE_KEYS.has(key);
+}
+function toStylePropertyName(key) {
+  return key.startsWith("--") ? key : key.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function toEventConfig(key) {
+  var _SPECIAL_EVENT_NAMES$;
+  const useCapture = key.endsWith("Capture"), reactEventName = (useCapture ? key.slice(0, -7) : key).slice(2);
+  return {
+    eventName: (_SPECIAL_EVENT_NAMES$ = SPECIAL_EVENT_NAMES[reactEventName]) !== null && _SPECIAL_EVENT_NAMES$ !== void 0 ? _SPECIAL_EVENT_NAMES$ : reactEventName.toLowerCase(),
+    options: useCapture ? { capture: !0 } : void 0
+  };
+}
+function createSyntheticEvent(element, nativeEvent) {
+  let defaultPrevented = nativeEvent.defaultPrevented, propagationStopped = !1;
+  const syntheticEvent = Object.create(nativeEvent);
+  return Object.defineProperties(syntheticEvent, {
+    nativeEvent: { value: nativeEvent },
+    currentTarget: { value: element },
+    target: { value: nativeEvent.target },
+    persist: { value: () => {
+    } },
+    isDefaultPrevented: { value: () => defaultPrevented },
+    isPropagationStopped: { value: () => propagationStopped },
+    preventDefault: { value: () => {
+      defaultPrevented = !0, nativeEvent.preventDefault();
+    } },
+    stopPropagation: { value: () => {
+      propagationStopped = !0, nativeEvent.stopPropagation();
+    } }
+  }), syntheticEvent;
+}
+function isDirectPropertyKey(key) {
+  return DIRECT_PROPERTY_KEYS.has(key);
+}
+function setDirectProperty(element, key, value) {
+  if (key === "tabIndex") {
+    element.tabIndex = Number(value);
+    return;
+  }
+  element[key] = value;
+}
+function clearDirectProperty(element, key) {
+  if (key === "tabIndex") {
+    element.removeAttribute("tabindex");
+    return;
+  }
+  const propertyValue = element[key];
+  if (typeof propertyValue == "boolean") {
+    element[key] = !1;
+    return;
+  }
+  if (typeof propertyValue == "number") {
+    element[key] = 0;
+    return;
+  }
+  element[key] = "";
+}
+function toStyleValue(styleName, value) {
+  return typeof value != "number" || value === 0 || styleName.startsWith("--") || UNITLESS_STYLE_PROPERTIES.has(styleName) ? String(value) : `${value}px`;
+}
+function removeStyleProperty(element, styleName) {
+  PLUGIN_MANAGED_STYLE_PROPERTIES.has(styleName) || element.style.removeProperty(toStylePropertyName(styleName));
+}
+function applyStyleProperty(element, styleName, value) {
+  PLUGIN_MANAGED_STYLE_PROPERTIES.has(styleName) || element.style.setProperty(toStylePropertyName(styleName), toStyleValue(styleName, value));
+}
+function syncAttributes(element, prevProps, nextProps) {
+  (/* @__PURE__ */ new Set([...Object.keys(prevProps), ...Object.keys(nextProps)])).forEach((key) => {
+    if (ATTRIBUTE_EXCLUSIONS.has(key) || !isForwardedAttributeKey(key) || isEventProp(key, prevProps[key]) || isEventProp(key, nextProps[key])) return;
+    const prevValue = prevProps[key], nextValue = nextProps[key];
+    if (prevValue === nextValue) return;
+    const attributeName = toAttributeName(key);
+    if (nextValue == null || nextValue === !1) {
+      isDirectPropertyKey(key) && clearDirectProperty(element, key), element.removeAttribute(attributeName);
+      return;
+    }
+    if (nextValue === !0) {
+      isDirectPropertyKey(key) && setDirectProperty(element, key, !0), element.setAttribute(attributeName, "");
+      return;
+    }
+    if (isDirectPropertyKey(key)) {
+      setDirectProperty(element, key, nextValue);
+      return;
+    }
+    element.setAttribute(attributeName, String(nextValue));
+  });
+}
+function syncClassName(element, prevClassName, nextClassName) {
+  if (prevClassName !== nextClassName) {
+    if (nextClassName) {
+      element.className = nextClassName;
+      return;
+    }
+    element.removeAttribute("class");
+  }
+}
+function syncStyles(element, prevStyle, nextStyle) {
+  const previousStyle = prevStyle ?? {}, currentStyle = nextStyle ?? {};
+  (/* @__PURE__ */ new Set([...Object.keys(previousStyle), ...Object.keys(currentStyle)])).forEach((styleName) => {
+    const prevValue = previousStyle[styleName], nextValue = currentStyle[styleName];
+    if (prevValue !== nextValue) {
+      if (nextValue == null) {
+        removeStyleProperty(element, styleName);
+        return;
+      }
+      applyStyleProperty(element, styleName, nextValue);
+    }
+  });
+}
+function syncEventListeners(element, prevListeners, nextProps) {
+  prevListeners.forEach(({ eventName, listener, options }) => {
+    element.removeEventListener(eventName, listener, options);
+  });
+  const nextListeners = [];
+  return Object.entries(nextProps).forEach(([key, value]) => {
+    if (!isEventProp(key, value)) return;
+    const { eventName, options } = toEventConfig(key), listener = (event) => {
+      value(createSyntheticEvent(element, event));
+    };
+    element.addEventListener(eventName, listener, options), nextListeners.push({
+      eventName,
+      listener,
+      options
+    });
+  }), nextListeners;
+}
+function useMenuElementProps(element, props) {
+  const previousPropsRef = useRef({}), listenersRef = useRef([]);
+  useIsomorphicLayoutEffect(() => {
+    const previousProps = previousPropsRef.current;
+    return syncClassName(element, previousProps.className, props.className), syncStyles(element, previousProps.style, props.style), syncAttributes(element, previousProps, props), listenersRef.current = syncEventListeners(element, listenersRef.current, props), previousPropsRef.current = props, () => {
+      listenersRef.current.forEach(({ eventName, listener, options }) => {
+        element.removeEventListener(eventName, listener, options);
+      }), listenersRef.current = [];
+    };
+  }, [element, props]);
+}
+const BubbleMenu = React.forwardRef(({ pluginKey, editor, updateDelay, resizeDelay, appendTo, shouldShow = null, getReferencedVirtualElement, options, children, ...restProps }, ref) => {
+  const menuEl = useRef(document.createElement("div")), resolvedPluginKey = useRef(getAutoPluginKey(pluginKey, "bubbleMenu")).current;
+  useMenuElementProps(menuEl.current, restProps), typeof ref == "function" ? ref(menuEl.current) : ref && (ref.current = menuEl.current);
+  const { editor: currentEditor } = useCurrentEditor(), pluginEditor = editor || currentEditor, bubbleMenuPluginProps = {
+    updateDelay,
+    resizeDelay,
+    appendTo,
+    pluginKey: resolvedPluginKey,
+    shouldShow,
+    getReferencedVirtualElement,
+    options
+  }, bubbleMenuPluginPropsRef = useRef(bubbleMenuPluginProps);
+  bubbleMenuPluginPropsRef.current = bubbleMenuPluginProps;
+  const [pluginInitialized, setPluginInitialized] = useState(!1), skipFirstUpdateRef = useRef(!0);
+  return useEffect(() => {
+    if (pluginEditor != null && pluginEditor.isDestroyed) return;
+    if (!pluginEditor) {
+      console.warn("BubbleMenu component is not rendered inside of an editor component or does not have editor prop.");
+      return;
+    }
+    const bubbleMenuElement = menuEl.current;
+    bubbleMenuElement.style.visibility = "hidden", bubbleMenuElement.style.position = "absolute";
+    const plugin = BubbleMenuPlugin({
+      ...bubbleMenuPluginPropsRef.current,
+      editor: pluginEditor,
+      element: bubbleMenuElement
+    });
+    pluginEditor.registerPlugin(plugin);
+    const createdPluginKey = bubbleMenuPluginPropsRef.current.pluginKey;
+    return skipFirstUpdateRef.current = !0, setPluginInitialized(!0), () => {
+      setPluginInitialized(!1), pluginEditor.unregisterPlugin(createdPluginKey), window.requestAnimationFrame(() => {
+        bubbleMenuElement.parentNode && bubbleMenuElement.parentNode.removeChild(bubbleMenuElement);
+      });
+    };
+  }, [pluginEditor]), useEffect(() => {
+    if (!(!pluginInitialized || !pluginEditor || pluginEditor.isDestroyed)) {
+      if (skipFirstUpdateRef.current) {
+        skipFirstUpdateRef.current = !1;
+        return;
+      }
+      pluginEditor.view.dispatch(pluginEditor.state.tr.setMeta(resolvedPluginKey, {
+        type: "updateOptions",
+        options: bubbleMenuPluginPropsRef.current
+      }));
+    }
+  }, [
+    pluginInitialized,
+    pluginEditor,
+    updateDelay,
+    resizeDelay,
+    shouldShow,
+    options,
+    appendTo,
+    getReferencedVirtualElement,
+    resolvedPluginKey
+  ]), createPortal(children, menuEl.current);
+}), FloatingMenu = React.forwardRef(({ pluginKey, editor, updateDelay, resizeDelay, appendTo, shouldShow = null, options, children, ...restProps }, ref) => {
+  const menuEl = useRef(document.createElement("div")), resolvedPluginKey = useRef(getAutoPluginKey(pluginKey, "floatingMenu")).current;
+  useMenuElementProps(menuEl.current, restProps), typeof ref == "function" ? ref(menuEl.current) : ref && (ref.current = menuEl.current);
+  const { editor: currentEditor } = useCurrentEditor(), pluginEditor = editor || currentEditor, floatingMenuPluginProps = {
+    updateDelay,
+    resizeDelay,
+    appendTo,
+    pluginKey: resolvedPluginKey,
+    shouldShow,
+    options
+  }, floatingMenuPluginPropsRef = useRef(floatingMenuPluginProps);
+  floatingMenuPluginPropsRef.current = floatingMenuPluginProps;
+  const [pluginInitialized, setPluginInitialized] = useState(!1), skipFirstUpdateRef = useRef(!0);
+  return useEffect(() => {
+    if (pluginEditor != null && pluginEditor.isDestroyed) return;
+    if (!pluginEditor) {
+      console.warn("FloatingMenu component is not rendered inside of an editor component or does not have editor prop.");
+      return;
+    }
+    const floatingMenuElement = menuEl.current;
+    floatingMenuElement.style.visibility = "hidden", floatingMenuElement.style.position = "absolute";
+    const plugin = FloatingMenuPlugin({
+      ...floatingMenuPluginPropsRef.current,
+      editor: pluginEditor,
+      element: floatingMenuElement
+    });
+    pluginEditor.registerPlugin(plugin);
+    const createdPluginKey = floatingMenuPluginPropsRef.current.pluginKey;
+    return skipFirstUpdateRef.current = !0, setPluginInitialized(!0), () => {
+      setPluginInitialized(!1), pluginEditor.unregisterPlugin(createdPluginKey), window.requestAnimationFrame(() => {
+        floatingMenuElement.parentNode && floatingMenuElement.parentNode.removeChild(floatingMenuElement);
+      });
+    };
+  }, [pluginEditor]), useEffect(() => {
+    if (!(!pluginInitialized || !pluginEditor || pluginEditor.isDestroyed)) {
+      if (skipFirstUpdateRef.current) {
+        skipFirstUpdateRef.current = !1;
+        return;
+      }
+      pluginEditor.view.dispatch(pluginEditor.state.tr.setMeta(resolvedPluginKey, {
+        type: "updateOptions",
+        options: floatingMenuPluginPropsRef.current
+      }));
+    }
+  }, [
+    pluginInitialized,
+    pluginEditor,
+    updateDelay,
+    resizeDelay,
+    shouldShow,
+    options,
+    appendTo,
+    resolvedPluginKey
+  ]), createPortal(children, menuEl.current);
+});
+export {
+  BubbleMenu,
+  FloatingMenu
+};