@tiptap/react 2.0.0-beta.20 → 2.0.0-beta.200

package/README.md

@@ -7,8 +7,8 @@
 ## Introduction
 tiptap is a headless wrapper around [ProseMirror](https://ProseMirror.net) – a toolkit for building rich text WYSIWYG editors, which is already in use at many well-known companies such as *New York Times*, *The Guardian* or *Atlassian*.
 
-## Offical Documentation
+## Official Documentation
 Documentation can be found on the [tiptap website](https://tiptap.dev).
 
 ## License
-tiptap is open sourced software licensed under the [MIT license](https://github.com/ueberdosis/tiptap-next/blob/main/LICENSE.md).
+tiptap is open sourced software licensed under the [MIT license](https://github.com/ueberdosis/tiptap/blob/main/LICENSE.md).

package/dist/packages/react/src/BubbleMenu.d.ts

@@ -1,6 +1,9 @@
-import React from 'react';
 import { BubbleMenuPluginProps } from '@tiptap/extension-bubble-menu';
-export declare type BubbleMenuProps = Omit<BubbleMenuPluginProps, 'element'> & {
+import React from 'react';
+declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export declare type BubbleMenuProps = Omit<Optional<BubbleMenuPluginProps, 'pluginKey'>, 'element'> & {
     className?: string;
+    children: React.ReactNode;
 };
-export declare const BubbleMenu: React.FC<BubbleMenuProps>;
+export declare const BubbleMenu: (props: BubbleMenuProps) => JSX.Element;
+export {};

package/dist/packages/react/src/Editor.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
 import { Editor as CoreEditor } from '@tiptap/core';
+import React from 'react';
 import { EditorContentProps, EditorContentState } from './EditorContent';
 export declare class Editor extends CoreEditor {
     contentComponent: React.Component<EditorContentProps, EditorContentState> | null;

package/dist/packages/react/src/EditorContent.d.ts

@@ -1,7 +1,7 @@
-import React from 'react';
+import React, { HTMLProps } from 'react';
 import { Editor } from './Editor';
 import { ReactRenderer } from './ReactRenderer';
-export interface EditorContentProps {
+export interface EditorContentProps extends HTMLProps<HTMLDivElement> {
     editor: Editor | null;
 }
 export interface EditorContentState {

package/dist/packages/react/src/FloatingMenu.d.ts

@@ -1,6 +1,9 @@
-import React from 'react';
 import { FloatingMenuPluginProps } from '@tiptap/extension-floating-menu';
-export declare type FloatingMenuProps = Omit<FloatingMenuPluginProps, 'element'> & {
+import React from 'react';
+declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export declare type FloatingMenuProps = Omit<Optional<FloatingMenuPluginProps, 'pluginKey'>, 'element'> & {
     className?: string;
+    children: React.ReactNode;
 };
-export declare const FloatingMenu: React.FC<FloatingMenuProps>;
+export declare const FloatingMenu: (props: FloatingMenuProps) => JSX.Element;
+export {};

package/dist/packages/react/src/NodeViewContent.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 export interface NodeViewContentProps {
-    className?: string;
+    [key: string]: any;
     as?: React.ElementType;
 }
 export declare const NodeViewContent: React.FC<NodeViewContentProps>;

package/dist/packages/react/src/NodeViewWrapper.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 export interface NodeViewWrapperProps {
-    className?: string;
+    [key: string]: any;
     as?: React.ElementType;
 }
 export declare const NodeViewWrapper: React.FC<NodeViewWrapperProps>;

package/dist/packages/react/src/ReactNodeViewRenderer.d.ts

@@ -1,9 +1,15 @@
-import { NodeViewRenderer } from '@tiptap/core';
-import { Decoration } from 'prosemirror-view';
+import { NodeViewRenderer, NodeViewRendererOptions } from '@tiptap/core';
 import { Node as ProseMirrorNode } from 'prosemirror-model';
-interface ReactNodeViewRendererOptions {
-    stopEvent: ((event: Event) => boolean) | null;
-    update: ((node: ProseMirrorNode, decorations: Decoration[]) => boolean) | null;
+import { Decoration } from 'prosemirror-view';
+export interface ReactNodeViewRendererOptions extends NodeViewRendererOptions {
+    update: ((props: {
+        oldNode: ProseMirrorNode;
+        oldDecorations: Decoration[];
+        newNode: ProseMirrorNode;
+        newDecorations: Decoration[];
+        updateProps: () => void;
+    }) => boolean) | null;
+    as?: string;
+    className?: string;
 }
 export declare function ReactNodeViewRenderer(component: any, options?: Partial<ReactNodeViewRendererOptions>): NodeViewRenderer;
-export {};

package/dist/packages/react/src/ReactRenderer.d.ts

@@ -1,21 +1,24 @@
+import { Editor } from '@tiptap/core';
 import React from 'react';
-import { AnyObject } from '@tiptap/core';
-import { Editor } from './Editor';
+import { Editor as ExtendedEditor } from './Editor';
 export interface ReactRendererOptions {
     editor: Editor;
-    props?: AnyObject;
+    props?: Record<string, any>;
     as?: string;
+    className?: string;
 }
-export declare class ReactRenderer {
+declare type ComponentType<R, P> = React.ComponentClass<P> | React.FunctionComponent<P> | React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<R>>;
+export declare class ReactRenderer<R = unknown, P = unknown> {
     id: string;
-    editor: Editor;
+    editor: ExtendedEditor;
     component: any;
     element: Element;
-    props: AnyObject;
+    props: Record<string, any>;
     reactElement: React.ReactNode;
-    ref: React.Component | null;
-    constructor(component: React.Component | React.FunctionComponent, { editor, props, as }: ReactRendererOptions);
+    ref: R | null;
+    constructor(component: ComponentType<R, P>, { editor, props, as, className, }: ReactRendererOptions);
     render(): void;
-    updateProps(props?: AnyObject): void;
+    updateProps(props?: Record<string, any>): void;
     destroy(): void;
 }
+export {};

package/dist/packages/react/src/index.d.ts

@@ -1,10 +1,10 @@
-export * from '@tiptap/core';
 export * from './BubbleMenu';
 export { Editor } from './Editor';
-export * from './FloatingMenu';
-export * from './useEditor';
-export * from './ReactRenderer';
-export * from './ReactNodeViewRenderer';
 export * from './EditorContent';
-export * from './NodeViewWrapper';
+export * from './FloatingMenu';
 export * from './NodeViewContent';
+export * from './NodeViewWrapper';
+export * from './ReactNodeViewRenderer';
+export * from './ReactRenderer';
+export * from './useEditor';
+export * from '@tiptap/core';

package/dist/packages/react/src/useEditor.d.ts

@@ -1,3 +1,4 @@
 import { EditorOptions } from '@tiptap/core';
+import { DependencyList } from 'react';
 import { Editor } from './Editor';
-export declare const useEditor: (options?: Partial<EditorOptions>) => Editor | null;
+export declare const useEditor: (options?: Partial<EditorOptions>, deps?: DependencyList) => Editor | null;

package/dist/packages/react/src/useReactNodeView.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 export interface ReactNodeViewContextProps {
     onDragStart: (event: DragEvent) => void;
+    nodeViewContentRef: (element: HTMLElement | null) => void;
 }
 export declare const ReactNodeViewContext: import("react").Context<Partial<ReactNodeViewContextProps>>;
 export declare const useReactNodeView: () => Partial<ReactNodeViewContextProps>;

package/dist/tiptap-react.cjs.js

@@ -2,31 +2,41 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var core = require('@tiptap/core');
-var React = require('react');
 var extensionBubbleMenu = require('@tiptap/extension-bubble-menu');
-var extensionFloatingMenu = require('@tiptap/extension-floating-menu');
+var React = require('react');
+var core = require('@tiptap/core');
 var ReactDOM = require('react-dom');
+var extensionFloatingMenu = require('@tiptap/extension-floating-menu');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
 
-const BubbleMenu = props => {
-    const element = React.useRef(null);
+const BubbleMenu = (props) => {
+    const [element, setElement] = React.useState(null);
     React.useEffect(() => {
-        const { editor, keepInBounds = true } = props;
-        editor.registerPlugin(extensionBubbleMenu.BubbleMenuPlugin({
+        if (!element) {
+            return;
+        }
+        if (props.editor.isDestroyed) {
+            return;
+        }
+        const { pluginKey = 'bubbleMenu', editor, tippyOptions = {}, shouldShow = null, } = props;
+        const plugin = extensionBubbleMenu.BubbleMenuPlugin({
+            pluginKey,
             editor,
-            element: element.current,
-            keepInBounds,
-        }));
-        return () => {
-            editor.unregisterPlugin(extensionBubbleMenu.BubbleMenuPluginKey);
-        };
-    }, []);
-    return (React__default['default'].createElement("div", { ref: element, className: props.className, style: { visibility: 'hidden' } }, props.children));
+            element,
+            tippyOptions,
+            shouldShow,
+        });
+        editor.registerPlugin(plugin);
+        return () => editor.unregisterPlugin(pluginKey);
+    }, [
+        props.editor,
+        element,
+    ]);
+    return (React__default["default"].createElement("div", { ref: setElement, className: props.className, style: { visibility: 'hidden' } }, props.children));
 };
 
 class Editor extends core.Editor {
@@ -36,46 +46,130 @@ class Editor extends core.Editor {
     }
 }
 
-const FloatingMenu = props => {
-    const element = React.useRef(null);
+const Portals = ({ renderers }) => {
+    return (React__default["default"].createElement(React__default["default"].Fragment, null, Array.from(renderers).map(([key, renderer]) => {
+        return ReactDOM__default["default"].createPortal(renderer.reactElement, renderer.element, key);
+    })));
+};
+class PureEditorContent extends React__default["default"].Component {
+    constructor(props) {
+        super(props);
+        this.editorContentRef = React__default["default"].createRef();
+        this.state = {
+            renderers: new Map(),
+        };
+    }
+    componentDidMount() {
+        this.init();
+    }
+    componentDidUpdate() {
+        this.init();
+    }
+    init() {
+        const { editor } = this.props;
+        if (editor && editor.options.element) {
+            if (editor.contentComponent) {
+                return;
+            }
+            const element = this.editorContentRef.current;
+            element.append(...editor.options.element.childNodes);
+            editor.setOptions({
+                element,
+            });
+            editor.contentComponent = this;
+            editor.createNodeViews();
+        }
+    }
+    componentWillUnmount() {
+        const { editor } = this.props;
+        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,
+        });
+    }
+    render() {
+        const { editor, ...rest } = this.props;
+        return (React__default["default"].createElement(React__default["default"].Fragment, null,
+            React__default["default"].createElement("div", { ref: this.editorContentRef, ...rest }),
+            React__default["default"].createElement(Portals, { renderers: this.state.renderers })));
+    }
+}
+const EditorContent = React__default["default"].memo(PureEditorContent);
+
+const FloatingMenu = (props) => {
+    const [element, setElement] = React.useState(null);
     React.useEffect(() => {
-        const { editor } = props;
-        editor.registerPlugin(extensionFloatingMenu.FloatingMenuPlugin({
+        if (!element) {
+            return;
+        }
+        if (props.editor.isDestroyed) {
+            return;
+        }
+        const { pluginKey = 'floatingMenu', editor, tippyOptions = {}, shouldShow = null, } = props;
+        const plugin = extensionFloatingMenu.FloatingMenuPlugin({
+            pluginKey,
             editor,
-            element: element.current,
-        }));
-        return () => {
-            editor.unregisterPlugin(extensionFloatingMenu.FloatingMenuPluginKey);
-        };
-    }, []);
-    return (React__default['default'].createElement("div", { ref: element, className: props.className, style: { visibility: 'hidden' } }, props.children));
+            element,
+            tippyOptions,
+            shouldShow,
+        });
+        editor.registerPlugin(plugin);
+        return () => editor.unregisterPlugin(pluginKey);
+    }, [
+        props.editor,
+        element,
+    ]);
+    return (React__default["default"].createElement("div", { ref: setElement, className: props.className, style: { visibility: 'hidden' } }, props.children));
 };
 
-function useForceUpdate() {
-    const [, setValue] = React.useState(0);
-    return () => setValue(value => value + 1);
-}
-const useEditor = (options = {}) => {
-    const [editor, setEditor] = React.useState(null);
-    const forceUpdate = useForceUpdate();
-    React.useEffect(() => {
-        const instance = new Editor(options);
-        setEditor(instance);
-        instance.on('transaction', forceUpdate);
-        return () => {
-            instance.destroy();
-        };
-    }, []);
-    return editor;
+const ReactNodeViewContext = React.createContext({
+    onDragStart: undefined,
+});
+const useReactNodeView = () => React.useContext(ReactNodeViewContext);
+
+const NodeViewContent = props => {
+    const Tag = props.as || 'div';
+    const { nodeViewContentRef } = useReactNodeView();
+    return (React__default["default"].createElement(Tag, { ...props, ref: nodeViewContentRef, "data-node-view-content": "", style: {
+            whiteSpace: 'pre-wrap',
+            ...props.style,
+        } }));
 };
 
+const NodeViewWrapper = React__default["default"].forwardRef((props, ref) => {
+    const { onDragStart } = useReactNodeView();
+    const Tag = props.as || 'div';
+    return (React__default["default"].createElement(Tag, { ...props, ref: ref, "data-node-view-wrapper": "", onDragStart: onDragStart, style: {
+            whiteSpace: 'normal',
+            ...props.style,
+        } }));
+});
+
 function isClassComponent(Component) {
     return !!(typeof Component === 'function'
         && Component.prototype
         && Component.prototype.isReactComponent);
 }
+function isForwardRefComponent(Component) {
+    var _a;
+    return !!(typeof Component === 'object'
+        && ((_a = Component.$$typeof) === null || _a === void 0 ? void 0 : _a.toString()) === 'Symbol(react.forward_ref)');
+}
 class ReactRenderer {
-    constructor(component, { editor, props = {}, as = 'div' }) {
+    constructor(component, { editor, props = {}, as = 'div', className = '', }) {
         this.ref = null;
         this.id = Math.floor(Math.random() * 0xFFFFFFFF).toString();
         this.component = component;
@@ -83,23 +177,30 @@ class ReactRenderer {
         this.props = props;
         this.element = document.createElement(as);
         this.element.classList.add('react-renderer');
+        if (className) {
+            this.element.classList.add(...className.split(' '));
+        }
         this.render();
     }
     render() {
-        var _a;
         const Component = this.component;
         const props = this.props;
-        if (isClassComponent(Component)) {
+        if (isClassComponent(Component) || isForwardRefComponent(Component)) {
             props.ref = (ref) => {
                 this.ref = ref;
             };
         }
-        this.reactElement = React__default['default'].createElement(Component, Object.assign({}, props));
-        if ((_a = this.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) {
-            this.editor.contentComponent.setState({
-                renderers: this.editor.contentComponent.state.renderers.set(this.id, this),
+        this.reactElement = React__default["default"].createElement(Component, { ...props });
+        queueMicrotask(() => {
+            ReactDOM.flushSync(() => {
+                var _a;
+                if ((_a = this.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) {
+                    this.editor.contentComponent.setState({
+                        renderers: this.editor.contentComponent.state.renderers.set(this.id, this),
+                    });
+                }
             });
-        }
+        });
     }
     updateProps(props = {}) {
         this.props = {
@@ -109,22 +210,21 @@ class ReactRenderer {
         this.render();
     }
     destroy() {
-        var _a;
-        if ((_a = this.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) {
-            const { renderers } = this.editor.contentComponent.state;
-            renderers.delete(this.id);
-            this.editor.contentComponent.setState({
-                renderers,
+        queueMicrotask(() => {
+            ReactDOM.flushSync(() => {
+                var _a;
+                if ((_a = this.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) {
+                    const { renderers } = this.editor.contentComponent.state;
+                    renderers.delete(this.id);
+                    this.editor.contentComponent.setState({
+                        renderers,
+                    });
+                }
             });
-        }
+        });
     }
 }
 
-const ReactNodeViewContext = React.createContext({
-    onDragStart: undefined,
-});
-const useReactNodeView = () => React.useContext(ReactNodeViewContext);
-
 class ReactNodeView extends core.NodeView {
     mount() {
         const props = {
@@ -135,6 +235,7 @@ class ReactNodeView extends core.NodeView {
             extension: this.extension,
             getPos: () => this.getPos(),
             updateAttributes: (attributes = {}) => this.updateAttributes(attributes),
+            deleteNode: () => this.deleteNode(),
         };
         if (!this.component.displayName) {
             const capitalizeFirstChar = (string) => {
@@ -143,21 +244,36 @@ class ReactNodeView extends core.NodeView {
             this.component.displayName = capitalizeFirstChar(this.extension.name);
         }
         const ReactNodeViewProvider = componentProps => {
-            const onDragStart = this.onDragStart.bind(this);
             const Component = this.component;
-            return (React__default['default'].createElement(ReactNodeViewContext.Provider, { value: { onDragStart } },
-                React__default['default'].createElement(Component, Object.assign({}, componentProps))));
+            const onDragStart = this.onDragStart.bind(this);
+            const nodeViewContentRef = element => {
+                if (element && this.contentDOMElement && element.firstChild !== this.contentDOMElement) {
+                    element.appendChild(this.contentDOMElement);
+                }
+            };
+            return (React__default["default"].createElement(ReactNodeViewContext.Provider, { value: { onDragStart, nodeViewContentRef } },
+                React__default["default"].createElement(Component, { ...componentProps })));
         };
         ReactNodeViewProvider.displayName = 'ReactNodeView';
         this.contentDOMElement = this.node.isLeaf
             ? null
             : document.createElement(this.node.isInline ? 'span' : 'div');
+        if (this.contentDOMElement) {
+            // For some reason the whiteSpace prop is not inherited properly in Chrome and Safari
+            // With this fix it seems to work fine
+            // See: https://github.com/ueberdosis/tiptap/issues/1197
+            this.contentDOMElement.style.whiteSpace = 'inherit';
+        }
+        let as = this.node.isInline ? 'span' : 'div';
+        if (this.options.as) {
+            as = this.options.as;
+        }
+        const { className = '' } = this.options;
         this.renderer = new ReactRenderer(ReactNodeViewProvider, {
             editor: this.editor,
             props,
-            as: this.node.isInline
-                ? 'span'
-                : 'div',
+            as,
+            className: `node-${this.node.type.name} ${className}`.trim(),
         });
     }
     get dom() {
@@ -172,27 +288,34 @@ class ReactNodeView extends core.NodeView {
         if (this.node.isLeaf) {
             return null;
         }
-        const contentElement = this.dom.querySelector('[data-node-view-content]');
-        if (this.contentDOMElement
-            && contentElement
-            && !contentElement.contains(this.contentDOMElement)) {
-            contentElement.appendChild(this.contentDOMElement);
-        }
         return this.contentDOMElement;
     }
     update(node, decorations) {
-        if (typeof this.options.update === 'function') {
-            return this.options.update(node, decorations);
-        }
+        const updateProps = (props) => {
+            this.renderer.updateProps(props);
+        };
         if (node.type !== this.node.type) {
             return false;
         }
+        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 === this.node && this.decorations === decorations) {
             return true;
         }
         this.node = node;
         this.decorations = decorations;
-        this.renderer.updateProps({ node, decorations });
+        updateProps({ node, decorations });
         return true;
     }
     selectNode() {
@@ -222,78 +345,32 @@ function ReactNodeViewRenderer(component, options) {
     };
 }
 
-const Portals = ({ renderers }) => {
-    return (React__default['default'].createElement(React__default['default'].Fragment, null, Array.from(renderers).map(([key, renderer]) => {
-        return ReactDOM__default['default'].createPortal(renderer.reactElement, renderer.element, key);
-    })));
-};
-class PureEditorContent extends React__default['default'].Component {
-    constructor(props) {
-        super(props);
-        this.editorContentRef = React__default['default'].createRef();
-        this.state = {
-            renderers: new Map(),
-        };
-    }
-    componentDidMount() {
-        this.init();
-    }
-    componentDidUpdate() {
-        this.init();
-    }
-    init() {
-        const { editor } = this.props;
-        if (editor && editor.options.element) {
-            if (editor.contentComponent) {
-                return;
-            }
-            const element = this.editorContentRef.current;
-            element.appendChild(editor.options.element.firstChild);
-            editor.setOptions({
-                element,
-            });
-            editor.contentComponent = this;
-            // TODO: alternative to setTimeout?
-            setTimeout(() => editor.createNodeViews(), 0);
-        }
-    }
-    componentWillUnmount() {
-        const { editor } = this.props;
-        if (!editor) {
-            return;
-        }
-        if (!editor.isDestroyed) {
-            editor.view.setProps({
-                nodeViews: {},
+function useForceUpdate() {
+    const [, setValue] = React.useState(0);
+    return () => setValue(value => value + 1);
+}
+const useEditor = (options = {}, deps = []) => {
+    const [editor, setEditor] = React.useState(null);
+    const forceUpdate = useForceUpdate();
+    React.useEffect(() => {
+        let isMounted = true;
+        const instance = new Editor(options);
+        setEditor(instance);
+        instance.on('transaction', () => {
+            requestAnimationFrame(() => {
+                requestAnimationFrame(() => {
+                    if (isMounted) {
+                        forceUpdate();
+                    }
+                });
             });
-        }
-        editor.contentComponent = null;
-        if (!editor.options.element.firstChild) {
-            return;
-        }
-        const newElement = document.createElement('div');
-        newElement.appendChild(editor.options.element.firstChild);
-        editor.setOptions({
-            element: newElement,
         });
-    }
-    render() {
-        return (React__default['default'].createElement(React__default['default'].Fragment, null,
-            React__default['default'].createElement("div", { ref: this.editorContentRef }),
-            React__default['default'].createElement(Portals, { renderers: this.state.renderers })));
-    }
-}
-const EditorContent = React__default['default'].memo(PureEditorContent);
-
-const NodeViewWrapper = props => {
-    const { onDragStart } = useReactNodeView();
-    const Tag = props.as || 'div';
-    return (React__default['default'].createElement(Tag, { className: props.className, "data-node-view-wrapper": "", onDragStart: onDragStart, style: { whiteSpace: 'normal' } }, props.children));
-};
-
-const NodeViewContent = props => {
-    const Tag = props.as || 'div';
-    return (React__default['default'].createElement(Tag, { className: props.className, "data-node-view-content": "", style: { whiteSpace: 'pre-wrap' } }));
+        return () => {
+            instance.destroy();
+            isMounted = false;
+        };
+    }, deps);
+    return editor;
 };
 
 exports.BubbleMenu = BubbleMenu;
@@ -309,9 +386,7 @@ exports.useEditor = useEditor;
 Object.keys(core).forEach(function (k) {
   if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () {
-      return core[k];
-    }
+    get: function () { return core[k]; }
   });
 });
 //# sourceMappingURL=tiptap-react.cjs.js.map