@tiptap/vue-2 3.0.0-next.0 → 3.0.0-next.2

package/dist/index.cjs

@@ -1,393 +1,485 @@
-'use strict';
-
-var extensionBubbleMenu = require('@tiptap/extension-bubble-menu');
-var core = require('@tiptap/core');
-var extensionFloatingMenu = require('@tiptap/extension-floating-menu');
-var Vue = require('vue');
-var vueTsTypes = require('vue-ts-types');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var Vue__default = /*#__PURE__*/_interopDefaultCompat(Vue);
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BubbleMenu: () => BubbleMenu,
+  Editor: () => Editor,
+  EditorContent: () => EditorContent,
+  FloatingMenu: () => FloatingMenu,
+  NodeViewContent: () => NodeViewContent,
+  NodeViewWrapper: () => NodeViewWrapper,
+  VueNodeViewRenderer: () => VueNodeViewRenderer,
+  VueRenderer: () => VueRenderer,
+  nodeViewProps: () => nodeViewProps
+});
+module.exports = __toCommonJS(src_exports);
 
-const BubbleMenu = {
-    name: 'BubbleMenu',
-    props: {
-        pluginKey: {
-            type: [String, Object],
-            default: 'bubbleMenu',
-        },
-        editor: {
-            type: Object,
-            required: true,
-        },
-        updateDelay: {
-            type: Number,
-        },
-        options: {
-            type: Object,
-            default: {},
-        },
-        resizeDelay: {
-            type: Number,
-        },
-        shouldShow: {
-            type: Function,
-            default: null,
-        },
+// src/BubbleMenu.ts
+var import_extension_bubble_menu = require("@tiptap/extension-bubble-menu");
+var BubbleMenu = {
+  name: "BubbleMenu",
+  props: {
+    pluginKey: {
+      type: [String, Object],
+      default: "bubbleMenu"
     },
-    watch: {
-        editor: {
-            immediate: true,
-            handler(editor) {
-                if (!editor) {
-                    return;
-                }
-                this.$el.style.visibility = 'hidden';
-                this.$el.style.position = 'absolute';
-                this.$el.remove();
-                this.$nextTick(() => {
-                    editor.registerPlugin(extensionBubbleMenu.BubbleMenuPlugin({
-                        updateDelay: this.updateDelay,
-                        resizeDelay: this.resizeDelay,
-                        options: this.options,
-                        editor,
-                        element: this.$el,
-                        pluginKey: this.pluginKey,
-                        shouldShow: this.shouldShow,
-                    }));
-                });
-            },
-        },
+    editor: {
+      type: Object,
+      required: true
+    },
+    updateDelay: {
+      type: Number
     },
-    render(createElement) {
-        return createElement('div', { style: { visibility: 'hidden' } }, this.$slots.default);
+    options: {
+      type: Object,
+      default: {}
     },
-    beforeDestroy() {
-        this.editor.unregisterPlugin(this.pluginKey);
+    resizeDelay: {
+      type: Number
     },
+    shouldShow: {
+      type: Function,
+      default: null
+    }
+  },
+  watch: {
+    editor: {
+      immediate: true,
+      handler(editor) {
+        if (!editor) {
+          return;
+        }
+        this.$el.style.visibility = "hidden";
+        this.$el.style.position = "absolute";
+        this.$el.remove();
+        this.$nextTick(() => {
+          editor.registerPlugin((0, import_extension_bubble_menu.BubbleMenuPlugin)({
+            updateDelay: this.updateDelay,
+            resizeDelay: this.resizeDelay,
+            options: this.options,
+            editor,
+            element: this.$el,
+            pluginKey: this.pluginKey,
+            shouldShow: this.shouldShow
+          }));
+        });
+      }
+    }
+  },
+  render(createElement) {
+    return createElement("div", { style: { visibility: "hidden" } }, this.$slots.default);
+  },
+  beforeDestroy() {
+    this.editor.unregisterPlugin(this.pluginKey);
+  }
 };
 
-class Editor extends core.Editor {
-    constructor() {
-        super(...arguments);
-        this.contentComponent = null;
+// src/Editor.ts
+var import_core = require("@tiptap/core");
+var Editor = class extends import_core.Editor {
+  constructor() {
+    super(...arguments);
+    this.contentComponent = null;
+  }
+};
+
+// src/EditorContent.ts
+var EditorContent = {
+  name: "EditorContent",
+  props: {
+    editor: {
+      default: null,
+      type: Object
     }
-}
+  },
+  watch: {
+    editor: {
+      immediate: true,
+      handler(editor) {
+        if (editor && editor.options.element) {
+          this.$nextTick(() => {
+            const element = this.$el;
+            if (!element || !editor.options.element.firstChild) {
+              return;
+            }
+            element.append(...editor.options.element.childNodes);
+            editor.contentComponent = this;
+            editor.setOptions({
+              element
+            });
+            editor.createNodeViews();
+          });
+        }
+      }
+    }
+  },
+  render(createElement) {
+    return createElement("div");
+  },
+  beforeDestroy() {
+    const { editor } = this;
+    if (!editor) {
+      return;
+    }
+    if (!editor.isDestroyed) {
+      editor.view.setProps({
+        nodeViews: {}
+      });
+    }
+    editor.contentComponent = null;
+    if (!editor.options.element.firstChild) {
+      return;
+    }
+    const newElement = document.createElement("div");
+    newElement.append(...editor.options.element.childNodes);
+    editor.setOptions({
+      element: newElement
+    });
+  }
+};
 
-const EditorContent = {
-    name: 'EditorContent',
-    props: {
-        editor: {
-            default: null,
-            type: Object,
-        },
+// src/FloatingMenu.ts
+var import_extension_floating_menu = require("@tiptap/extension-floating-menu");
+var FloatingMenu = {
+  name: "FloatingMenu",
+  props: {
+    pluginKey: {
+      type: [String, Object],
+      default: "floatingMenu"
     },
-    watch: {
-        editor: {
-            immediate: true,
-            handler(editor) {
-                if (editor && editor.options.element) {
-                    this.$nextTick(() => {
-                        const element = this.$el;
-                        if (!element || !editor.options.element.firstChild) {
-                            return;
-                        }
-                        element.append(...editor.options.element.childNodes);
-                        editor.contentComponent = this;
-                        editor.setOptions({
-                            element,
-                        });
-                        editor.createNodeViews();
-                    });
-                }
-            },
-        },
+    editor: {
+      type: Object,
+      required: true
     },
-    render(createElement) {
-        return createElement('div');
+    options: {
+      type: Object,
+      default: () => ({})
     },
-    beforeDestroy() {
-        const { editor } = this;
+    shouldShow: {
+      type: Function,
+      default: null
+    }
+  },
+  watch: {
+    editor: {
+      immediate: true,
+      handler(editor) {
         if (!editor) {
-            return;
+          return;
         }
-        if (!editor.isDestroyed) {
-            editor.view.setProps({
-                nodeViews: {},
-            });
-        }
-        editor.contentComponent = null;
-        if (!editor.options.element.firstChild) {
-            return;
-        }
-        const newElement = document.createElement('div');
-        newElement.append(...editor.options.element.childNodes);
-        editor.setOptions({
-            element: newElement,
+        this.$el.style.visibility = "hidden";
+        this.$el.style.position = "absolute";
+        this.$el.remove();
+        this.$nextTick(() => {
+          editor.registerPlugin((0, import_extension_floating_menu.FloatingMenuPlugin)({
+            pluginKey: this.pluginKey,
+            editor,
+            element: this.$el,
+            options: this.options,
+            shouldShow: this.shouldShow
+          }));
         });
-    },
+      }
+    }
+  },
+  render(createElement) {
+    return createElement("div", { style: { visibility: "hidden" } }, this.$slots.default);
+  },
+  beforeDestroy() {
+    this.editor.unregisterPlugin(this.pluginKey);
+  }
 };
 
-const FloatingMenu = {
-    name: 'FloatingMenu',
-    props: {
-        pluginKey: {
-            type: [String, Object],
-            default: 'floatingMenu',
-        },
-        editor: {
-            type: Object,
-            required: true,
-        },
-        options: {
-            type: Object,
-            default: () => ({}),
-        },
-        shouldShow: {
-            type: Function,
-            default: null,
-        },
-    },
-    watch: {
-        editor: {
-            immediate: true,
-            handler(editor) {
-                if (!editor) {
-                    return;
-                }
-                this.$el.style.visibility = 'hidden';
-                this.$el.style.position = 'absolute';
-                this.$el.remove();
-                this.$nextTick(() => {
-                    editor.registerPlugin(extensionFloatingMenu.FloatingMenuPlugin({
-                        pluginKey: this.pluginKey,
-                        editor,
-                        element: this.$el,
-                        options: this.options,
-                        shouldShow: this.shouldShow,
-                    }));
-                });
-            },
-        },
-    },
-    render(createElement) {
-        return createElement('div', { style: { visibility: 'hidden' } }, this.$slots.default);
-    },
-    beforeDestroy() {
-        this.editor.unregisterPlugin(this.pluginKey);
-    },
+// src/NodeViewContent.ts
+var NodeViewContent = {
+  props: {
+    as: {
+      type: String,
+      default: "div"
+    }
+  },
+  render(createElement) {
+    return createElement(this.as, {
+      style: {
+        whiteSpace: "pre-wrap"
+      },
+      attrs: {
+        "data-node-view-content": ""
+      }
+    });
+  }
 };
 
-const NodeViewContent = {
-    props: {
-        as: {
-            type: String,
-            default: 'div',
+// src/NodeViewWrapper.ts
+var NodeViewWrapper = {
+  props: {
+    as: {
+      type: String,
+      default: "div"
+    }
+  },
+  inject: ["onDragStart", "decorationClasses"],
+  render(createElement) {
+    return createElement(
+      this.as,
+      {
+        class: this.decorationClasses.value,
+        style: {
+          whiteSpace: "normal"
         },
-    },
-    render(createElement) {
-        return createElement(this.as, {
-            style: {
-                whiteSpace: 'pre-wrap',
-            },
-            attrs: {
-                'data-node-view-content': '',
-            },
-        });
-    },
-};
-
-const NodeViewWrapper = {
-    props: {
-        as: {
-            type: String,
-            default: 'div',
+        attrs: {
+          "data-node-view-wrapper": ""
         },
-    },
-    inject: ['onDragStart', 'decorationClasses'],
-    render(createElement) {
-        return createElement(this.as, {
-            class: this.decorationClasses.value,
-            style: {
-                whiteSpace: 'normal',
-            },
-            attrs: {
-                'data-node-view-wrapper': '',
-            },
-            on: {
-                dragstart: this.onDragStart,
-            },
-        }, this.$slots.default);
-    },
+        on: {
+          dragstart: this.onDragStart
+        }
+      },
+      this.$slots.default
+    );
+  }
 };
 
-/**
- * The VueRenderer class is responsible for rendering a Vue component as a ProseMirror node view.
- */
-class VueRenderer {
-    constructor(component, props) {
-        const Component = (typeof component === 'function') ? component : Vue__default.default.extend(component);
-        this.ref = new Component(props).$mount();
-    }
-    get element() {
-        return this.ref.$el;
-    }
-    updateProps(props = {}) {
-        var _a, _b, _c;
-        if (!this.ref.$props) {
-            return;
-        }
-        // prevents `Avoid mutating a prop directly` error message
-        // Fix: `VueNodeViewRenderer` change vue Constructor `config.silent` not working
-        const currentVueConstructor = (_c = (_b = (_a = this.ref.$props.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) === null || _b === void 0 ? void 0 : _b.$options._base) !== null && _c !== void 0 ? _c : Vue__default.default; // eslint-disable-line
-        const originalSilent = currentVueConstructor.config.silent;
-        currentVueConstructor.config.silent = true;
-        Object
-            .entries(props)
-            .forEach(([key, value]) => {
-            this.ref.$props[key] = value;
-        });
-        currentVueConstructor.config.silent = originalSilent;
-    }
-    destroy() {
-        this.ref.$destroy();
+// src/VueNodeViewRenderer.ts
+var import_core2 = require("@tiptap/core");
+var import_vue2 = __toESM(require("vue"), 1);
+var import_vue_ts_types = require("vue-ts-types");
+
+// src/VueRenderer.ts
+var import_vue = __toESM(require("vue"), 1);
+var VueRenderer = class {
+  constructor(component, props) {
+    const Component = typeof component === "function" ? component : import_vue.default.extend(component);
+    this.ref = new Component(props).$mount();
+  }
+  get element() {
+    return this.ref.$el;
+  }
+  updateProps(props = {}) {
+    var _a, _b, _c;
+    if (!this.ref.$props) {
+      return;
     }
-}
+    const currentVueConstructor = (_c = (_b = (_a = this.ref.$props.editor) == null ? void 0 : _a.contentComponent) == null ? void 0 : _b.$options._base) != null ? _c : import_vue.default;
+    const originalSilent = currentVueConstructor.config.silent;
+    currentVueConstructor.config.silent = true;
+    Object.entries(props).forEach(([key, value]) => {
+      this.ref.$props[key] = value;
+    });
+    currentVueConstructor.config.silent = originalSilent;
+  }
+  destroy() {
+    this.ref.$destroy();
+  }
+};
 
-const nodeViewProps = {
-    editor: vueTsTypes.objectProp().required,
-    node: vueTsTypes.objectProp().required,
-    decorations: vueTsTypes.objectProp().required,
-    selected: vueTsTypes.booleanProp().required,
-    extension: vueTsTypes.objectProp().required,
-    getPos: vueTsTypes.functionProp().required,
-    updateAttributes: vueTsTypes.functionProp().required,
-    deleteNode: vueTsTypes.functionProp().required,
+// src/VueNodeViewRenderer.ts
+var nodeViewProps = {
+  editor: (0, import_vue_ts_types.objectProp)().required,
+  node: (0, import_vue_ts_types.objectProp)().required,
+  decorations: (0, import_vue_ts_types.objectProp)().required,
+  selected: (0, import_vue_ts_types.booleanProp)().required,
+  extension: (0, import_vue_ts_types.objectProp)().required,
+  getPos: (0, import_vue_ts_types.functionProp)().required,
+  updateAttributes: (0, import_vue_ts_types.functionProp)().required,
+  deleteNode: (0, import_vue_ts_types.functionProp)().required
 };
-class VueNodeView extends core.NodeView {
-    mount() {
-        var _a, _b;
-        const props = {
-            editor: this.editor,
-            node: this.node,
-            decorations: this.decorations,
-            selected: false,
-            extension: this.extension,
-            getPos: () => this.getPos(),
-            updateAttributes: (attributes = {}) => this.updateAttributes(attributes),
-            deleteNode: () => this.deleteNode(),
+var VueNodeView = class extends import_core2.NodeView {
+  mount() {
+    var _a, _b;
+    const props = {
+      editor: this.editor,
+      node: this.node,
+      decorations: this.decorations,
+      innerDecorations: this.innerDecorations,
+      view: this.view,
+      selected: false,
+      extension: this.extension,
+      HTMLAttributes: this.HTMLAttributes,
+      getPos: () => this.getPos(),
+      updateAttributes: (attributes = {}) => this.updateAttributes(attributes),
+      deleteNode: () => this.deleteNode()
+    };
+    const onDragStart = this.onDragStart.bind(this);
+    this.decorationClasses = import_vue2.default.observable({
+      value: this.getDecorationClasses()
+    });
+    const vue = (_b = (_a = this.editor.contentComponent) == null ? void 0 : _a.$options._base) != null ? _b : import_vue2.default;
+    const Component = vue.extend(this.component).extend({
+      props: Object.keys(props),
+      provide: () => {
+        return {
+          onDragStart,
+          decorationClasses: this.decorationClasses
         };
-        const onDragStart = this.onDragStart.bind(this);
-        this.decorationClasses = Vue__default.default.observable({
-            value: this.getDecorationClasses(),
-        });
-        // @ts-ignore
-        const vue = (_b = (_a = this.editor.contentComponent) === null || _a === void 0 ? void 0 : _a.$options._base) !== null && _b !== void 0 ? _b : Vue__default.default; // eslint-disable-line
-        const Component = vue.extend(this.component).extend({
-            props: Object.keys(props),
-            provide: () => {
-                return {
-                    onDragStart,
-                    decorationClasses: this.decorationClasses,
-                };
-            },
-        });
-        this.renderer = new VueRenderer(Component, {
-            parent: this.editor.contentComponent,
-            propsData: props,
-        });
-    }
-    get dom() {
-        if (!this.renderer.element.hasAttribute('data-node-view-wrapper')) {
-            throw Error('Please use the NodeViewWrapper component for your node view.');
-        }
-        return this.renderer.element;
+      }
+    });
+    this.handleSelectionUpdate = this.handleSelectionUpdate.bind(this);
+    this.editor.on("selectionUpdate", this.handleSelectionUpdate);
+    this.renderer = new VueRenderer(Component, {
+      parent: this.editor.contentComponent,
+      propsData: props
+    });
+  }
+  /**
+   * Return the DOM element.
+   * This is the element that will be used to display the node view.
+   */
+  get dom() {
+    if (!this.renderer.element.hasAttribute("data-node-view-wrapper")) {
+      throw Error("Please use the NodeViewWrapper component for your node view.");
     }
-    get contentDOM() {
-        if (this.node.isLeaf) {
-            return null;
-        }
-        const contentElement = this.dom.querySelector('[data-node-view-content]');
-        return (contentElement || this.dom);
+    return this.renderer.element;
+  }
+  /**
+   * Return the content DOM element.
+   * This is the element that will be used to display the rich-text content of the node.
+   */
+  get contentDOM() {
+    if (this.node.isLeaf) {
+      return null;
     }
-    update(node, decorations) {
-        const updateProps = (props) => {
-            this.decorationClasses.value = this.getDecorationClasses();
-            this.renderer.updateProps(props);
-        };
-        if (typeof this.options.update === 'function') {
-            const oldNode = this.node;
-            const oldDecorations = this.decorations;
-            this.node = node;
-            this.decorations = decorations;
-            return this.options.update({
-                oldNode,
-                oldDecorations,
-                newNode: node,
-                newDecorations: decorations,
-                updateProps: () => updateProps({ node, decorations }),
-            });
-        }
-        if (node.type !== this.node.type) {
-            return false;
-        }
-        if (node === this.node && this.decorations === decorations) {
-            return true;
-        }
-        this.node = node;
-        this.decorations = decorations;
-        updateProps({ node, decorations });
-        return true;
+    const contentElement = this.dom.querySelector("[data-node-view-content]");
+    return contentElement || this.dom;
+  }
+  /**
+   * On editor selection update, check if the node is selected.
+   * If it is, call `selectNode`, otherwise call `deselectNode`.
+   */
+  handleSelectionUpdate() {
+    const { from, to } = this.editor.state.selection;
+    const pos = this.getPos();
+    if (typeof pos !== "number") {
+      return;
     }
-    selectNode() {
-        this.renderer.updateProps({
-            selected: true,
-        });
-        this.renderer.element.classList.add('ProseMirror-selectednode');
+    if (from <= pos && to >= pos + this.node.nodeSize) {
+      if (this.renderer.ref.$props.selected) {
+        return;
+      }
+      this.selectNode();
+    } else {
+      if (!this.renderer.ref.$props.selected) {
+        return;
+      }
+      this.deselectNode();
     }
-    deselectNode() {
-        this.renderer.updateProps({
-            selected: false,
-        });
-        this.renderer.element.classList.remove('ProseMirror-selectednode');
+  }
+  /**
+   * On update, update the React component.
+   * To prevent unnecessary updates, the `update` option can be used.
+   */
+  update(node, decorations, innerDecorations) {
+    const rerenderComponent = (props) => {
+      this.decorationClasses.value = this.getDecorationClasses();
+      this.renderer.updateProps(props);
+    };
+    if (typeof this.options.update === "function") {
+      const oldNode = this.node;
+      const oldDecorations = this.decorations;
+      const oldInnerDecorations = this.innerDecorations;
+      this.node = node;
+      this.decorations = decorations;
+      this.innerDecorations = innerDecorations;
+      return this.options.update({
+        oldNode,
+        oldDecorations,
+        newNode: node,
+        newDecorations: decorations,
+        oldInnerDecorations,
+        innerDecorations,
+        updateProps: () => rerenderComponent({ node, decorations, innerDecorations })
+      });
     }
-    getDecorationClasses() {
-        return (this.decorations
-            // @ts-ignore
-            .map(item => item.type.attrs.class)
-            .flat()
-            .join(' '));
+    if (node.type !== this.node.type) {
+      return false;
     }
-    destroy() {
-        this.renderer.destroy();
+    if (node === this.node && this.decorations === decorations && this.innerDecorations === innerDecorations) {
+      return true;
     }
-}
+    this.node = node;
+    this.decorations = decorations;
+    this.innerDecorations = innerDecorations;
+    rerenderComponent({ node, decorations, innerDecorations });
+    return true;
+  }
+  /**
+   * Select the node.
+   * Add the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  selectNode() {
+    this.renderer.updateProps({
+      selected: true
+    });
+    this.renderer.element.classList.add("ProseMirror-selectednode");
+  }
+  /**
+   * Deselect the node.
+   * Remove the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  deselectNode() {
+    this.renderer.updateProps({
+      selected: false
+    });
+    this.renderer.element.classList.remove("ProseMirror-selectednode");
+  }
+  getDecorationClasses() {
+    return this.decorations.map((item) => item.type.attrs.class).flat().join(" ");
+  }
+  destroy() {
+    this.renderer.destroy();
+    this.editor.off("selectionUpdate", this.handleSelectionUpdate);
+  }
+};
 function VueNodeViewRenderer(component, options) {
-    return (props) => {
-        // try to get the parent component
-        // this is important for vue devtools to show the component hierarchy correctly
-        // maybe it’s `undefined` because <editor-content> isn’t rendered yet
-        if (!props.editor.contentComponent) {
-            return {};
-        }
-        return new VueNodeView(component, props, options);
-    };
+  return (props) => {
+    if (!props.editor.contentComponent) {
+      return {};
+    }
+    return new VueNodeView(component, props, options);
+  };
 }
 
-exports.BubbleMenu = BubbleMenu;
-exports.Editor = Editor;
-exports.EditorContent = EditorContent;
-exports.FloatingMenu = FloatingMenu;
-exports.NodeViewContent = NodeViewContent;
-exports.NodeViewWrapper = NodeViewWrapper;
-exports.VueNodeViewRenderer = VueNodeViewRenderer;
-exports.VueRenderer = VueRenderer;
-exports.nodeViewProps = nodeViewProps;
-Object.keys(core).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return core[k]; }
-  });
+// src/index.ts
+__reExport(src_exports, require("@tiptap/core"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BubbleMenu,
+  Editor,
+  EditorContent,
+  FloatingMenu,
+  NodeViewContent,
+  NodeViewWrapper,
+  VueNodeViewRenderer,
+  VueRenderer,
+  nodeViewProps,
+  ...require("@tiptap/core")
 });
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map