@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/types/refs.d.ts

@@ -0,0 +1,2 @@
+import { Ref, RefCallback } from "react";
+export declare function useMergedDOMRefs<Value>(...refs: Ref<Value>[]): RefCallback<Value>;

package/dist/types/testing/editorViewTestHelpers.d.ts

@@ -0,0 +1,24 @@
+import { Node } from "prosemirror-model";
+import { Selection } from "prosemirror-state";
+import { doc } from "prosemirror-test-builder";
+import { EditorView as EditorViewT } from "prosemirror-view";
+import { Props } from "../components/ProseMirror.js";
+import { DOMNode } from "../dom.js";
+declare module "expect-webdriverio" {
+    interface AsymmetricMatchers {
+        toEqualNode(actual: Node): void;
+    }
+    interface Matchers<R, T> {
+        toEqualNode(actual: Node): R;
+    }
+}
+export declare function tempEditor({ doc: startDoc, selection, controlled, plugins, ...props }: {
+    doc?: ReturnType<typeof doc>;
+    selection?: Selection;
+    controlled?: boolean;
+} & Omit<Props, "state">): {
+    view: EditorViewT;
+    rerender: (props?: Omit<Props, "state" | "plugins">) => void;
+    unmount: () => void;
+};
+export declare function findTextNode(node: DOMNode, text: string): Text;

package/dist/types/testing/setupProseMirrorView.d.ts

@@ -0,0 +1,2 @@
+export declare function setupProseMirrorView(): void;
+export declare function teardownProseMirrorView(): void;

package/dist/types/tiptap/ReactProseMirrorNodeView.d.ts

@@ -0,0 +1,15 @@
+import { Editor, NodeView, NodeViewRendererOptions, NodeViewRendererProps } from "@tiptap/core";
+/**
+ * Subclass of Tiptap's NodeView to be used in tiptapNodeView.
+ *
+ * Allows us to pass in an existing dom and contentDOM from React ProseMirror's
+ * ViewDesc, so that we can call Tiptap's default stopEvent and ignoreMutation
+ * methods
+ */
+export declare class ReactProseMirrorNodeView<Component, NodeEditor extends Editor = Editor, Options extends NodeViewRendererOptions = NodeViewRendererOptions> extends NodeView<Component, NodeEditor, Options> {
+    private _dom;
+    private _contentDOM;
+    constructor(component: Component, props: NodeViewRendererProps, dom: HTMLElement, contentDOM: HTMLElement | null, options?: Partial<Options>);
+    get dom(): HTMLElement;
+    get contentDOM(): HTMLElement | null;
+}

package/dist/types/tiptap/TiptapEditor.d.ts

@@ -0,0 +1,6 @@
+import { Editor, type EditorOptions } from "@tiptap/core";
+import type { EditorView } from "prosemirror-view";
+export declare class TiptapEditor extends Editor {
+    constructor(options?: Partial<EditorOptions>);
+    get view(): EditorView;
+}

package/dist/types/tiptap/TiptapEditorContent.d.ts

@@ -0,0 +1,28 @@
+import { Editor } from "@tiptap/core";
+import { ReactRenderer } from "@tiptap/react";
+import React, { ElementType, ForwardedRef, HTMLProps, ReactPortal } from "react";
+export type ContentComponent = {
+    setRenderer(id: string, renderer: ReactRenderer): void;
+    removeRenderer(id: string): void;
+    subscribe: (callback: () => void) => () => void;
+    getSnapshot: () => Record<string, ReactPortal>;
+    getServerSnapshot: () => Record<string, ReactPortal>;
+};
+export interface EditorContentProps extends HTMLProps<HTMLDivElement> {
+    editor: Editor | null;
+    innerRef?: ForwardedRef<HTMLDivElement | null>;
+}
+interface Props extends Omit<HTMLProps<HTMLElement>, "as"> {
+    editor: Editor;
+    as?: ElementType;
+}
+/**
+ * Renders the actual editable ProseMirror document.
+ *
+ * This **must** be passed as a child to the `TiptapEditorView`
+ * component. It may be wrapped in other components, and other
+ * childern may be passed before or after. It must be passed the
+ * same `editor` as is passed to the `TiptapEditorView`.
+ */
+export declare function TiptapEditorContent({ editor: editorProp, ...props }: Props): React.JSX.Element;
+export {};

package/dist/types/tiptap/TiptapEditorView.d.ts

@@ -0,0 +1,16 @@
+import { Editor } from "@tiptap/core";
+import React, { ComponentType, ReactNode } from "react";
+import { MarkViewComponentProps } from "../components/marks/MarkViewComponentProps.js";
+import { NodeViewComponentProps } from "../components/nodes/NodeViewComponentProps.js";
+interface Props {
+    editor: Editor;
+    nodeViewComponents?: Record<string, ComponentType<NodeViewComponentProps>>;
+    markViewComponents?: Record<string, ComponentType<MarkViewComponentProps>>;
+    children?: ReactNode;
+    static?: boolean;
+}
+/**
+ * Render a Tiptap-compatible React ProseMirror editor.
+ */
+export declare function TiptapEditorView({ editor, nodeViewComponents, markViewComponents, children, static: isStatic, }: Props): React.JSX.Element;
+export {};

package/dist/types/tiptap/contexts/TiptapEditorContext.d.ts

@@ -0,0 +1,6 @@
+export interface TiptapEditorContextValue {
+    isEditorInitialized: boolean;
+    onEditorInitialize: () => void;
+    onEditorDeinitialize: () => void;
+}
+export declare const TiptapEditorContext: import("react").Context<TiptapEditorContextValue>;

package/dist/types/tiptap/extensions/ReactProseMirror.d.ts

@@ -0,0 +1,9 @@
+import { Extension } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        reactProseMirrorCommands: {
+            reorderSiblings: (pos: number, order: number[]) => ReturnType;
+        };
+    }
+}
+export declare const ReactProseMirror: Extension<any, any>;

package/dist/types/tiptap/extensions/ReactProseMirrorCommands.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from "@tiptap/core";
+export declare const ReactProseMirrorCommands: Extension<any, any>;

package/dist/types/tiptap/extensions/commands/updateAttributes.d.ts

@@ -0,0 +1,24 @@
+import { RawCommands } from "@tiptap/core";
+import type { MarkType, NodeType } from "@tiptap/pm/model";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        updateAttributes: {
+            /**
+             * Update attributes of a node or mark.
+             * @param typeOrName The type or name of the node or mark.
+             * @param attributes The attributes of the node or mark.
+             * @example editor.commands.updateAttributes('mention', { userId: "2" })
+             */
+            updateAttributes: (
+            /**
+             * The type or name of the node or mark.
+             */
+            typeOrName: string | NodeType | MarkType, 
+            /**
+             * The attributes of the node or mark.
+             */
+            attributes: Record<string, any>) => ReturnType;
+        };
+    }
+}
+export declare const updateAttributes: RawCommands["updateAttributes"];

package/dist/types/tiptap/hooks/useEditor.d.ts

@@ -0,0 +1,38 @@
+import { Editor, type EditorOptions } from "@tiptap/core";
+import { DependencyList } from "react";
+/**
+ * The options for the `useEditor` hook.
+ */
+export type UseEditorOptions = Partial<EditorOptions> & {
+    /**
+     * Whether to render the editor on the first render.
+     * If client-side rendering, set this to `true`.
+     * If server-side rendering, set this to `false`.
+     * @default true
+     */
+    immediatelyRender?: boolean;
+    /**
+     * Whether to re-render the editor on each transaction.
+     * This is legacy behavior that will be removed in future versions.
+     * @default false
+     */
+    shouldRerenderOnTransaction?: boolean;
+};
+/**
+ * This hook allows you to create an editor instance.
+ * @param options The editor options
+ * @param deps The dependencies to watch for changes
+ * @returns The editor instance
+ * @example const editor = useEditor({ extensions: [...] })
+ */
+export declare function useEditor(options: UseEditorOptions & {
+    immediatelyRender: false;
+}, deps?: DependencyList): Editor | null;
+/**
+ * This hook allows you to create an editor instance.
+ * @param options The editor options
+ * @param deps The dependencies to watch for changes
+ * @returns The editor instance
+ * @example const editor = useEditor({ extensions: [...] })
+ */
+export declare function useEditor(options: UseEditorOptions, deps?: DependencyList): Editor;

package/dist/types/tiptap/hooks/useIsInReactProseMirror.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the hook is called in a
+ * component that's a descendant of the
+ * ProseMirror component
+ */
+export declare function useIsInReactProseMirror(): boolean;

package/dist/types/tiptap/hooks/useTiptapEditor.d.ts

@@ -0,0 +1,11 @@
+import { DependencyList } from "react";
+import { useEditor } from "./useEditor.js";
+export type UseTiptapEditorOptions = Omit<Parameters<typeof useEditor>[0], "element">;
+/**
+ * Create a React ProseMirror integrated Tiptap Editor instance.
+ * @param options The editor options
+ * @param deps The dependencies to watch for changes
+ * @returns The editor instance
+ * @example const editor = useEditor({ extensions: [...] })
+ */
+export declare function useTiptapEditor(options: UseTiptapEditorOptions, deps?: DependencyList): import("@tiptap/core").Editor;

package/dist/types/tiptap/hooks/useTiptapEditorEffect.d.ts

@@ -0,0 +1,21 @@
+import { Editor } from "@tiptap/core";
+import { DependencyList } from "react";
+/**
+ * Registers a layout effect to run after the EditorView has
+ * been updated with the latest EditorState and Decorations.
+ *
+ * Effects can take a Tiptap Editor instance as an argument.
+ * This hook should be used to execute layout effects that
+ * depend on the Editor, such as for positioning DOM
+ * nodes based on ProseMirror positions.
+ *
+ * Layout effects registered with this hook still fire
+ * synchronously after all DOM mutations, but they do so
+ * _after_ the Editor has been updated, even when the
+ * Editor lives in an ancestor component.
+ *
+ * This hook can only be used in a component that is mounted
+ * as a child of the TiptapEditorView component, including
+ * React node view components.
+ */
+export declare function useTiptapEditorEffect(effect: (editor: Editor) => void | (() => void), dependencies?: DependencyList): void;

package/dist/types/tiptap/hooks/useTiptapEditorEventCallback.d.ts

@@ -0,0 +1,13 @@
+import { Editor } from "@tiptap/core";
+/**
+ * Returns a stable function reference to be used as an
+ * event handler callback.
+ *
+ * The callback will be called with the Tiptap Editor instance
+ * as its first argument.
+ *
+ * This hook can only be used in a component that is mounted
+ * as a child of the TiptapEditorView component, including
+ * React node view components.
+ */
+export declare function useTiptapEditorEventCallback<T extends unknown[], R>(callback: (editor: Editor, ...args: T) => R): (...args: T) => R;

package/dist/types/tiptap/index.d.ts

@@ -0,0 +1,9 @@
+export { tiptapNodeView } from "./tiptapNodeView.js";
+export { TiptapEditorView } from "./TiptapEditorView.js";
+export { TiptapEditorContent } from "./TiptapEditorContent.js";
+export { useTiptapEditorEffect } from "./hooks/useTiptapEditorEffect.js";
+export { useIsInReactProseMirror } from "./hooks/useIsInReactProseMirror.js";
+export { useTiptapEditorEventCallback } from "./hooks/useTiptapEditorEventCallback.js";
+export { TiptapEditor } from "./TiptapEditor.js";
+export { type UseTiptapEditorOptions, useTiptapEditor, } from "./hooks/useTiptapEditor.js";
+export { ReactProseMirror } from "./extensions/ReactProseMirror.js";

package/dist/types/tiptap/tiptapNodeView.d.ts

@@ -0,0 +1,50 @@
+import { type ReactNodeViewProps } from "@tiptap/react";
+import { type Node as ProseMirrorNode } from "prosemirror-model";
+import { ViewMutationRecord } from "prosemirror-view";
+import React, { type ComponentType, ElementType, Ref } from "react";
+import { NodeViewComponentProps } from "../components/nodes/NodeViewComponentProps.js";
+export interface TiptapNodeViewProps {
+    component: ComponentType<Omit<ReactNodeViewProps, "ref"> & {
+        ref?: Ref<HTMLElement | null>;
+    }>;
+    extension: ReactNodeViewProps["extension"];
+    className?: string | undefined;
+    attrs?: Record<string, string> | ((props: {
+        node: ProseMirrorNode;
+        HTMLAttributes: Record<string, unknown>;
+    }) => Record<string, string>) | undefined;
+    as?: ElementType | undefined;
+    stopEvent?: ((props: {
+        event: Event;
+        defaultStopEvent: (event: Event) => boolean;
+    }) => boolean) | null;
+    ignoreMutation?: ((props: {
+        mutation: ViewMutationRecord;
+        defaultIgnoreMutation: (mutation: ViewMutationRecord) => boolean;
+    }) => boolean) | null;
+    contentDOMElementTag?: ElementType | undefined;
+}
+/**
+ * Convert a Tiptap node view component to a React ProseMirror node view component
+ *
+ * Given a Tiptap-compatible React component and a Tiptap extension, returns
+ * a React component that can be passed to React ProseMirror as a custom node view.
+ *
+ * Example:
+ *
+ * ```tsx
+ * const nodeViews = {
+ *   codeBlock: nodeView({
+ *     component: function CodeBlock(nodeViewProps) {
+ *       return (
+ *         <pre>
+ *           <NodeViewContent as="code" />
+ *         </pre>
+ *       )
+ *     },
+ *     extension: CodeBlockExtension,
+ *   }),
+ * }
+ * ```
+ */
+export declare function tiptapNodeView({ component: WrappedComponent, extension, as, className, attrs, contentDOMElementTag: InnerTag, stopEvent, ignoreMutation, }: TiptapNodeViewProps): React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<NodeViewComponentProps, "ref"> & React.RefAttributes<HTMLElement | null>>>;

package/dist/types/viewdesc.d.ts

@@ -0,0 +1,179 @@
+import { Fragment, Mark, Node, TagParseRule } from "prosemirror-model";
+import { Decoration, DecorationSource, EditorView, NodeView } from "prosemirror-view";
+import { ReactEditorView } from "./ReactEditorView.js";
+import { DOMNode } from "./dom.js";
+declare global {
+    interface Node {
+        pmViewDesc?: ViewDesc;
+    }
+}
+export type ViewMutationRecord = MutationRecord | {
+    type: "selection";
+    target: DOMNode;
+};
+export declare function sortViewDescs(a: ViewDesc, b: ViewDesc): number;
+export declare const placeViewDesc: (siblings: ViewDesc[], desc: ViewDesc) => void;
+export declare class ViewDesc {
+    parent: ViewDesc | undefined;
+    children: ViewDesc[];
+    getPos: () => number;
+    dom: DOMNode;
+    contentDOM: HTMLElement | null;
+    dirty: number;
+    node: Node | null;
+    constructor(parent: ViewDesc | undefined, children: ViewDesc[], getPos: () => number, dom: DOMNode, contentDOM: HTMLElement | null);
+    matchesWidget(_widget: Decoration): boolean;
+    matchesMark(_mark: Mark): boolean;
+    matchesNode(_node: Node, _outerDeco: readonly Decoration[], _innerDeco: DecorationSource): boolean;
+    matchesHack(nodeName: string): boolean;
+    parseRule(): Omit<TagParseRule, "tag"> | null;
+    stopEvent(event: Event): boolean;
+    get size(): number;
+    get border(): number;
+    destroy(): void;
+    posBeforeChild(child: ViewDesc): number;
+    get posBefore(): number;
+    get posAtStart(): number;
+    get posAfter(): number;
+    get posAtEnd(): number;
+    localPosFromDOM(dom: DOMNode, offset: number, bias: number): number;
+    nearestDesc(dom: DOMNode): ViewDesc | undefined;
+    nearestDesc(dom: DOMNode, onlyNodes: true): NodeViewDesc | undefined;
+    getDesc(dom: DOMNode): ViewDesc | undefined;
+    posFromDOM(dom: DOMNode, offset: number, bias: number): number;
+    descAt(pos: number): ViewDesc | undefined;
+    domFromPos(pos: number, side: number): {
+        node: DOMNode;
+        offset: number;
+        atom?: number;
+    };
+    parseRange(from: number, to: number, base?: number): {
+        node: DOMNode;
+        from: number;
+        to: number;
+        fromOffset: number;
+        toOffset: number;
+    };
+    emptyChildAt(side: number): boolean;
+    domAfterPos(pos: number): DOMNode;
+    setSelection(anchor: number, head: number, view: ReactEditorView, force?: boolean): void;
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+    get contentLost(): boolean | null;
+    markDirty(from: number, to: number): void;
+    markParentsDirty(): void;
+    get domAtom(): boolean;
+    get ignoreForCoords(): boolean;
+    get ignoreForSelection(): boolean;
+    isText(_text: string): boolean;
+}
+export declare class WidgetViewDesc extends ViewDesc {
+    widget: Decoration;
+    constructor(parent: ViewDesc | undefined, getPos: () => number, widget: Decoration, dom: DOMNode);
+    matchesWidget(widget: Decoration): any;
+    parseRule(): {
+        ignore: boolean;
+    };
+    stopEvent(event: Event): any;
+    ignoreMutation(mutation: ViewMutationRecord): any;
+    get domAtom(): boolean;
+    get ignoreForSelection(): boolean;
+    get side(): number;
+}
+export declare class CompositionViewDesc extends ViewDesc {
+    textDOM: Text;
+    text: string;
+    constructor(parent: ViewDesc | undefined, getPos: () => number, dom: DOMNode, textDOM: Text, text: string);
+    get size(): number;
+    localPosFromDOM(dom: DOMNode, offset: number): number;
+    domFromPos(pos: number): {
+        node: Text;
+        offset: number;
+    };
+    ignoreMutation(mut: ViewMutationRecord): boolean;
+}
+export interface MarkView {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement | null;
+    update?: (mark: Mark) => boolean;
+    ignoreMutation?: (mutation: ViewMutationRecord) => boolean;
+    destroy?: () => void;
+}
+export declare class MarkViewDesc extends ViewDesc {
+    mark: Mark;
+    spec: MarkView;
+    constructor(parent: ViewDesc | undefined, children: ViewDesc[], getPos: () => number, mark: Mark, dom: HTMLElement, contentDOM: HTMLElement, spec: MarkView);
+    parseRule(): {
+        mark: string;
+        attrs: import("prosemirror-model").Attrs;
+        contentElement: HTMLElement;
+    } | null;
+    matchesMark(mark: Mark): boolean;
+    markDirty(from: number, to: number): void;
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+    destroy(): void;
+}
+export declare class NodeViewDesc extends ViewDesc {
+    node: Node;
+    outerDeco: readonly Decoration[];
+    innerDeco: DecorationSource;
+    nodeDOM: DOMNode;
+    constructor(parent: ViewDesc | undefined, children: ViewDesc[], getPos: () => number, node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, dom: DOMNode, contentDOM: HTMLElement | null, nodeDOM: DOMNode);
+    parseRule(addedNodes?: readonly DOMNode[]): Omit<TagParseRule, "tag"> | null;
+    matchesNode(node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource): boolean;
+    get size(): number;
+    get border(): 0 | 1;
+    updateChildren(_view: EditorView, _pos: number): void;
+    update(node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, view: EditorView): boolean;
+    updateInner(node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, view: EditorView): void;
+    updateOuterDeco(outerDeco: readonly Decoration[]): void;
+    selectNode(): void;
+    deselectNode(): void;
+    get domAtom(): boolean;
+}
+export declare class TextViewDesc extends NodeViewDesc {
+    constructor(parent: ViewDesc | undefined, children: ViewDesc[], getPos: () => number, node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, dom: DOMNode, nodeDOM: DOMNode);
+    parseRule(): {
+        skip: any;
+    };
+    update(node: Node, outerDeco: readonly Decoration[], _innerDeco: DecorationSource, _view: ReactEditorView): boolean;
+    inParent(): boolean;
+    domFromPos(pos: number): {
+        node: globalThis.Node;
+        offset: number;
+    };
+    localPosFromDOM(dom: DOMNode, offset: number, bias: number): number;
+    markDirty(from: number, to: number): void;
+    get domAtom(): boolean;
+    isText(text: string): boolean;
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+}
+export declare class TrailingHackViewDesc extends ViewDesc {
+    parseRule(): {
+        ignore: boolean;
+    };
+    matchesHack(nodeName: string): boolean;
+    get domAtom(): boolean;
+    get ignoreForCoords(): boolean;
+}
+declare class CustomNodeViewDesc extends NodeViewDesc {
+    readonly spec: NodeView;
+    constructor(parent: ViewDesc | undefined, children: ViewDesc[], getPos: () => number, node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, dom: HTMLElement, contentDOM: HTMLElement | null, nodeDOM: HTMLElement, spec: NodeView);
+    update(node: Node, outerDeco: readonly Decoration[], innerDeco: DecorationSource, view: EditorView): boolean;
+    selectNode(): void;
+    deselectNode(): void;
+    setSelection(anchor: number, head: number, view: ReactEditorView, force: boolean): void;
+    destroy(): void;
+    stopEvent(event: Event): boolean;
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+}
+export declare class ReactMarkViewDesc extends MarkViewDesc {
+    destroy(): void;
+}
+export declare class ReactNodeViewDesc extends CustomNodeViewDesc {
+    updateChildren(_view: EditorView, _pos: number): void;
+    updateOuterDeco(outerDeco: readonly Decoration[]): void;
+    destroy(): void;
+}
+export declare function sameOuterDeco(a: readonly Decoration[], b: readonly Decoration[]): boolean;
+export declare function findTextInFragment(frag: Fragment, text: string, from: number, to: number): number;
+export {};

package/package.json

@@ -0,0 +1,167 @@
+{
+  "name": "@stesura/react-prosemirror",
+  "version": "3.2.11-stesura.1",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./tiptap": {
+      "types": "./dist/types/tiptap/index.d.ts",
+      "import": "./dist/esm/tiptap/index.js",
+      "require": "./dist/cjs/tiptap/index.js"
+    },
+    "./src": "./src/index.ts"
+  },
+  "files": [
+    "README.md",
+    "LICENSE.txt",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stesura/react-prosemirror.git"
+  },
+  "scripts": {
+    "build:cjs": "swc ./src --ignore **/__tests__/** -d ./dist/cjs/ --no-swcrc --config-file .swcrc-cjs",
+    "build:esm": "swc ./src --ignore **/__tests__/** -d ./dist/esm/",
+    "build:types": "tsc --noEmit false --emitDeclarationOnly",
+    "build": "concurrently -P 'npm:build:* {@}' --",
+    "check:format": "prettier --check .",
+    "check:lint": "eslint --cache .",
+    "check:types": "tsc",
+    "check": "concurrently -P 'npm:check:* {@}' --",
+    "clean": "rimraf \"./dist/!(cjs/package.json)\"",
+    "demo": "yarn vite",
+    "demo:build": "yarn vite build --outDir docs --base=/react-prosemirror/",
+    "dev": "yarn build -- --watch",
+    "fix:format": "prettier --write .",
+    "fix:lint": "eslint --cache --fix .",
+    "fix:toc": "markdown-toc --bullets='-' -i README.md",
+    "fix": "concurrently -P 'npm:fix:* {@}' --",
+    "prepack": "yarn build",
+    "test:wdio": "wdio run ./wdio.conf.ts",
+    "test:unit": "jest",
+    "test": "yarn test:unit && yarn test:wdio"
+  },
+  "devDependencies": {
+    "@codemirror/commands": "^6.8.0",
+    "@codemirror/lang-javascript": "^6.2.2",
+    "@codemirror/state": "^6.5.1",
+    "@codemirror/view": "^6.36.2",
+    "@handlewithcare/remark-prosemirror": "^0.1.5",
+    "@jest/globals": "^29.6.2",
+    "@swc/cli": "^0.1.61",
+    "@swc/core": "^1.3.32",
+    "@swc/jest": "^0.2.24",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@tiptap/core": "^3.15.3",
+    "@tiptap/pm": "^3.15.3",
+    "@tiptap/react": "^3.15.3",
+    "@types/css-tree": "^2.3.10",
+    "@types/jest": "^27.0.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@types/react-reconciler": "^0.28.9",
+    "@typescript-eslint/eslint-plugin": "^5.51.0",
+    "@typescript-eslint/parser": "^5.51.0",
+    "@uiw/react-codemirror": "^4.23.7",
+    "@vitejs/plugin-basic-ssl": "^2.3.0",
+    "@vitejs/plugin-react": "^4.3.1",
+    "@wdio/browser-runner": "^9.18.1",
+    "@wdio/cli": "^9.18.1",
+    "@wdio/dot-reporter": "^9.18.0",
+    "@wdio/globals": "^9.17.0",
+    "@wdio/logger": "^9.18.0",
+    "@wdio/mocha-framework": "^9.18.0",
+    "@wdio/spec-reporter": "^9.18.0",
+    "@wdio/types": "^9.16.2",
+    "@yarnpkg/sdks": "^3.0.0-rc.38",
+    "concurrently": "^7.6.0",
+    "eslint": "^8.33.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-import-resolver-typescript": "^3.5.3",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-jest": "^27.2.1",
+    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "expect": "^29.7.0",
+    "expect-webdriverio": "^5.4.0",
+    "husky": "^8.0.3",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "lint-staged": "^13.1.0",
+    "markdown-toc": "^1.2.0",
+    "mdast-util-gfm-table": "^2.0.0",
+    "micromark-extension-gfm-table": "^2.1.1",
+    "prettier": "^2.8.3",
+    "prosemirror-commands": "^1.7.1",
+    "prosemirror-gapcursor": "^1.4.1",
+    "prosemirror-history": "^1.5.0",
+    "prosemirror-inputrules": "^1.5.1",
+    "prosemirror-keymap": "^1.2.3",
+    "prosemirror-model": "^1.25.8",
+    "prosemirror-schema-list": "^1.5.1",
+    "prosemirror-state": "^1.4.4",
+    "prosemirror-tables": "^1.8.5",
+    "prosemirror-test-builder": "^1.1.1",
+    "prosemirror-transform": "^1.12.0",
+    "prosemirror-view": "1.42.3",
+    "puppeteer-core": "^25.0.4",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-reconciler": "^0.29.0",
+    "remark-parse": "^11.0.0",
+    "rimraf": "^3.0.2",
+    "tsx": "^4.20.3",
+    "typescript": "^6.0.3",
+    "unified": "^11.0.5",
+    "vite": "^5.4.5",
+    "webdriver": "^9.18.0",
+    "webdriverio": "^9.18.1"
+  },
+  "resolutions": {
+    "prosemirror-view": "1.42.3"
+  },
+  "peerDependencies": {
+    "@tiptap/core": "^3.0.0",
+    "@tiptap/pm": "^3.0.0",
+    "@tiptap/react": "^3.0.0",
+    "prosemirror-model": "^1.0.0",
+    "prosemirror-state": "^1.0.0",
+    "prosemirror-transform": "^1.8.0",
+    "prosemirror-view": "1.42.3",
+    "react": ">=17 <20",
+    "react-dom": ">=17 <20",
+    "react-reconciler": ">=0.26.1 <=0.33.0"
+  },
+  "packageManager": "yarn@4.11.0",
+  "engines": {
+    "node": ">=16.9"
+  },
+  "peerDependenciesMeta": {
+    "@tiptap/core": {
+      "optional": true
+    },
+    "@tiptap/pm": {
+      "optional": true
+    },
+    "@tiptap/react": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "classnames": "^2.5.1"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  }
+}