@haklex/rich-ext-excalidraw 0.0.82 → 0.0.83

package/dist/index.mjs

@@ -1,87 +1,576 @@
-import { A as ExcalidrawConfigProvider, j as useExcalidrawConfig, n as parseSnapshot, r as serializeSnapshot } from "./useExcalidrawData-DcXa8vqV.js";
-import { r as _defineProperty, t as ExcalidrawDisplayRenderer } from "./ExcalidrawDisplayRenderer-C4fbKYqL.js";
-import { a as ExcalidrawSSRRenderer, i as ExcalidrawNode, n as $createExcalidrawNode, r as $isExcalidrawNode, t as EXCALIDRAW_BLOCK_TRANSFORMER } from "./transformer-DxW-N9IJ.js";
-import { t as ExcalidrawEditRenderer } from "./ExcalidrawEditRenderer-CSchoC4Y.js";
-import { Suspense, createElement, lazy, useEffect } from "react";
-import { ViewportGate } from "@haklex/rich-editor-ui";
-import { PenTool } from "lucide-react";
-import { $getNodeByKey, $insertNodes, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { c as ExcalidrawNode, s as serializeSnapshot, p as parseSnapshot, u as useExcalidrawConfig, e as useExcalidrawData, f as excalidrawFullscreenPopup, g as excalidrawEditorContainer, h as excalidrawLoading, i as excalidrawError, r as readonlyUIOptions, j as excalidrawEditOverlay, k as excalidrawEditLabel, l as excalidrawConfirmActions, m as excalidrawConfirmBtn, n as excalidrawConfirmBtnDanger, o as excalidrawConfirmBtnPrimary, q as excalidrawDialogHeader, t as excalidrawStatusDot, v as excalidrawDialogTitle, w as excalidrawDialogMeta, x as excalidrawHeaderActions, y as excalidrawActionBarSep, z as excalidrawActionBarBtn, A as excalidrawActionBarUrl, B as excalidrawHeaderClose, C as excalidrawDialogCanvas } from "./ExcalidrawNode-DEcONli3.js";
+import { $, a, E, b, b as b2, d, b as b3 } from "./ExcalidrawNode-DEcONli3.js";
+import { ViewportGate, presentDialog, SegmentedControl, dismissTopDialog } from "@haklex/rich-editor-ui";
+import { $insertNodes, $getNodeByKey, createCommand, COMMAND_PRIORITY_EDITOR } from "lexical";
+import { PenTool, Pencil, Save, Download, Clipboard, X } from "lucide-react";
+import { lazy, createElement, Suspense, useState, useRef, useEffect, useCallback } from "react";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { useColorScheme } from "@haklex/rich-editor";
+import { usePortalTheme } from "@haklex/rich-style-token";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-//#region src/ExcalidrawEditNode.ts
-var LazyEditRenderer = lazy(() => import("./ExcalidrawEditRenderer-CSchoC4Y.js").then((n) => n.n).then((m) => ({ default: m.ExcalidrawEditRenderer })));
-var ExcalidrawEditNode = class ExcalidrawEditNode extends ExcalidrawNode {
-	static clone(node) {
-		return new ExcalidrawEditNode(node.__snapshot, node.__key);
-	}
-	constructor(snapshot, key) {
-		super(snapshot, key);
-	}
-	static importJSON(serializedNode) {
-		return new ExcalidrawEditNode(serializedNode.snapshot);
-	}
-	decorate(editor, config) {
-		if (!editor.isEditable()) return super.decorate(editor, config);
-		const nodeKey = this.__key;
-		const fallback = createElement("div", {
-			className: "rich-excalidraw-loading",
-			style: {
-				position: "relative",
-				width: "100%",
-				aspectRatio: "16 / 10",
-				margin: "1rem 0"
-			}
-		});
-		return createElement(ViewportGate, {
-			fallback,
-			children: createElement(Suspense, { fallback }, createElement(LazyEditRenderer, {
-				snapshot: parseSnapshot(this.__snapshot),
-				onSnapshotChange: (snapshot) => {
-					editor.update(() => {
-						const node = $getNodeByKey(nodeKey);
-						if (node) node.setSnapshot(serializeSnapshot(snapshot));
-					});
-				}
-			}))
-		});
-	}
+import { EXCALIDRAW_BLOCK_TRANSFORMER } from "@haklex/rich-headless/transformers";
+const LazyEditRenderer = lazy(
+  () => Promise.resolve().then(() => ExcalidrawEditRenderer$1).then((m) => ({
+    default: m.ExcalidrawEditRenderer
+  }))
+);
+const _ExcalidrawEditNode = class _ExcalidrawEditNode extends ExcalidrawNode {
+  static clone(node) {
+    return new _ExcalidrawEditNode(node.__snapshot, node.__key);
+  }
+  constructor(snapshot, key) {
+    super(snapshot, key);
+  }
+  static importJSON(serializedNode) {
+    return new _ExcalidrawEditNode(serializedNode.snapshot);
+  }
+  decorate(editor, config) {
+    const isEditable = editor.isEditable();
+    if (!isEditable) {
+      return super.decorate(editor, config);
+    }
+    const nodeKey = this.__key;
+    const fallback = createElement("div", {
+      className: "rich-excalidraw-loading",
+      style: {
+        position: "relative",
+        width: "100%",
+        aspectRatio: "16 / 10",
+        margin: "1rem 0"
+      }
+    });
+    return createElement(ViewportGate, {
+      fallback,
+      children: createElement(
+        Suspense,
+        { fallback },
+        createElement(LazyEditRenderer, {
+          snapshot: parseSnapshot(this.__snapshot),
+          onSnapshotChange: (snapshot) => {
+            editor.update(() => {
+              const node = $getNodeByKey(nodeKey);
+              if (node) {
+                node.setSnapshot(serializeSnapshot(snapshot));
+              }
+            });
+          }
+        })
+      )
+    });
+  }
 };
-_defineProperty(ExcalidrawEditNode, "commandItems", [{
-	title: "Whiteboard",
-	icon: createElement(PenTool, { size: 20 }),
-	description: "Excalidraw whiteboard canvas",
-	keywords: [
-		"excalidraw",
-		"whiteboard",
-		"draw",
-		"canvas"
-	],
-	section: "MEDIA",
-	placement: ["slash", "toolbar"],
-	group: "insert",
-	onSelect: (editor) => {
-		editor.update(() => {
-			$insertNodes([$createExcalidrawEditNode("{}")]);
-		});
-	}
-}]);
+__publicField(_ExcalidrawEditNode, "commandItems", [
+  {
+    title: "Whiteboard",
+    icon: createElement(PenTool, { size: 20 }),
+    description: "Excalidraw whiteboard canvas",
+    keywords: ["excalidraw", "whiteboard", "draw", "canvas"],
+    section: "MEDIA",
+    placement: ["slash", "toolbar"],
+    group: "insert",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createExcalidrawEditNode("{}")]);
+      });
+    }
+  }
+]);
+let ExcalidrawEditNode = _ExcalidrawEditNode;
 function $createExcalidrawEditNode(snapshot) {
-	return new ExcalidrawEditNode(snapshot);
+  return new ExcalidrawEditNode(snapshot);
 }
 function $isExcalidrawEditNode(node) {
-	return node instanceof ExcalidrawEditNode;
+  return node instanceof ExcalidrawEditNode;
 }
-//#endregion
-//#region src/ExcalidrawPlugin.tsx
-var INSERT_EXCALIDRAW_COMMAND = createCommand("INSERT_EXCALIDRAW");
+const SAVE_DEBOUNCE_MS = 2e3;
+const ExcalidrawEditorDialogContent = ({
+  dismiss,
+  ExcalidrawComponent,
+  initialData,
+  initialSnapshot,
+  theme,
+  onSave,
+  saveSnapshot,
+  onClose,
+  baseRef,
+  baseData
+}) => {
+  const { className: portalClassName } = usePortalTheme();
+  const apiRef = useRef(null);
+  const saveTimerRef = useRef(void 0);
+  const [isDirty, setIsDirty] = useState(false);
+  const isDirtyRef = useRef(false);
+  const confirmDialogOpenRef = useRef(false);
+  const initializedRef = useRef(false);
+  const baseRefRef = useRef(baseRef);
+  const baseDataRef = useRef(baseData);
+  const [storageMode, setStorageMode] = useState(() => {
+    if (!saveSnapshot || !initialSnapshot) return "inline";
+    return initialSnapshot.type === "delta" ? "delta" : initialSnapshot.type === "remote" ? "remote" : "inline";
+  });
+  const storageModeRef = useRef(storageMode);
+  const [savedRef, setSavedRef] = useState(() => {
+    if (!saveSnapshot || !initialSnapshot) return "";
+    if (initialSnapshot.type === "remote") return initialSnapshot.url;
+    if (initialSnapshot.type === "delta") return initialSnapshot.baseUrl;
+    return "";
+  });
+  const [isSaving, setIsSaving] = useState(false);
+  useEffect(() => {
+    return () => {
+      if (saveTimerRef.current) clearTimeout(saveTimerRef.current);
+    };
+  }, []);
+  const getSnapshot = useCallback(() => {
+    const api = apiRef.current;
+    if (!api) return;
+    const appState = api.getAppState();
+    return {
+      elements: api.getSceneElements(),
+      appState: {
+        viewBackgroundColor: appState.viewBackgroundColor,
+        gridSize: appState.gridSize
+      },
+      files: api.getFiles()
+    };
+  }, []);
+  const performSave = useCallback(() => {
+    if (saveTimerRef.current) clearTimeout(saveTimerRef.current);
+    const doc = getSnapshot();
+    if (!doc) return Promise.resolve();
+    const mode = storageModeRef.current;
+    if (mode === "delta" && saveSnapshot) {
+      setIsSaving(true);
+      return (async () => {
+        try {
+          const currentBaseUrl = baseRefRef.current;
+          const currentBaseData = baseDataRef.current;
+          if (!currentBaseUrl || !currentBaseData) {
+            const ref = await saveSnapshot(doc, baseRefRef.current || void 0);
+            baseRefRef.current = ref;
+            baseDataRef.current = doc;
+            setSavedRef(ref);
+          }
+          isDirtyRef.current = false;
+          setIsDirty(false);
+        } finally {
+          setIsSaving(false);
+        }
+      })();
+    }
+    if (mode === "remote" && saveSnapshot) {
+      if (baseRefRef.current && baseDataRef.current && JSON.stringify(doc) === JSON.stringify(baseDataRef.current)) {
+        isDirtyRef.current = false;
+        setIsDirty(false);
+        return Promise.resolve();
+      }
+      setIsSaving(true);
+      return saveSnapshot(doc, baseRefRef.current || void 0).then(
+        (ref) => {
+          baseRefRef.current = ref;
+          baseDataRef.current = doc;
+          isDirtyRef.current = false;
+          setIsDirty(false);
+          setIsSaving(false);
+          setSavedRef(ref);
+        },
+        () => {
+          setIsSaving(false);
+        }
+      );
+    }
+    isDirtyRef.current = false;
+    setIsDirty(false);
+    return Promise.resolve();
+  }, [saveSnapshot, getSnapshot]);
+  const emitSnapshot = useCallback(async () => {
+    const doc = getSnapshot();
+    if (!doc) return;
+    const mode = storageModeRef.current;
+    if (mode === "delta" && saveSnapshot) {
+      const currentBaseUrl = baseRefRef.current;
+      const currentBaseData = baseDataRef.current;
+      if (currentBaseUrl && currentBaseData) {
+        const { diff } = await import("jsondiffpatch");
+        const delta = diff(currentBaseData, structuredClone(doc));
+        onSave(
+          delta ? { type: "delta", baseUrl: currentBaseUrl, delta } : { type: "remote", url: currentBaseUrl }
+        );
+      } else {
+        const ref = await saveSnapshot(doc, baseRefRef.current || void 0);
+        onSave({ type: "remote", url: ref });
+      }
+      return;
+    }
+    if (mode === "remote") {
+      const ref = baseRefRef.current;
+      if (ref) {
+        onSave({ type: "remote", url: ref });
+      } else if (saveSnapshot) {
+        const newRef = await saveSnapshot(doc);
+        onSave({ type: "remote", url: newRef });
+      }
+      return;
+    }
+    onSave({ type: "inline", data: doc });
+  }, [onSave, saveSnapshot, getSnapshot]);
+  const handleChange = useCallback(
+    (elements) => {
+      if (!initializedRef.current) {
+        initializedRef.current = true;
+        return;
+      }
+      if (elements.length === 0) return;
+      if (!isDirtyRef.current) {
+        isDirtyRef.current = true;
+        setIsDirty(true);
+      }
+      if (saveTimerRef.current) clearTimeout(saveTimerRef.current);
+      saveTimerRef.current = setTimeout(() => performSave(), SAVE_DEBOUNCE_MS);
+    },
+    [performSave]
+  );
+  const handleSaveAndClose = useCallback(() => {
+    void performSave().then(async () => {
+      await emitSnapshot();
+      onClose(getSnapshot());
+      dismiss();
+    });
+  }, [performSave, emitSnapshot, getSnapshot, onClose, dismiss]);
+  const handleDiscard = useCallback(() => {
+    if (saveTimerRef.current) clearTimeout(saveTimerRef.current);
+    dismiss();
+  }, [dismiss]);
+  const showConfirmDialog = useCallback(() => {
+    if (confirmDialogOpenRef.current) return;
+    confirmDialogOpenRef.current = true;
+    presentDialog({
+      title: "Unsaved Changes",
+      description: "You have unsaved changes that will be lost if you close now.",
+      content: ({ dismiss: dismissConfirm }) => {
+        const wrappedDismiss = () => {
+          confirmDialogOpenRef.current = false;
+          dismissConfirm();
+        };
+        return /* @__PURE__ */ jsxs("div", { className: excalidrawConfirmActions, children: [
+          /* @__PURE__ */ jsx("button", { className: excalidrawConfirmBtn, type: "button", onClick: wrappedDismiss, children: "Continue Editing" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: excalidrawConfirmBtnDanger,
+              type: "button",
+              onClick: () => {
+                wrappedDismiss();
+                handleDiscard();
+              },
+              children: "Discard"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: excalidrawConfirmBtnPrimary,
+              type: "button",
+              onClick: () => {
+                wrappedDismiss();
+                handleSaveAndClose();
+              },
+              children: "Save & Close"
+            }
+          )
+        ] });
+      },
+      portalClassName,
+      theme,
+      showCloseButton: false,
+      clickOutsideToDismiss: false
+    });
+  }, [handleDiscard, handleSaveAndClose, portalClassName, theme]);
+  const attemptClose = useCallback(() => {
+    if (isDirtyRef.current) {
+      showConfirmDialog();
+    } else {
+      void emitSnapshot().then(() => {
+        onClose(getSnapshot());
+        dismiss();
+      });
+    }
+  }, [dismiss, showConfirmDialog, emitSnapshot, getSnapshot, onClose]);
+  useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+        if (confirmDialogOpenRef.current) {
+          confirmDialogOpenRef.current = false;
+          dismissTopDialog();
+        } else {
+          attemptClose();
+        }
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown, true);
+    return () => document.removeEventListener("keydown", handleKeyDown, true);
+  }, [attemptClose]);
+  const handleManualUpload = useCallback(() => {
+    performSave();
+  }, [performSave]);
+  const handleExportJson = useCallback(() => {
+    const doc = getSnapshot();
+    if (!doc) return;
+    const blob = new Blob([JSON.stringify(doc, null, 2)], {
+      type: "application/json"
+    });
+    const url = URL.createObjectURL(blob);
+    const a2 = document.createElement("a");
+    a2.href = url;
+    a2.download = "excalidraw-snapshot.json";
+    a2.click();
+    URL.revokeObjectURL(url);
+  }, [getSnapshot]);
+  const handleCopyJson = useCallback(() => {
+    const doc = getSnapshot();
+    if (!doc) return;
+    void navigator.clipboard.writeText(JSON.stringify(doc));
+  }, [getSnapshot]);
+  const handleRefChange = useCallback((e) => {
+    const { value } = e.target;
+    setSavedRef(value);
+    baseRefRef.current = value;
+    baseDataRef.current = void 0;
+  }, []);
+  const handleStorageModeChange = useCallback(
+    (newMode) => {
+      setStorageMode(newMode);
+      storageModeRef.current = newMode;
+      if (newMode === "inline") setSavedRef("");
+      performSave();
+    },
+    [performSave]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { className: excalidrawDialogHeader, children: [
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: excalidrawStatusDot,
+          style: { backgroundColor: isDirty ? "#f59e0b" : "#22c55e" }
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { className: excalidrawDialogTitle, children: "Canvas Editor" }),
+      /* @__PURE__ */ jsx("span", { className: excalidrawDialogMeta, children: "excalidraw" }),
+      /* @__PURE__ */ jsxs("div", { className: excalidrawHeaderActions, children: [
+        saveSnapshot && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(
+            SegmentedControl,
+            {
+              value: storageMode,
+              items: [
+                { value: "inline", label: "Inline" },
+                { value: "remote", label: "Remote" },
+                { value: "delta", label: "Delta" }
+              ],
+              onChange: handleStorageModeChange
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: excalidrawActionBarSep }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              className: excalidrawActionBarBtn,
+              disabled: isSaving,
+              type: "button",
+              onClick: handleManualUpload,
+              children: [
+                /* @__PURE__ */ jsx(Save, { size: 14 }),
+                /* @__PURE__ */ jsx("span", { children: isSaving ? "Saving..." : "Save" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: excalidrawActionBarSep })
+        ] }),
+        /* @__PURE__ */ jsxs("button", { className: excalidrawActionBarBtn, type: "button", onClick: handleExportJson, children: [
+          /* @__PURE__ */ jsx(Download, { size: 14 }),
+          "JSON"
+        ] }),
+        /* @__PURE__ */ jsxs("button", { className: excalidrawActionBarBtn, type: "button", onClick: handleCopyJson, children: [
+          /* @__PURE__ */ jsx(Clipboard, { size: 14 }),
+          "Copy"
+        ] }),
+        storageMode !== "inline" && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("div", { className: excalidrawActionBarSep }),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              className: excalidrawActionBarUrl,
+              placeholder: "base URL / ref",
+              spellCheck: false,
+              type: "text",
+              value: savedRef,
+              onChange: handleRefChange
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("button", { className: excalidrawHeaderClose, type: "button", onClick: attemptClose, children: /* @__PURE__ */ jsx(X, { size: 18 }) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: excalidrawDialogCanvas, children: /* @__PURE__ */ jsx(
+      ExcalidrawComponent,
+      {
+        initialData,
+        theme,
+        excalidrawAPI: (api) => {
+          apiRef.current = api;
+        },
+        onChange: handleChange
+      }
+    ) })
+  ] });
+};
+const ExcalidrawEditRenderer = ({
+  snapshot,
+  onSnapshotChange
+}) => {
+  const theme = useColorScheme();
+  const { saveSnapshot } = useExcalidrawConfig();
+  const {
+    snapshot: initialData,
+    loading: dataLoading,
+    error: dataError,
+    baseRef,
+    baseData
+  } = useExcalidrawData(snapshot);
+  const [ExcalidrawComponent, setExcalidrawComponent] = useState(null);
+  const [libLoading, setLibLoading] = useState(true);
+  const previewApiRef = useRef(null);
+  const initialDataRef = useRef(void 0);
+  const [previewKey, setPreviewKey] = useState(0);
+  const onSnapshotChangeRef = useRef(onSnapshotChange);
+  onSnapshotChangeRef.current = onSnapshotChange;
+  const saveSnapshotRef = useRef(saveSnapshot);
+  saveSnapshotRef.current = saveSnapshot;
+  const snapshotRef = useRef(snapshot);
+  snapshotRef.current = snapshot;
+  const { className: portalClassName } = usePortalTheme();
+  useEffect(() => {
+    if (initialData && !initialDataRef.current) {
+      initialDataRef.current = initialData;
+    }
+  }, [initialData]);
+  useEffect(() => {
+    import("@excalidraw/excalidraw").then((mod) => {
+      const Comp = mod.Excalidraw || mod.default?.Excalidraw;
+      if (Comp) setExcalidrawComponent(() => Comp);
+      setLibLoading(false);
+    }).catch(() => setLibLoading(false));
+  }, []);
+  const baseRefRef = useRef(baseRef);
+  const baseDataRefOuter = useRef(baseData);
+  useEffect(() => {
+    if (baseRef) baseRefRef.current = baseRef;
+  }, [baseRef]);
+  useEffect(() => {
+    if (baseData) baseDataRefOuter.current = baseData;
+  }, [baseData]);
+  const handleOpenEditor = useCallback(() => {
+    if (!ExcalidrawComponent || dataLoading) return;
+    presentDialog({
+      content: ({ dismiss }) => /* @__PURE__ */ jsx(
+        ExcalidrawEditorDialogContent,
+        {
+          ExcalidrawComponent,
+          baseData: baseDataRefOuter.current,
+          baseRef: baseRefRef.current,
+          dismiss,
+          initialData: initialDataRef.current,
+          initialSnapshot: snapshotRef.current,
+          saveSnapshot: saveSnapshotRef.current,
+          theme,
+          onSave: (ref) => onSnapshotChangeRef.current(ref),
+          onClose: (doc) => {
+            if (doc) {
+              initialDataRef.current = doc;
+              setPreviewKey((k) => k + 1);
+            }
+          }
+        }
+      ),
+      className: excalidrawFullscreenPopup,
+      portalClassName,
+      theme,
+      showCloseButton: false,
+      clickOutsideToDismiss: false
+    });
+  }, [ExcalidrawComponent, dataLoading, theme, portalClassName]);
+  const loading = dataLoading || libLoading;
+  if (loading || !ExcalidrawComponent) {
+    return /* @__PURE__ */ jsx("div", { className: excalidrawEditorContainer, children: /* @__PURE__ */ jsx("div", { className: excalidrawLoading, children: "Loading excalidraw editor..." }) });
+  }
+  if (dataError) {
+    return /* @__PURE__ */ jsx("div", { className: excalidrawEditorContainer, children: /* @__PURE__ */ jsx("div", { className: excalidrawError, children: dataError }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: excalidrawEditorContainer, children: [
+    /* @__PURE__ */ jsx(
+      ExcalidrawComponent,
+      {
+        viewModeEnabled: true,
+        zenModeEnabled: true,
+        UIOptions: readonlyUIOptions,
+        initialData: initialDataRef.current,
+        theme,
+        excalidrawAPI: (api) => {
+          previewApiRef.current = api;
+          setTimeout(() => api.scrollToContent(), 100);
+        }
+      },
+      previewKey
+    ),
+    /* @__PURE__ */ jsx("button", { className: excalidrawEditOverlay, type: "button", onClick: handleOpenEditor, children: /* @__PURE__ */ jsxs("span", { className: excalidrawEditLabel, children: [
+      /* @__PURE__ */ jsx(Pencil, { size: 16 }),
+      "Edit Whiteboard"
+    ] }) })
+  ] });
+};
+const ExcalidrawEditRenderer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ExcalidrawEditRenderer
+}, Symbol.toStringTag, { value: "Module" }));
+const INSERT_EXCALIDRAW_COMMAND = createCommand("INSERT_EXCALIDRAW");
 function ExcalidrawPlugin() {
-	const [editor] = useLexicalComposerContext();
-	useEffect(() => {
-		return editor.registerCommand(INSERT_EXCALIDRAW_COMMAND, (snapshot) => {
-			$insertNodes([$createExcalidrawEditNode(snapshot)]);
-			return true;
-		}, COMMAND_PRIORITY_EDITOR);
-	}, [editor]);
-	return null;
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return editor.registerCommand(
+      INSERT_EXCALIDRAW_COMMAND,
+      (snapshot) => {
+        const node = $createExcalidrawEditNode(snapshot);
+        $insertNodes([node]);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR
+    );
+  }, [editor]);
+  return null;
 }
-//#endregion
-export { $createExcalidrawEditNode, $createExcalidrawNode, $isExcalidrawEditNode, $isExcalidrawNode, EXCALIDRAW_BLOCK_TRANSFORMER, ExcalidrawConfigProvider, ExcalidrawDisplayRenderer, ExcalidrawDisplayRenderer as ExcalidrawRenderer, ExcalidrawDisplayRenderer as ExcalidrawStaticRenderer, ExcalidrawEditNode, ExcalidrawEditRenderer, ExcalidrawNode, ExcalidrawPlugin, ExcalidrawSSRRenderer, INSERT_EXCALIDRAW_COMMAND, parseSnapshot, serializeSnapshot, useExcalidrawConfig };
+export {
+  $createExcalidrawEditNode,
+  $ as $createExcalidrawNode,
+  $isExcalidrawEditNode,
+  a as $isExcalidrawNode,
+  EXCALIDRAW_BLOCK_TRANSFORMER,
+  E as ExcalidrawConfigProvider,
+  b as ExcalidrawDisplayRenderer,
+  ExcalidrawEditNode,
+  ExcalidrawEditRenderer,
+  ExcalidrawNode,
+  ExcalidrawPlugin,
+  b2 as ExcalidrawRenderer,
+  d as ExcalidrawSSRRenderer,
+  b3 as ExcalidrawStaticRenderer,
+  INSERT_EXCALIDRAW_COMMAND,
+  parseSnapshot,
+  serializeSnapshot,
+  useExcalidrawConfig
+};