@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/hr/command/index.d.ts

@@ -0,0 +1,7 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/hr/command/index.d.ts
+declare const INSERT_HORIZONTAL_RULE_COMMAND: _$lexical.LexicalCommand<unknown>;
+//#endregion
+export { INSERT_HORIZONTAL_RULE_COMMAND };

package/es/plugins/hr/command/index.js

@@ -0,0 +1,14 @@
+import { $createHorizontalRuleNode } from "../node/HorizontalRuleNode.js";
+import { $insertNodes, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+//#region src/plugins/hr/command/index.ts
+const INSERT_HORIZONTAL_RULE_COMMAND = createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
+function registerHorizontalRuleCommand(editor) {
+	return editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, () => {
+		editor.update(() => {
+			$insertNodes([$createHorizontalRuleNode()]);
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
+}
+//#endregion
+export { INSERT_HORIZONTAL_RULE_COMMAND, registerHorizontalRuleCommand };

package/es/plugins/hr/index.d.ts

@@ -0,0 +1,4 @@
+import { INSERT_HORIZONTAL_RULE_COMMAND } from "./command/index.js";
+import { HRPlugin, HRPluginOptions } from "./plugin/index.js";
+import { ReactHRPluginProps } from "./react/type.js";
+import { ReactHRPlugin } from "./react/ReactHRPlugin.js";

package/es/plugins/hr/node/HorizontalRuleNode.d.ts

@@ -0,0 +1,18 @@
+import { DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalNode, SerializedLexicalNode } from "lexical";
+
+//#region src/plugins/hr/node/HorizontalRuleNode.d.ts
+type SerializedHorizontalRuleNode = SerializedLexicalNode;
+declare class HorizontalRuleNode extends DecoratorNode<any> {
+  static getType(): string;
+  static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+  static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+  static importDOM(): DOMConversionMap | null;
+  exportDOM(): DOMExportOutput;
+  createDOM(config: EditorConfig): HTMLElement;
+  getTextContent(): string;
+  isInline(): false;
+  updateDOM(): boolean;
+  decorate(editor: LexicalEditor): any;
+}
+//#endregion
+export { HorizontalRuleNode };

package/es/plugins/hr/node/HorizontalRuleNode.js

@@ -0,0 +1,59 @@
+import { getKernelFromEditor, init_utils } from "../../../editor-kernel/utils.js";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import { addClassNamesToElement } from "@lexical/utils";
+//#region src/plugins/hr/node/HorizontalRuleNode.ts
+init_utils();
+var HorizontalRuleNode = class HorizontalRuleNode extends DecoratorNode {
+	static getType() {
+		return "horizontalrule";
+	}
+	static clone(node) {
+		return new HorizontalRuleNode(node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createHorizontalRuleNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { hr: () => ({
+			conversion: $convertHorizontalRuleElement,
+			priority: 0
+		}) };
+	}
+	exportDOM() {
+		return { element: document.createElement("hr") };
+	}
+	createDOM(config) {
+		const element = document.createElement("div");
+		addClassNamesToElement(element, config.theme.hr);
+		return element;
+	}
+	getTextContent() {
+		return "\n";
+	}
+	isInline() {
+		return false;
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator("horizontalrule");
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+function $createHorizontalRuleNode() {
+	return $applyNodeReplacement(new HorizontalRuleNode());
+}
+function $convertHorizontalRuleElement() {
+	return { node: $createHorizontalRuleNode() };
+}
+function $isHorizontalRuleNode(node) {
+	return node.getType() === HorizontalRuleNode.getType();
+}
+//#endregion
+export { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode };

package/es/plugins/hr/plugin/index.d.ts

@@ -0,0 +1,12 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+import { HorizontalRuleNode } from "../node/HorizontalRuleNode.js";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/hr/plugin/index.d.ts
+interface HRPluginOptions {
+  decorator: (node: HorizontalRuleNode, editor: LexicalEditor) => any;
+  theme?: string;
+}
+declare const HRPlugin: IEditorPluginConstructor<HRPluginOptions>;
+//#endregion
+export { HRPlugin, HRPluginOptions };

package/es/plugins/hr/plugin/index.js

@@ -0,0 +1,60 @@
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { ILitexmlService } from "../../litexml/service/litexml-service.js";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from "../node/HorizontalRuleNode.js";
+import { registerHorizontalRuleCommand } from "../command/index.js";
+//#region src/plugins/hr/plugin/index.ts
+init_helper();
+init_plugin();
+const HRPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "HRPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		kernel.registerNodes([HorizontalRuleNode]);
+		kernel.registerThemes({ hr: config?.theme || "" });
+		this.registerDecorator(kernel, "horizontalrule", (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
+	}
+	onInit(editor) {
+		this.register(registerHorizontalRuleCommand(editor));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(HorizontalRuleNode.getType(), (node, ctx) => {
+			if ($isHorizontalRuleNode(node)) return ctx.createXmlNode("hr", {});
+			return false;
+		});
+		litexmlService.registerXMLReader("hr", () => {
+			return INodeHelper.createElementNode(HorizontalRuleNode.getType(), {});
+		});
+	}
+	registerMarkdown() {
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
+			regExp: /^(---|\*\*\*|___)$/,
+			replace: (parentNode, _1, _2, isImport) => {
+				const line = $createHorizontalRuleNode();
+				if (isImport || parentNode.getNextSibling()) parentNode.replace(line);
+				else parentNode.insertBefore(line);
+				line.selectNext();
+			},
+			trigger: "enter",
+			type: "element"
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(HorizontalRuleNode.getType(), (ctx, node) => {
+			if ($isHorizontalRuleNode(node)) ctx.appendLine("---\n\n");
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("thematicBreak", () => {
+			return INodeHelper.createElementNode("horizontalrule", {});
+		});
+	}
+};
+//#endregion
+export { HRPlugin };

package/es/plugins/hr/react/ReactHRPlugin.d.ts

@@ -0,0 +1,7 @@
+import { ReactHRPluginProps } from "./type.js";
+import { FC } from "react";
+
+//#region src/plugins/hr/react/ReactHRPlugin.d.ts
+declare const ReactHRPlugin: FC<ReactHRPluginProps>;
+//#endregion
+export { ReactHRPlugin };

package/es/plugins/hr/react/ReactHRPlugin.js

@@ -0,0 +1,28 @@
+"use client";
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context.js";
+import { MarkdownPlugin } from "../../markdown/plugin/index.js";
+import { HRPlugin } from "../plugin/index.js";
+import HRNode from "./components/HRNode.js";
+import { useLayoutEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/plugins/hr/react/ReactHRPlugin.tsx
+const ReactHRPlugin = ({ className }) => {
+	const [editor] = useLexicalComposerContext();
+	useLayoutEffect(() => {
+		editor.registerPlugin(MarkdownPlugin);
+		editor.registerPlugin(HRPlugin, {
+			decorator(node, editor) {
+				return /* @__PURE__ */ jsx(HRNode, {
+					className,
+					editor,
+					node
+				});
+			},
+			theme: className
+		});
+	}, []);
+	return null;
+};
+ReactHRPlugin.displayName = "ReactHRPlugin";
+//#endregion
+export { ReactHRPlugin as default };

package/es/plugins/hr/react/components/HRNode.js

@@ -0,0 +1,36 @@
+"use client";
+import { useLexicalNodeSelection } from "../../../../editor-kernel/react/useLexicalNodeSelection.js";
+import { styles } from "../style.js";
+import { useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+import { cx } from "antd-style";
+import { CLICK_COMMAND, COMMAND_PRIORITY_LOW } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+//#region src/plugins/hr/react/components/HRNode.tsx
+const HRNode = ({ node, className, editor }) => {
+	const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(node.getKey());
+	useEffect(() => {
+		return mergeRegister(editor.registerCommand(CLICK_COMMAND, (event) => {
+			const hrElem = editor.getElementByKey(node.getKey());
+			if (hrElem?.contains(event.target) || event.target === hrElem) {
+				if (!event.shiftKey) clearSelection();
+				setSelected(!isSelected);
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_LOW));
+	}, [
+		clearSelection,
+		editor,
+		isSelected,
+		node,
+		setSelected
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		className: cx(styles, isSelected && "selected", className),
+		children: /* @__PURE__ */ jsx("hr", {})
+	});
+};
+HRNode.displayName = "HRNode";
+//#endregion
+export { HRNode as default };

package/es/plugins/hr/react/index.d.ts

@@ -0,0 +1,2 @@
+import { ReactHRPluginProps } from "./type.js";
+import { ReactHRPlugin } from "./ReactHRPlugin.js";

package/es/plugins/hr/react/style.js

@@ -0,0 +1,32 @@
+import { createStaticStyles } from "antd-style";
+//#region src/plugins/hr/react/style.ts
+const styles = createStaticStyles(({ css, cssVar }) => css`
+    cursor: pointer;
+
+    display: flex;
+    align-items: center;
+
+    width: 100%;
+    height: calc(var(--lobe-markdown-margin-multiple) * 1em);
+    margin-block: calc(var(--lobe-markdown-margin-multiple) * 1em);
+
+    hr {
+      width: 100%;
+      border-color: ${cssVar.colorBorder};
+      border-style: dashed;
+      border-width: 1px;
+      border-block-start: none;
+      border-inline-start: none;
+      border-inline-end: none;
+    }
+
+    &.selected {
+      background: ${cssVar.yellow};
+
+      hr {
+        border-color: #000;
+      }
+    }
+  `);
+//#endregion
+export { styles };

package/es/plugins/hr/react/type.d.ts

@@ -0,0 +1,6 @@
+//#region src/plugins/hr/react/type.d.ts
+interface ReactHRPluginProps {
+  className?: string;
+}
+//#endregion
+export { ReactHRPluginProps };

package/es/plugins/image/command/index.d.ts

@@ -0,0 +1,12 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/image/command/index.d.ts
+declare const INSERT_IMAGE_COMMAND: _$lexical.LexicalCommand<{
+  block?: boolean;
+  file: File;
+  maxWidth?: number;
+  range?: Range | null;
+}>;
+//#endregion
+export { INSERT_IMAGE_COMMAND };

package/es/plugins/image/command/index.js

@@ -0,0 +1,53 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { $createBlockImageNode } from "../node/block-image-node.js";
+import { $createImageNode } from "../node/image-node.js";
+import { $createParagraphNode, $createRangeSelection, $insertNodes, $isRootOrShadowRoot, $setSelection, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { $wrapNodeInElement } from "@lexical/utils";
+//#region src/plugins/image/command/index.ts
+init_debug();
+const logger = createDebugLogger("plugin", "image");
+const INSERT_IMAGE_COMMAND = createCommand("INSERT_IMAGE_COMMAND");
+function isImageFile(file) {
+	return file.type.startsWith("image/");
+}
+function registerImageCommand(editor, handleUpload, defaultBlockImage = false) {
+	return editor.registerCommand(INSERT_IMAGE_COMMAND, (payload) => {
+		const { file, range, block, maxWidth } = payload;
+		const isBlock = block ?? defaultBlockImage;
+		if (!isImageFile(file)) return false;
+		const placeholderURL = URL.createObjectURL(file);
+		editor.update(() => {
+			if (range) {
+				const rangeSelection = $createRangeSelection();
+				if (range !== null && range !== void 0) rangeSelection.applyDOMRange(range);
+				$setSelection(rangeSelection);
+			}
+			const imageNode = isBlock ? $createBlockImageNode({
+				altText: file.name,
+				maxWidth: maxWidth || 800,
+				src: placeholderURL,
+				status: "loading"
+			}) : $createImageNode({
+				altText: file.name,
+				maxWidth: maxWidth || 800,
+				src: placeholderURL,
+				status: "loading"
+			});
+			$insertNodes([imageNode]);
+			if (!isBlock && $isRootOrShadowRoot(imageNode.getParentOrThrow())) $wrapNodeInElement(imageNode, $createParagraphNode).selectEnd();
+			handleUpload(file).then((res) => {
+				editor.update(() => {
+					imageNode.setUploaded(res.url);
+				});
+			}).catch((error) => {
+				logger.error("❌ Image upload failed:", error);
+				editor.update(() => {
+					imageNode.setError("Image upload failed : " + error.message);
+				});
+			});
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
+}
+//#endregion
+export { INSERT_IMAGE_COMMAND, registerImageCommand };

package/es/plugins/image/index.d.ts

@@ -0,0 +1,4 @@
+import { INSERT_IMAGE_COMMAND } from "./command/index.js";
+import { ImagePlugin, ImagePluginOptions } from "./plugin/index.js";
+import { ReactImagePluginProps } from "./react/type.js";
+import { ReactImagePlugin } from "./react/ReactImagePlugin.js";

package/es/plugins/image/node/basie-image-node.d.ts

@@ -0,0 +1,33 @@
+import { DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalUpdateJSON, NodeKey, SerializedLexicalNode, Spread } from "lexical";
+
+//#region src/plugins/image/node/basie-image-node.d.ts
+type SerializedImageNode = Spread<{
+  altText: string;
+  height?: number;
+  maxWidth: number;
+  src: string;
+  status?: 'uploaded' | 'loading' | 'error';
+  width?: number;
+}, SerializedLexicalNode>;
+declare class BaseImageNode extends DecoratorNode<any> {
+  __src: string;
+  __altText: string;
+  __width: 'inherit' | number;
+  __height: 'inherit' | number;
+  __maxWidth: number;
+  static clone(node: BaseImageNode): BaseImageNode;
+  static importJSON(serializedNode: SerializedImageNode): BaseImageNode;
+  static getType(): string;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedImageNode>): this;
+  exportDOM(): DOMExportOutput;
+  constructor(src: string, altText: string, maxWidth: number, width?: 'inherit' | number, height?: 'inherit' | number, key?: NodeKey);
+  exportJSON(): SerializedImageNode;
+  setWidthAndHeight(width: 'inherit' | number, height: 'inherit' | number): void;
+  isInline(): boolean;
+  createDOM(config: EditorConfig): HTMLElement;
+  updateDOM(): false;
+  getSrc(): string;
+  getAltText(): string;
+}
+//#endregion
+export { BaseImageNode, SerializedImageNode };

package/es/plugins/image/node/basie-image-node.js

@@ -0,0 +1,68 @@
+import { DecoratorNode } from "lexical";
+//#region src/plugins/image/node/basie-image-node.ts
+var BaseImageNode = class BaseImageNode extends DecoratorNode {
+	static clone(node) {
+		return new BaseImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__key);
+	}
+	static importJSON(serializedNode) {
+		const { altText, height, width, maxWidth, src } = serializedNode;
+		return new BaseImageNode(src, altText, maxWidth, width, height);
+	}
+	static getType() {
+		return "image";
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode);
+	}
+	exportDOM() {
+		const element = document.createElement("img");
+		element.setAttribute("src", this.__src);
+		element.setAttribute("alt", this.__altText);
+		element.setAttribute("width", this.__width.toString());
+		element.setAttribute("height", this.__height.toString());
+		return { element };
+	}
+	constructor(src, altText, maxWidth, width, height, key) {
+		super(key);
+		this.__src = src;
+		this.__altText = altText;
+		this.__maxWidth = maxWidth;
+		this.__width = width || "inherit";
+		this.__height = height || "inherit";
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			altText: this.getAltText(),
+			height: this.__height === "inherit" ? 0 : this.__height,
+			maxWidth: this.__maxWidth,
+			src: this.getSrc(),
+			width: this.__width === "inherit" ? 0 : this.__width
+		};
+	}
+	setWidthAndHeight(width, height) {
+		const writable = this.getWritable();
+		writable.__width = width;
+		writable.__height = height;
+	}
+	isInline() {
+		return true;
+	}
+	createDOM(config) {
+		const span = document.createElement("span");
+		const className = config.theme.image;
+		if (className !== void 0) span.className = className;
+		return span;
+	}
+	updateDOM() {
+		return false;
+	}
+	getSrc() {
+		return this.__src;
+	}
+	getAltText() {
+		return this.__altText;
+	}
+};
+//#endregion
+export { BaseImageNode };

package/es/plugins/image/node/block-image-node.d.ts

@@ -0,0 +1,43 @@
+import { BaseImageNode, SerializedImageNode } from "./basie-image-node.js";
+import { DOMConversionMap, EditorConfig, LexicalNode, NodeKey } from "lexical";
+
+//#region src/plugins/image/node/block-image-node.d.ts
+declare class BlockImageNode extends BaseImageNode {
+  private static _decorate;
+  static setDecorate(decorate: (node: BlockImageNode) => any): void;
+  static getType(): string;
+  private __loading;
+  private __status;
+  private __message;
+  private __extra;
+  get isLoading(): boolean;
+  get status(): 'uploaded' | 'loading' | 'error';
+  get message(): string | null;
+  get src(): string;
+  get altText(): string;
+  get maxWidth(): number;
+  get width(): number | string;
+  get height(): number | string;
+  constructor(opt: {
+    altText: string;
+    height?: 'inherit' | number;
+    key?: NodeKey;
+    maxWidth: number;
+    src: string;
+    status?: 'uploaded' | 'loading' | 'error';
+    width?: 'inherit' | number;
+  });
+  isInline(): boolean;
+  setMaxWidth(maxWidth: number): void;
+  setWidth(width: number): void;
+  setStatus(status: 'uploaded' | 'loading' | 'error'): void;
+  setUploaded(url: string): void;
+  setError(message: string): void;
+  static clone(node: BlockImageNode): BlockImageNode;
+  static importJSON(serializedNode: SerializedImageNode): BlockImageNode;
+  static importDOM(): DOMConversionMap | null;
+  decorate(): any;
+  createDOM(config: EditorConfig): HTMLElement;
+}
+//#endregion
+export { BlockImageNode };

package/es/plugins/image/node/block-image-node.js

@@ -0,0 +1,137 @@
+import { BaseImageNode } from "./basie-image-node.js";
+import { $applyNodeReplacement } from "lexical";
+//#region src/plugins/image/node/block-image-node.tsx
+var BlockImageNode = class BlockImageNode extends BaseImageNode {
+	static {
+		this._decorate = () => null;
+	}
+	static setDecorate(decorate) {
+		BlockImageNode._decorate = decorate;
+	}
+	static getType() {
+		return "block-image";
+	}
+	get isLoading() {
+		return this.__loading;
+	}
+	get status() {
+		return this.__status;
+	}
+	get message() {
+		return this.__message;
+	}
+	get src() {
+		return this.__src;
+	}
+	get altText() {
+		return this.__altText;
+	}
+	get maxWidth() {
+		return this.__maxWidth;
+	}
+	get width() {
+		return this.__width;
+	}
+	get height() {
+		return this.__height;
+	}
+	constructor(opt) {
+		super(opt.src, opt.altText, opt.maxWidth, opt.width, opt.height, opt.key);
+		this.__loading = true;
+		this.__status = "uploaded";
+		this.__message = null;
+		this.__extra = null;
+		this.__status = opt.status ?? "uploaded";
+	}
+	isInline() {
+		return false;
+	}
+	setMaxWidth(maxWidth) {
+		const writable = this.getWritable();
+		writable.__maxWidth = maxWidth;
+	}
+	setWidth(width) {
+		const writable = this.getWritable();
+		writable.__width = width;
+	}
+	setStatus(status) {
+		const writable = this.getWritable();
+		writable.__status = status;
+	}
+	setUploaded(url) {
+		const writable = this.getWritable();
+		writable.__loading = false;
+		writable.__src = url;
+		writable.__status = "uploaded";
+	}
+	setError(message) {
+		const writable = this.getWritable();
+		writable.__loading = false;
+		writable.__status = "error";
+		writable.__message = message;
+	}
+	static clone(node) {
+		return new BlockImageNode({
+			altText: node.__altText,
+			height: node.__height,
+			key: node.__key,
+			maxWidth: node.__maxWidth,
+			src: node.__src,
+			status: node.__status,
+			width: node.__width
+		});
+	}
+	static importJSON(serializedNode) {
+		const { altText, height, width, maxWidth, src, status } = serializedNode;
+		return $createBlockImageNode({
+			altText,
+			height,
+			maxWidth,
+			src,
+			status,
+			width
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { img: () => ({
+			conversion: $convertImageElement,
+			priority: 0
+		}) };
+	}
+	decorate() {
+		return BlockImageNode._decorate(this);
+	}
+	createDOM(config) {
+		const span = document.createElement("div");
+		const className = config.theme.blockImage;
+		if (className !== void 0) span.className = className;
+		return span;
+	}
+};
+function $createBlockImageNode({ altText, height, maxWidth = 4200, src, width, key, status }) {
+	return $applyNodeReplacement(new BlockImageNode({
+		altText,
+		height,
+		key,
+		maxWidth,
+		src,
+		status,
+		width
+	}));
+}
+function $convertImageElement(domNode) {
+	const img = domNode;
+	if (img.src.startsWith("file:///")) return null;
+	const { alt: altText, src, width, height } = img;
+	return { node: $createBlockImageNode({
+		altText,
+		height,
+		src,
+		width
+	}) };
+}
+function $isBlockImageNode(node) {
+	return node.getType() === BlockImageNode.getType();
+}
+//#endregion
+export { $createBlockImageNode, $isBlockImageNode, BlockImageNode };