@lobehub/editor 4.15.1 → 4.15.2

package/es/editor-kernel/plugin.js

@@ -0,0 +1,59 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import EventEmitter from "eventemitter3";
+//#region src/editor-kernel/plugin.ts
+var KernelPlugin;
+var init_plugin = __esmMin((() => {
+	KernelPlugin = class extends EventEmitter {
+		constructor(..._args) {
+			super(..._args);
+			this.clears = [];
+			this.registeredDecorators = /* @__PURE__ */ new Set();
+		}
+		register(clear) {
+			this.clears.push(clear);
+		}
+		registerClears(...clears) {
+			clears.forEach((clear) => this.register(clear));
+		}
+		/**
+		* Register a node transform and automatically clean it up on plugin destroy
+		*/
+		registerNodeTransform(kernel, transform) {
+			this.register(kernel.registerNodeTransform(transform));
+		}
+		/**
+		* Register className(s) on contenteditable root and auto cleanup
+		*/
+		registerRootClassName(kernel, className) {
+			this.register(kernel.registerRootClassName(className));
+		}
+		/**
+		* Register a decorator and track it for cleanup
+		*/
+		registerDecorator(kernel, name, decorator) {
+			kernel.registerDecorator(name, decorator);
+			this.registeredDecorators.add(name);
+		}
+		/**
+		* Unregister a specific decorator
+		*/
+		unregisterDecorator(kernel, name) {
+			const result = kernel.unregisterDecorator(name);
+			if (result) this.registeredDecorators.delete(name);
+			return result;
+		}
+		/**
+		* Get all decorator names registered by this plugin
+		*/
+		getRegisteredDecorators() {
+			return Array.from(this.registeredDecorators);
+		}
+		destroy() {
+			this.clears.forEach((clear) => clear());
+			this.registeredDecorators.clear();
+		}
+	};
+}));
+//#endregion
+init_plugin();
+export { KernelPlugin, init_plugin };

package/es/editor-kernel/react/LexicalErrorBoundary.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from "react";
+
+//#region src/editor-kernel/react/LexicalErrorBoundary.d.ts
+type LexicalErrorBoundaryProps = {
+  children: JSX.Element;
+  onError: (error: unknown) => void;
+};
+declare function LexicalErrorBoundary({
+  children,
+  onError
+}: LexicalErrorBoundaryProps): JSX.Element;
+//#endregion
+export { LexicalErrorBoundary };

package/es/editor-kernel/react/LexicalErrorBoundary.js

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import { ErrorBoundary } from "react-error-boundary";
+//#region src/editor-kernel/react/LexicalErrorBoundary.tsx
+function LexicalErrorBoundary({ children, onError }) {
+	return /* @__PURE__ */ jsx(ErrorBoundary, {
+		fallback: /* @__PURE__ */ jsx("div", {
+			style: {
+				border: "1px solid #f00",
+				color: "#f00",
+				padding: "8px"
+			},
+			children: "An error was thrown."
+		}),
+		onError,
+		children
+	});
+}
+//#endregion
+export { LexicalErrorBoundary };

package/es/editor-kernel/react/PortalAnchor.js

@@ -0,0 +1,12 @@
+"use client";
+import { useAnchor } from "./useAnchor.js";
+import { createPortal } from "react-dom";
+//#region src/editor-kernel/react/PortalAnchor.tsx
+const PortalAnchor = ({ children }) => {
+	const targetElement = useAnchor();
+	if (!targetElement) return null;
+	return createPortal(children, targetElement);
+};
+PortalAnchor.displayName = "PortalAnchor";
+//#endregion
+export { PortalAnchor as default };

package/es/editor-kernel/react/PortalContainer.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { LexicalEditor, LexicalNode } from "lexical";
+
+//#region src/editor-kernel/react/PortalContainer.d.ts
+interface PortalContainerProps {
+  children: React.ReactNode;
+  className?: string;
+  editor: LexicalEditor;
+  node: LexicalNode;
+  style?: React.CSSProperties;
+}
+declare const LexicalPortalContainer: React.ForwardRefExoticComponent<PortalContainerProps & React.RefAttributes<HTMLDivElement | null>>;
+//#endregion
+export { LexicalPortalContainer };

package/es/editor-kernel/react/PortalContainer.js

@@ -0,0 +1,25 @@
+import { forwardRef, useEffect, useImperativeHandle, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/editor-kernel/react/PortalContainer.tsx
+const LexicalPortalContainer = forwardRef(({ editor, node, children }, ref) => {
+	const divRef = useRef(null);
+	useImperativeHandle(ref, () => divRef.current, []);
+	useEffect(() => {
+		return () => {
+			if (divRef.current) delete divRef.current[`__lexicalKey_${editor._key}`];
+		};
+	}, [editor, node]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: (dom) => {
+			divRef.current = dom;
+			if (dom) {
+				const prop = `__lexicalKey_${editor._key}`;
+				dom[prop] = node.getKey();
+			}
+		},
+		children
+	});
+});
+LexicalPortalContainer.displayName = "LexicalPortalContainer";
+//#endregion
+export { LexicalPortalContainer as default };

package/es/editor-kernel/react/index.d.ts

@@ -0,0 +1,5 @@
+import { LexicalErrorBoundary } from "./LexicalErrorBoundary.js";
+import { LexicalPortalContainer } from "./PortalContainer.js";
+import { useLexicalComposerContext } from "./react-context.js";
+import { ReactEditor } from "./react-editor.js";
+import { useLexicalEditor } from "./useLexicalEditor.js";

package/es/editor-kernel/react/react-context.d.ts

@@ -0,0 +1,11 @@
+import { IEditor } from "../../types/kernel.js";
+import { EditorThemeClasses } from "lexical";
+
+//#region src/editor-kernel/react/react-context.d.ts
+type LexicalComposerContextType = {
+  getTheme: () => EditorThemeClasses | null | undefined;
+};
+type LexicalComposerContextWithEditor = [IEditor, LexicalComposerContextType];
+declare function useLexicalComposerContext(): LexicalComposerContextWithEditor;
+//#endregion
+export { useLexicalComposerContext };

package/es/editor-kernel/react/react-context.js

@@ -0,0 +1,21 @@
+import { assert, init_utils } from "../utils.js";
+import { createContext, use } from "react";
+//#region src/editor-kernel/react/react-context.ts
+init_utils();
+const LexicalComposerContext = createContext(null);
+function createLexicalComposerContext(parent, theme) {
+	let parentContext = null;
+	if (parent) parentContext = parent[1];
+	function getTheme() {
+		if (theme !== null) return theme;
+		return parentContext !== null ? parentContext.getTheme() : null;
+	}
+	return { getTheme };
+}
+function useLexicalComposerContext() {
+	const composerContext = use(LexicalComposerContext);
+	if (!composerContext) assert(false, "LexicalComposerContext.useLexicalComposerContext: cannot find a LexicalComposerContext");
+	return composerContext;
+}
+//#endregion
+export { LexicalComposerContext, createLexicalComposerContext, useLexicalComposerContext };

package/es/editor-kernel/react/react-editor.d.ts

@@ -0,0 +1,16 @@
+import { IEditor } from "../../types/kernel.js";
+import { FC, ReactNode } from "react";
+
+//#region src/editor-kernel/react/react-editor.d.ts
+interface IReactEditorProps {
+  children?: ReactNode | undefined;
+  /** Editor configuration */
+  config?: Record<string, any>;
+  /** Editor instance to use */
+  editor?: IEditor;
+  /** Callback called when editor is initialized */
+  onInit?: (editor: IEditor) => void;
+}
+declare const ReactEditor: FC<IReactEditorProps>;
+//#endregion
+export { ReactEditor };

package/es/editor-kernel/react/react-editor.js

@@ -0,0 +1,32 @@
+import Editor from "../index.js";
+import { LexicalComposerContext, createLexicalComposerContext, useLexicalComposerContext } from "./react-context.js";
+import { useEffect, useMemo, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/editor-kernel/react/react-editor.tsx
+/**
+* Support configuration through react children
+*/
+const ConfigInjector = ({ config }) => {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		if (config?.locale && Object.keys(config.locale).length > 0) editor.registerLocale(config.locale);
+	}, [editor, config]);
+	return null;
+};
+const ReactEditor = ({ editor: editorProp, children, config, onInit }) => {
+	const composerContext = useMemo(() => {
+		return [editorProp || Editor.createEditor(), createLexicalComposerContext(null, null)];
+	}, [editorProp]);
+	const onInitRef = useRef(onInit);
+	onInitRef.current = onInit;
+	useEffect(() => {
+		const editor = composerContext[0];
+		onInitRef.current?.(editor);
+	}, [composerContext]);
+	return /* @__PURE__ */ jsxs(LexicalComposerContext, {
+		value: composerContext,
+		children: [/* @__PURE__ */ jsx(ConfigInjector, { config }), children]
+	});
+};
+//#endregion
+export { ReactEditor };

package/es/editor-kernel/react/useAnchor.js

@@ -0,0 +1,17 @@
+"use client";
+import { useLexicalComposerContext } from "./react-context.js";
+import { LOBE_THEME_APP_ID } from "@lobehub/ui";
+import { useMemo } from "react";
+//#region src/editor-kernel/react/useAnchor.ts
+const useAnchor = () => {
+	const [editor] = useLexicalComposerContext();
+	return useMemo(() => {
+		if (typeof document === "undefined" || !editor) return;
+		const root = editor.getRootElement();
+		const anchor = root ? root.parentElement : null;
+		if (anchor) return anchor;
+		return document.querySelector(`#${LOBE_THEME_APP_ID}`) || document.body;
+	}, [editor]);
+};
+//#endregion
+export { useAnchor };

package/es/editor-kernel/react/useDecorators.js

@@ -0,0 +1,54 @@
+import { CAN_USE_DOM } from "../../common/canUseDOM.js";
+import { Suspense, useEffect, useLayoutEffect, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { createPortal, flushSync } from "react-dom";
+//#region src/editor-kernel/react/useDecorators.tsx
+const useLayoutEffectImpl = CAN_USE_DOM ? useLayoutEffect : useEffect;
+function useDecorators(editor, ErrorBoundary) {
+	const [decorators, setDecorators] = useState(() => editor.getLexicalEditor()?.getDecorators() || {});
+	useLayoutEffectImpl(() => {
+		let clears = [];
+		const handleInit = (editor) => {
+			setDecorators(editor.getDecorators());
+			clears.push(editor.registerDecoratorListener((nextDecorators) => {
+				flushSync(() => {
+					setDecorators(nextDecorators);
+				});
+			}));
+		};
+		const lexicalEditor = editor.getLexicalEditor();
+		if (lexicalEditor) handleInit(lexicalEditor);
+		else {
+			editor.on("initialized", handleInit);
+			clears.push(() => {
+				editor.off("initialized", handleInit);
+			});
+		}
+		return () => {
+			clears.forEach((clear) => clear());
+		};
+	}, [editor]);
+	return useMemo(() => {
+		const decoratedPortals = [];
+		const decoratorKeys = Object.keys(decorators);
+		for (const nodeKey of decoratorKeys) {
+			const decorator = decorators[nodeKey];
+			const reactDecorator = /* @__PURE__ */ jsx(ErrorBoundary, {
+				onError: (e) => editor.getLexicalEditor()?._onError(e),
+				children: /* @__PURE__ */ jsx(Suspense, {
+					fallback: null,
+					children: "render" in decorator ? decorator.render : decorator
+				})
+			});
+			const element = editor.getLexicalEditor()?.getElementByKey(nodeKey);
+			if (element !== null && element !== void 0) decoratedPortals.push(createPortal(reactDecorator, "queryDOM" in decorator ? decorator.queryDOM(element) : element, nodeKey));
+		}
+		return decoratedPortals;
+	}, [
+		ErrorBoundary,
+		decorators,
+		editor
+	]);
+}
+//#endregion
+export { useDecorators };

package/es/editor-kernel/react/useEditable.js

@@ -0,0 +1,25 @@
+"use client";
+import { useLexicalComposerContext } from "./react-context.js";
+import { useEffect, useState } from "react";
+//#region src/editor-kernel/react/useEditable.ts
+const useEditable = () => {
+	const [editor] = useLexicalComposerContext();
+	const [editable, setEditable] = useState(editor.isEditable());
+	useEffect(() => {
+		const updateEditable = (newEditable) => {
+			setEditable(newEditable);
+		};
+		const handleInitialized = () => {
+			setEditable(editor.isEditable());
+		};
+		editor.on("editableChange", updateEditable);
+		editor.on("initialized", handleInitialized);
+		return () => {
+			editor.off("editableChange", updateEditable);
+			editor.off("initialized", handleInitialized);
+		};
+	}, [editor]);
+	return { editable };
+};
+//#endregion
+export { useEditable };

package/es/editor-kernel/react/useLexicalEditor.d.ts

@@ -0,0 +1,6 @@
+import { LexicalEditor } from "lexical";
+
+//#region src/editor-kernel/react/useLexicalEditor.d.ts
+declare function useLexicalEditor(handleEditor: (lexicalEditor: LexicalEditor) => (() => void) | undefined, deps?: any[]): void;
+//#endregion
+export { useLexicalEditor };

package/es/editor-kernel/react/useLexicalEditor.js

@@ -0,0 +1,23 @@
+import { useLexicalComposerContext } from "./react-context.js";
+import { useEffect } from "react";
+//#region src/editor-kernel/react/useLexicalEditor.ts
+function useLexicalEditor(handleEditor, deps = []) {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		let lexicalEditor = editor.getLexicalEditor();
+		if (lexicalEditor) return handleEditor(lexicalEditor);
+		else {
+			let remove = void 0;
+			const handle = (editor) => {
+				remove = handleEditor(editor);
+			};
+			editor.on("initialized", handle);
+			return () => {
+				editor.off("initialized", handle);
+				remove?.();
+			};
+		}
+	}, deps);
+}
+//#endregion
+export { useLexicalEditor };

package/es/editor-kernel/react/useLexicalNodeSelection.js

@@ -0,0 +1,86 @@
+import { useLexicalComposerContext } from "./react-context.js";
+import { useCallback, useEffect, useState } from "react";
+import { $createNodeSelection, $getNodeByKey, $getSelection, $isNodeSelection, $setSelection } from "lexical";
+//#region src/editor-kernel/react/useLexicalNodeSelection.ts
+/**
+* A helper function to determine if a specific node is selected in a Lexical editor.
+*
+* @param {LexicalEditor} editor - The LexicalEditor instance.
+* @param {NodeKey} key - The key of the node to check.
+* @returns {boolean} Whether the node is selected.
+*/
+function isNodeSelected(editor, key) {
+	if (!editor) return false;
+	return editor.getEditorState().read(() => {
+		const node = $getNodeByKey(key);
+		if (node === null) return false;
+		return node.isSelected();
+	});
+}
+function detectNodeSelection(editor) {
+	if (!editor) return false;
+	return editor.getEditorState().read(() => {
+		return $getSelection()?.getNodes().length === 1;
+	});
+}
+/**
+* A custom hook to manage the selection state of a specific node in a Lexical editor.
+*
+* This hook provides utilities to:
+* - Check if a node is selected.
+* - Update its selection state.
+* - Clear the selection.
+*
+* @param {NodeKey} key - The key of the node to track selection for.
+* @returns {[boolean, (selected: boolean) => void, () => void]} A tuple containing:
+* - `isSelected` (boolean): Whether the node is currently selected.
+* - `setSelected` (function): A function to set the selection state of the node.
+* - `clearSelected` (function): A function to clear the selection of the node.
+*
+*/
+function useLexicalNodeSelection(key) {
+	const [editor] = useLexicalComposerContext();
+	const lexicalEditor = editor.getLexicalEditor();
+	const [isSelected, setIsSelected] = useState(() => isNodeSelected(lexicalEditor, key));
+	const [isNodeSelection, setIsNodeSelection] = useState(() => detectNodeSelection(lexicalEditor));
+	useEffect(() => {
+		let isMounted = true;
+		if (!lexicalEditor) return;
+		const unregister = lexicalEditor.registerUpdateListener(() => {
+			if (isMounted) {
+				setIsSelected(isNodeSelected(lexicalEditor, key));
+				setIsNodeSelection(detectNodeSelection(lexicalEditor));
+			}
+		});
+		return () => {
+			isMounted = false;
+			unregister();
+		};
+	}, [lexicalEditor, key]);
+	return [
+		isSelected,
+		useCallback((selected) => {
+			if (!lexicalEditor) return;
+			lexicalEditor.update(() => {
+				let selection = $getSelection();
+				if (selection?.getNodes().length === 1 && selection?.getNodes().map((v) => v.getKey()).includes(key)) return;
+				if (!$isNodeSelection(selection)) {
+					selection = $createNodeSelection();
+					$setSelection(selection);
+				}
+				if ($isNodeSelection(selection)) if (selected) selection.add(key);
+				else selection.delete(key);
+			});
+		}, [lexicalEditor, key]),
+		useCallback(() => {
+			if (!lexicalEditor) return;
+			lexicalEditor.update(() => {
+				const selection = $getSelection();
+				if ($isNodeSelection(selection)) selection.clear();
+			});
+		}, [lexicalEditor]),
+		isNodeSelection
+	];
+}
+//#endregion
+export { useLexicalNodeSelection };

package/es/editor-kernel/react/useTranslation.js

@@ -0,0 +1,9 @@
+import { useLexicalComposerContext } from "./react-context.js";
+import { useCallback } from "react";
+//#region src/editor-kernel/react/useTranslation.ts
+function useTranslation() {
+	const [editor] = useLexicalComposerContext();
+	return useCallback((key, options) => editor.t(key, options), [editor]);
+}
+//#endregion
+export { useTranslation };

package/es/editor-kernel/utils.d.ts

@@ -0,0 +1,46 @@
+import { IEditorKernel, IServiceID } from "../types/kernel.js";
+import * as _$lexical from "lexical";
+import { EditorConfig, ElementNode, LexicalEditor, LexicalNode, NodeKey } from "lexical";
+
+//#region src/editor-kernel/utils.d.ts
+declare const DOM_ELEMENT_TYPE = 1;
+declare const DOM_TEXT_TYPE = 3;
+declare const DOM_DOCUMENT_TYPE = 9;
+declare const DOM_DOCUMENT_FRAGMENT_TYPE = 11;
+declare function genServiceId<T>(name: string): IServiceID<T>;
+declare const noop: () => void;
+declare function createEmptyEditorState(): _$lexical.EditorState;
+declare function assert(cond?: boolean, message?: string): asserts cond;
+declare function getNodeKeyFromDOMNode(dom: Node, editor: LexicalEditor): NodeKey | undefined;
+declare function $getNodeFromDOMNode(dom: Node, editor: LexicalEditor, editorState?: ReturnType<LexicalEditor['getEditorState']>): LexicalNode | null;
+/**
+ * @param x - The element being tested
+ * @returns Returns true if x is a DOM Node, false otherwise.
+ */
+declare function isDOMNode(x: unknown): x is Node;
+/**
+ * @param x - The element being testing
+ * @returns Returns true if x is a document fragment, false otherwise.
+ */
+declare function isDocumentFragment(x: unknown): x is DocumentFragment;
+declare function getParentElement(node: Node): HTMLElement | null;
+declare function $getNearestNodeFromDOMNode$1(startingDOM: Node, editor: LexicalEditor, editorState?: ReturnType<LexicalEditor['getEditorState']>): LexicalNode | null;
+declare function getKernelFromEditor(editor: LexicalEditor): IEditorKernel;
+declare const EDITOR_THEME_KEY = "__editorId";
+declare function generateEditorId(): string;
+declare function registerEditorKernel(id: string, kernel: IEditorKernel): void;
+declare function unregisterEditorKernel(id: string): void;
+declare function getKernelFromEditorConfig(config: EditorConfig): IEditorKernel | null;
+/**
+ *
+ * @param nodeA
+ * @param nodeB
+ * @returns
+ */
+declare function compareNodeOrder(nodeA: LexicalNode, nodeB: LexicalNode): number;
+declare function $closest(node: LexicalNode | ElementNode | null, test: (node: LexicalNode) => boolean): LexicalNode | null;
+declare function $closestNodeType(node: LexicalNode | ElementNode | null, type: string | string[]): LexicalNode | null;
+declare function moment(): Promise<unknown>;
+declare function reconcileDecorator(activeEditor: LexicalEditor, key: NodeKey, decorator: unknown): void;
+//#endregion
+export { $closest, $closestNodeType, $getNearestNodeFromDOMNode$1 as $getNearestNodeFromDOMNode, $getNodeFromDOMNode, DOM_DOCUMENT_FRAGMENT_TYPE, DOM_DOCUMENT_TYPE, DOM_ELEMENT_TYPE, DOM_TEXT_TYPE, EDITOR_THEME_KEY, assert, compareNodeOrder, createEmptyEditorState, genServiceId, generateEditorId, getKernelFromEditor, getKernelFromEditorConfig, getNodeKeyFromDOMNode, getParentElement, isDOMNode, isDocumentFragment, moment, noop, reconcileDecorator, registerEditorKernel, unregisterEditorKernel };

package/es/editor-kernel/utils.js

@@ -0,0 +1,138 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { $getNodeByKey, createEditor } from "lexical";
+//#region src/editor-kernel/utils.ts
+function genServiceId(name) {
+	return { __serviceId: name };
+}
+function createEmptyEditorState() {
+	return createEditor().getEditorState();
+}
+function assert(cond, message) {
+	if (cond) return;
+	throw new Error(message);
+}
+function getNodeKeyFromDOMNode(dom, editor) {
+	return dom[`__lexicalKey_${editor._key}`];
+}
+function $getNodeFromDOMNode(dom, editor, editorState) {
+	const key = getNodeKeyFromDOMNode(dom, editor);
+	if (key !== void 0) return $getNodeByKey(key, editorState);
+	return null;
+}
+/**
+* @param x - The element being tested
+* @returns Returns true if x is a DOM Node, false otherwise.
+*/
+function isDOMNode(x) {
+	return typeof x === "object" && x !== null && "nodeType" in x && typeof x.nodeType === "number";
+}
+/**
+* @param x - The element being testing
+* @returns Returns true if x is a document fragment, false otherwise.
+*/
+function isDocumentFragment(x) {
+	return isDOMNode(x) && x.nodeType === 11;
+}
+function getParentElement(node) {
+	const parentElement = node.assignedSlot || node.parentElement;
+	return isDocumentFragment(parentElement) ? parentElement.host : parentElement;
+}
+function $getNearestNodeFromDOMNode$1(startingDOM, editor, editorState) {
+	let dom = startingDOM;
+	while (dom !== null) {
+		const node = $getNodeFromDOMNode(dom, editor, editorState);
+		if (node !== null) return node;
+		dom = getParentElement(dom);
+	}
+	return null;
+}
+function getKernelFromEditor(editor) {
+	return editor._createEditorArgs?.__kernel || editor._kernel;
+}
+function generateEditorId() {
+	EditorId += 1;
+	return `editor-${EditorId}`;
+}
+function registerEditorKernel(id, kernel) {
+	EditorMap.set(id, kernel);
+}
+function unregisterEditorKernel(id) {
+	EditorMap.delete(id);
+}
+function getKernelFromEditorConfig(config) {
+	const id = config.theme[EDITOR_THEME_KEY];
+	return EditorMap.get(id) || null;
+}
+/**
+*
+* @param nodeA
+* @param nodeB
+* @returns
+*/
+function compareNodeOrder(nodeA, nodeB) {
+	if (nodeA === nodeB) return 0;
+	const pathA = [];
+	const pathB = [];
+	let currentA = nodeA;
+	let currentB = nodeB;
+	while (currentA) {
+		pathA.unshift(currentA);
+		currentA = currentA.getParent();
+	}
+	while (currentB) {
+		pathB.unshift(currentB);
+		currentB = currentB.getParent();
+	}
+	const minLength = Math.min(pathA.length, pathB.length);
+	for (let i = 0; i < minLength; i++) if (pathA[i] !== pathB[i]) {
+		const siblings = pathA[i].getParent()?.getChildren() || [];
+		return siblings.indexOf(pathA[i]) - siblings.indexOf(pathB[i]);
+	}
+	if (pathA.length !== pathB.length) return pathA.length - pathB.length;
+	return 0;
+}
+function $closest(node, test) {
+	let current = node;
+	while (current) {
+		if (test(current)) return current;
+		current = current.getParent();
+	}
+	return null;
+}
+function $closestNodeType(node, type) {
+	return $closest(node, (n) => Array.isArray(type) ? type.includes(n.getType()) : n.getType() === type);
+}
+function moment() {
+	return new Promise((resolve) => {
+		queueMicrotask(() => resolve(true));
+	});
+}
+function cloneDecorators(editor) {
+	const currentDecorators = editor._decorators;
+	const pendingDecorators = Object.assign({}, currentDecorators);
+	editor._pendingDecorators = pendingDecorators;
+	return pendingDecorators;
+}
+function reconcileDecorator(activeEditor, key, decorator) {
+	let pendingDecorators = activeEditor._pendingDecorators;
+	const currentDecorators = activeEditor._decorators;
+	if (pendingDecorators === null) {
+		if (currentDecorators[key] === decorator) return;
+		pendingDecorators = cloneDecorators(activeEditor);
+	}
+	pendingDecorators[key] = decorator;
+}
+var DOM_ELEMENT_TYPE, DOM_TEXT_TYPE, DOM_DOCUMENT_TYPE, DOM_DOCUMENT_FRAGMENT_TYPE, noop, EditorId, EDITOR_THEME_KEY, EditorMap;
+var init_utils = __esmMin((() => {
+	DOM_ELEMENT_TYPE = 1;
+	DOM_TEXT_TYPE = 3;
+	DOM_DOCUMENT_TYPE = 9;
+	DOM_DOCUMENT_FRAGMENT_TYPE = 11;
+	noop = () => {};
+	EditorId = 0;
+	EDITOR_THEME_KEY = "__editorId";
+	EditorMap = /* @__PURE__ */ new Map();
+}));
+//#endregion
+init_utils();
+export { $closest, $closestNodeType, $getNearestNodeFromDOMNode$1 as $getNearestNodeFromDOMNode, $getNodeFromDOMNode, DOM_DOCUMENT_FRAGMENT_TYPE, DOM_DOCUMENT_TYPE, DOM_ELEMENT_TYPE, DOM_TEXT_TYPE, EDITOR_THEME_KEY, assert, compareNodeOrder, createEmptyEditorState, genServiceId, generateEditorId, getKernelFromEditor, getKernelFromEditorConfig, getNodeKeyFromDOMNode, getParentElement, init_utils, isDOMNode, isDocumentFragment, moment, noop, reconcileDecorator, registerEditorKernel, unregisterEditorKernel };