@lobehub/editor 4.15.1 → 4.16.0

package/es/plugins/litexml/node/DiffNode.d.ts

@@ -0,0 +1,29 @@
+import { CardLikeElementNode } from "../../common/node/cursor.js";
+import { DOMExportOutput, EditorConfig, ElementDOMSlot, LexicalEditor, LexicalUpdateJSON, SerializedElementNode, Spread } from "lexical";
+
+//#region src/plugins/litexml/node/DiffNode.d.ts
+type DiffType = 'add' | 'remove' | 'modify' | 'unchanged' | 'listItemModify' | 'listItemRemove' | 'listItemAdd';
+type SerializedDiffNode = Spread<{
+  diffType: DiffType;
+}, SerializedElementNode>;
+/** DiffNode - contains two block children: original and modified */
+declare class DiffNode extends CardLikeElementNode {
+  static getType(): string;
+  static clone(node: DiffNode): DiffNode;
+  static importJSON(serializedNode: SerializedDiffNode): DiffNode;
+  static importDOM(): null;
+  private __diffType;
+  constructor(type: DiffType, key?: string);
+  get diffType(): DiffType;
+  setDiffType(type: DiffType): this;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedDiffNode>): this;
+  exportJSON(): SerializedDiffNode;
+  exportDOM(editor: LexicalEditor): DOMExportOutput;
+  createDOM(config: EditorConfig, editor: LexicalEditor): HTMLDivElement;
+  updateDOM(_prevNode: unknown, _dom: HTMLElement, _config: EditorConfig): boolean;
+  getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLElement>;
+  isInline(): boolean;
+  isCardLike(): boolean;
+}
+//#endregion
+export { DiffNode };

package/es/plugins/litexml/node/DiffNode.js

@@ -0,0 +1,95 @@
+import { getKernelFromEditor, getKernelFromEditorConfig, init_utils, reconcileDecorator } from "../../../editor-kernel/utils.js";
+import { CardLikeElementNode } from "../../common/node/cursor.js";
+import { $applyNodeReplacement } from "lexical";
+//#region src/plugins/litexml/node/DiffNode.ts
+init_utils();
+/** DiffNode - contains two block children: original and modified */
+var DiffNode = class DiffNode extends CardLikeElementNode {
+	static getType() {
+		return "diff";
+	}
+	static clone(node) {
+		return new DiffNode(node.__diffType, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createDiffNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return null;
+	}
+	constructor(type, key) {
+		super(key);
+		this.__diffType = "unchanged";
+		this.__diffType = type;
+	}
+	get diffType() {
+		return this.__diffType;
+	}
+	setDiffType(type) {
+		this.getWritable().__diffType = type;
+		return this;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setDiffType(serializedNode.diffType);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			diffType: this.__diffType,
+			type: "diff"
+		};
+	}
+	exportDOM(editor) {
+		return super.exportDOM(editor);
+	}
+	createDOM(config, editor) {
+		const el = document.createElement("div");
+		el.contentEditable = "false";
+		el.dataset.lexicalKey = this.getKey();
+		el.dataset.diffType = this.__diffType;
+		el.classList.add("ne-diff");
+		if (config.theme.diffNode) el.classList.add(config.theme.diffNode);
+		const toolbar = document.createElement("div");
+		toolbar.className = "toolbar";
+		toolbar.dataset.lexicalDecorator = "true";
+		el.append(toolbar);
+		const content = document.createElement("div");
+		content.className = "content";
+		el.append(content);
+		const decorator = getKernelFromEditor(editor)?.getDecorator("diff") || null;
+		if (decorator) if (typeof decorator === "function") reconcileDecorator(editor, this.getKey(), decorator(this, editor));
+		else reconcileDecorator(editor, this.getKey(), {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		});
+		return el;
+	}
+	updateDOM(_prevNode, _dom, _config) {
+		if (_dom.dataset.diffType !== this.__diffType) _dom.dataset.diffType = this.__diffType;
+		const kernel = getKernelFromEditorConfig(_config);
+		const editor = kernel?.getLexicalEditor();
+		if (editor) {
+			const decorator = kernel?.getDecorator("diff") || null;
+			if (decorator) if (typeof decorator === "function") reconcileDecorator(editor, this.getKey(), decorator(this, editor));
+			else reconcileDecorator(editor, this.getKey(), {
+				queryDOM: decorator.queryDOM,
+				render: decorator.render(this, editor)
+			});
+		}
+		return false;
+	}
+	getDOMSlot(element) {
+		return super.getDOMSlot(element).withElement(element.querySelector(".content"));
+	}
+	isInline() {
+		return false;
+	}
+	isCardLike() {
+		return true;
+	}
+};
+function $createDiffNode(diffType = "unchanged") {
+	return $applyNodeReplacement(new DiffNode(diffType));
+}
+//#endregion
+export { $createDiffNode, DiffNode };

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

@@ -0,0 +1,24 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+import { DiffNode } from "../node/DiffNode.js";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/litexml/plugin/index.d.ts
+/**
+ * LitexmlPluginOptions - Configuration options for the Litexml plugin
+ */
+interface LitexmlPluginOptions {
+  decorator: (node: DiffNode, editor: LexicalEditor) => any;
+  /**
+   * Enable or disable the litexml data source
+   * @default true
+   */
+  enabled?: boolean;
+  theme?: string;
+}
+/**
+ * LitexmlPlugin - A plugin that provides XML-based data source support
+ * Allows converting between Lexical editor state and XML format
+ */
+declare const LitexmlPlugin: IEditorPluginConstructor<LitexmlPluginOptions>;
+//#endregion
+export { LitexmlPlugin, LitexmlPluginOptions };

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

@@ -0,0 +1,106 @@
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { DiffNode } from "../node/DiffNode.js";
+import { registerLiteXMLCommand } from "../command/index.js";
+import { registerLiteXMLDiffCommand } from "../command/diffCommand.js";
+import { ILitexmlService, LitexmlService } from "../service/litexml-service.js";
+import LitexmlDataSource from "../data-source/litexml-data-source.js";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { $nodesOfType, HISTORIC_TAG } from "lexical";
+//#region src/plugins/litexml/plugin/index.ts
+init_plugin();
+/**
+* LitexmlPlugin - A plugin that provides XML-based data source support
+* Allows converting between Lexical editor state and XML format
+*/
+const LitexmlPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "LitexmlPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		kernel.registerThemes({ diffNode: config?.theme || "editor_diffNode" });
+		const litexmlService = new LitexmlService();
+		this.service = litexmlService;
+		kernel.registerService(ILitexmlService, litexmlService);
+		this.datasource = new LitexmlDataSource("litexml", (serviceId) => {
+			return kernel.requireService(serviceId);
+		}, litexmlService);
+		kernel.registerNodes([DiffNode]);
+		kernel.registerDecorator(DiffNode.getType(), {
+			queryDOM: (el) => el.querySelector(".toolbar"),
+			render: (node, editor) => {
+				return config?.decorator ? config.decorator(node, editor) : null;
+			}
+		});
+		if (config?.enabled !== false) kernel.registerDataSource(this.datasource);
+	}
+	onInit(editor) {
+		this.register(registerLiteXMLCommand(editor, this.datasource));
+		this.register(registerLiteXMLDiffCommand(editor));
+		this.register(editor.registerNodeTransform(DiffNode, (node) => {
+			if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
+		}));
+		this.register(editor.registerUpdateListener(({ editorState, prevEditorState, tags }) => {
+			if (editorState === prevEditorState) return;
+			if (tags.has(HISTORIC_TAG)) return;
+			let shouldNormalize = false;
+			editorState.read(() => {
+				shouldNormalize = $nodesOfType(DiffNode).some((node) => node.diffType === "modify" && node.getChildrenSize() === 1);
+			});
+			if (!shouldNormalize) return;
+			editor.update(() => {
+				const diffNodes = $nodesOfType(DiffNode);
+				for (const node of diffNodes) if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
+			});
+		}));
+		this.registerLiteXml();
+		this.registerMarkdown();
+	}
+	registerLiteXml() {
+		this.service.registerXMLWriter(DiffNode.getType(), (node, ctx, indent, nodeToXML) => {
+			const diffNode = node;
+			const lines = [];
+			switch (diffNode.diffType) {
+				case "modify":
+					nodeToXML(diffNode.getChildAtIndex(1), lines, indent);
+					break;
+				case "add":
+					nodeToXML(diffNode.getChildAtIndex(0), lines, indent);
+					break;
+				case "remove": break;
+				case "listItemModify":
+					diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
+						nodeToXML(child, lines, indent);
+					});
+					break;
+				default: break;
+			}
+			return { lines };
+		});
+	}
+	registerMarkdown() {
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(DiffNode.getType(), (ctx, node) => {
+			const diffNode = node;
+			switch (diffNode.diffType) {
+				case "modify":
+					ctx.processChild(ctx, diffNode.getChildAtIndex(1));
+					break;
+				case "add":
+					ctx.processChild(ctx, diffNode.getChildAtIndex(0));
+					break;
+				case "remove": break;
+				case "listItemModify":
+					diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
+						ctx.processChild(ctx, child);
+					});
+					break;
+				default: break;
+			}
+			return true;
+		});
+	}
+};
+//#endregion
+export { LitexmlPlugin };

package/es/plugins/litexml/react/DiffNodeToolbar/index.js

@@ -0,0 +1,60 @@
+import LexicalPortalContainer from "../../../../editor-kernel/react/PortalContainer.js";
+import { LITEXML_DIFFNODE_COMMAND } from "../../command/diffCommand.js";
+import { useTranslation } from "../../../../editor-kernel/react/useTranslation.js";
+import { styles } from "./style.js";
+import { ActionIcon, Block } from "@lobehub/ui";
+import { Check, X } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useThemeMode } from "antd-style";
+//#region src/plugins/litexml/react/DiffNodeToolbar/index.tsx
+const ReactDiffNodeToolbar = ({ editor, node }) => {
+	const t = useTranslation();
+	const { isDarkMode } = useThemeMode();
+	return /* @__PURE__ */ jsx(LexicalPortalContainer, {
+		editor,
+		node,
+		children: /* @__PURE__ */ jsxs(Block, {
+			className: isDarkMode ? styles.toolbarDark : styles.toolbarLight,
+			gap: 2,
+			horizontal: true,
+			padding: 2,
+			shadow: true,
+			variant: "outlined",
+			children: [/* @__PURE__ */ jsx(ActionIcon, {
+				"aria-label": "Reject change",
+				className: styles.reject,
+				danger: true,
+				icon: X,
+				onClick: () => {
+					editor.dispatchCommand(LITEXML_DIFFNODE_COMMAND, {
+						action: 0,
+						nodeKey: node.getKey()
+					});
+				},
+				size: {
+					blockSize: 28,
+					size: 16
+				},
+				title: t("modifier.reject")
+			}), /* @__PURE__ */ jsx(ActionIcon, {
+				"aria-label": "Accept change",
+				className: styles.accept,
+				icon: Check,
+				onClick: () => {
+					editor.dispatchCommand(LITEXML_DIFFNODE_COMMAND, {
+						action: 1,
+						nodeKey: node.getKey()
+					});
+				},
+				size: {
+					blockSize: 28,
+					size: 16
+				},
+				title: t("modifier.accept")
+			})]
+		})
+	});
+};
+ReactDiffNodeToolbar.displayName = "ReactDiffNodeToolbar";
+//#endregion
+export { ReactDiffNodeToolbar as default };

package/es/plugins/litexml/react/DiffNodeToolbar/style.js

@@ -0,0 +1,24 @@
+import { createStaticStyles } from "antd-style";
+//#region src/plugins/litexml/react/DiffNodeToolbar/style.ts
+const styles = createStaticStyles(({ css, cssVar }) => ({
+	accept: css`
+    color: ${cssVar.colorSuccess};
+  `,
+	reject: css``,
+	toolbarDark: css`
+    border-color: ${cssVar.colorFillSecondary};
+    background: ${cssVar.colorBgElevated};
+    box-shadow:
+      0 14px 28px -6px color-mix(in srgb, #000 18.75%, transparent),
+      0 2px 4px -1px color-mix(in srgb, #000 12.19%, transparent);
+  `,
+	toolbarLight: css`
+    border-color: ${cssVar.colorFillSecondary};
+    background: ${cssVar.colorBgElevated};
+    box-shadow:
+      0 14px 28px -6px color-mix(in srgb, #000 10.2%, transparent),
+      0 2px 4px -1px color-mix(in srgb, #000 5.88%, transparent);
+  `
+}));
+//#endregion
+export { styles };

package/es/plugins/litexml/react/hooks/useHasDiffNode.d.ts

@@ -0,0 +1,7 @@
+import { IEditor } from "../../../../types/kernel.js";
+//#region src/plugins/litexml/react/hooks/useHasDiffNode.d.ts
+declare function useHasDiffNode(editor?: IEditor): {
+  hasDiff: boolean;
+};
+//#endregion
+export { useHasDiffNode };

package/es/plugins/litexml/react/hooks/useHasDiffNode.js

@@ -0,0 +1,35 @@
+import { useEffect, useState } from "react";
+//#region src/plugins/litexml/react/hooks/useHasDiffNode.ts
+function hasDiffNode(editor) {
+	if (!editor) return false;
+	const values = editor.getLexicalEditor()?.getEditorState()._nodeMap.values();
+	if (!values) return false;
+	for (const node of values) if (node.getType() === "diff") return true;
+	return false;
+}
+function useHasDiffNode(editor) {
+	const [hasInit, setHasInit] = useState(!!editor?.getLexicalEditor());
+	const [hasDiff, setHasDiff] = useState(hasDiffNode(editor));
+	useEffect(() => {
+		if (!editor) return;
+		const handle = () => {
+			setHasInit(true);
+		};
+		editor.on("initialized", handle);
+		return () => {
+			editor.off("initialized", handle);
+		};
+	}, [editor]);
+	useEffect(() => {
+		if (!editor || !hasInit) return;
+		const unregister = editor.getLexicalEditor()?.registerUpdateListener(() => {
+			setHasDiff(hasDiffNode(editor));
+		});
+		return () => {
+			unregister?.();
+		};
+	}, [editor, hasInit]);
+	return { hasDiff };
+}
+//#endregion
+export { useHasDiffNode };

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

@@ -0,0 +1,6 @@
+import { FC } from "react";
+
+//#region src/plugins/litexml/react/index.d.ts
+declare const ReactLiteXmlPlugin: FC<void>;
+//#endregion
+export { ReactLiteXmlPlugin };

package/es/plugins/litexml/react/index.js

@@ -0,0 +1,26 @@
+"use client";
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context.js";
+import { INodePlugin } from "../../inode/plugin/index.js";
+import { LitexmlPlugin } from "../plugin/index.js";
+import ReactDiffNodeToolbar from "./DiffNodeToolbar/index.js";
+import { styles } from "./style.js";
+import { useLayoutEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/plugins/litexml/react/index.tsx
+const ReactLiteXmlPlugin = () => {
+	const [editor] = useLexicalComposerContext();
+	useLayoutEffect(() => {
+		editor.registerPlugin(INodePlugin);
+		editor.registerPlugin(LitexmlPlugin, {
+			decorator: (node, editor) => /* @__PURE__ */ jsx(ReactDiffNodeToolbar, {
+				editor,
+				node
+			}),
+			theme: styles
+		});
+	}, [editor]);
+	return null;
+};
+ReactLiteXmlPlugin.displayName = "ReactLiteXmlPlugin";
+//#endregion
+export { ReactLiteXmlPlugin as default };

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

@@ -0,0 +1,124 @@
+import { createStaticStyles } from "antd-style";
+//#region src/plugins/litexml/react/style.ts
+const styles = createStaticStyles(({ css, cssVar }) => css`
+    position: relative;
+
+    .toolbar {
+      position: absolute;
+      z-index: 10;
+      inset-block-end: 0;
+      inset-inline-end: 8px;
+
+      opacity: 0;
+    }
+
+    &:hover {
+      .toolbar {
+        opacity: 1;
+      }
+    }
+
+    &[data-diff-type='add'] .content {
+      position: relative;
+      margin-block-start: calc(var(--lobe-markdown-margin-multiple) * 0.5em);
+      padding-inline-end: 4px;
+      border-inline-end: 3px solid ${cssVar.colorSuccess};
+    }
+
+    &[data-diff-type='remove'] .content {
+      position: relative;
+      margin-block-start: calc(var(--lobe-markdown-margin-multiple) * 0.5em);
+      padding-inline-end: 4px;
+      border-inline-end: 3px solid ${cssVar.colorError};
+
+      > *:first-child * {
+        color: ${cssVar.colorTextQuaternary} !important;
+        text-decoration: line-through !important;
+      }
+    }
+
+    &[data-diff-type='listItemRemove'] {
+      display: inline-block;
+      min-width: 100%;
+    }
+
+    &[data-diff-type='listItemRemove'] .content {
+      position: relative;
+      margin-block-start: calc(var(--lobe-markdown-margin-multiple) * 0.5em);
+      padding-inline-end: 4px;
+      border-inline-end: 3px solid ${cssVar.colorError};
+
+      /* first child: original (deleted) */
+
+      /*  > *:first-child {}  */
+
+      /* visually indicate deletion with strike-through for text nodes */
+      > *:first-child * {
+        color: ${cssVar.colorTextQuaternary} !important;
+        text-decoration: line-through !important;
+      }
+
+      /* second child: modified/new - normal appearance */
+      > *:nth-child(2) {
+        color: inherit;
+        opacity: 1;
+      }
+    }
+
+    &[data-diff-type='listItemModify'] {
+      display: inline-block;
+      min-width: 100%;
+
+      p {
+        display: block !important;
+      }
+    }
+
+    &[data-diff-type='listItemModify'] .content {
+      position: relative;
+      margin-block-start: calc(var(--lobe-markdown-margin-multiple) * 0.5em);
+      padding-inline-end: 4px;
+      border-inline-end: 3px solid ${cssVar.colorWarning};
+
+      /* first child: original (deleted) */
+
+      /*  > *:first-child {}  */
+
+      /* visually indicate deletion with strike-through for text nodes */
+      > *:first-child * {
+        color: ${cssVar.colorTextQuaternary} !important;
+        text-decoration: line-through !important;
+      }
+
+      /* second child: modified/new - normal appearance */
+      > *:nth-child(2) {
+        color: inherit;
+        opacity: 1;
+      }
+    }
+
+    &[data-diff-type='modify'] .content {
+      position: relative;
+      margin-block-start: calc(var(--lobe-markdown-margin-multiple) * 0.5em);
+      padding-inline-end: 4px;
+      border-inline-end: 3px solid ${cssVar.colorWarning};
+
+      /* first child: original (deleted) */
+
+      /*  > *:first-child {}  */
+
+      /* visually indicate deletion with strike-through for text nodes */
+      > *:first-child * {
+        color: ${cssVar.colorTextQuaternary} !important;
+        text-decoration: line-through !important;
+      }
+
+      /* second child: modified/new - normal appearance */
+      > *:nth-child(2) {
+        color: inherit;
+        opacity: 1;
+      }
+    }
+  `);
+//#endregion
+export { styles };

package/es/plugins/litexml/service/litexml-service.d.ts

@@ -0,0 +1,93 @@
+import { IServiceID } from "../../../types/kernel.js";
+import { LexicalNode } from "lexical";
+
+//#region src/plugins/litexml/service/litexml-service.d.ts
+/**
+ * XML Reader function type - converts XML element to Lexical node
+ */
+type XMLReaderFunc = (xmlElement: Element, children: any[]) => any | any[] | false;
+/**
+ * XML Writer function type - converts Lexical node to XML string
+ */
+type XMLWriterFunc = (node: LexicalNode, ctx: IWriterContext, indent: number, nodeToXML: (node: any, lines: string[], indent?: number) => void) => IXmlNode | HandleChildrenResult | false;
+/**
+ * Record of XML readers indexed by tag name
+ */
+type XMLReaderRecord = {
+  [tagName: string]: XMLReaderFunc | XMLReaderFunc[];
+};
+/**
+ * Record of XML writers indexed by node type
+ */
+type XMLWriterRecord = {
+  [nodeType: string]: XMLWriterFunc | XMLWriterFunc[];
+};
+interface IXmlNode {
+  attributes: {
+    [key: string]: string;
+  };
+  children?: IXmlNode[];
+  tagName: string;
+  textContent?: string;
+}
+interface HandleChildrenResult {
+  lines: string[];
+}
+interface IWriterContext {
+  createXmlNode(tagName: string, attributes?: {
+    [key: string]: string;
+  }, textContent?: string): IXmlNode;
+}
+/**
+ * ILitexmlService - Service interface for extending Litexml plugin
+ * Allows other plugins to register custom XML readers and writers
+ */
+interface ILitexmlService {
+  /**
+   * Get all registered XML readers
+   */
+  getXMLReaders(): XMLReaderRecord;
+  /**
+   * Get all registered XML writers
+   */
+  getXMLWriters(): XMLWriterRecord;
+  /**
+   * Check if a reader is registered for a tag
+   */
+  hasXMLReader(tagName: string): boolean;
+  /**
+   * Check if a writer is registered for a node type
+   */
+  hasXMLWriter(nodeType: string): boolean;
+  /**
+   * Register a custom XML reader for a specific tag name
+   * @param tagName - XML tag name to handle (case-insensitive)
+   * @param reader - Function that converts XML element to Lexical node
+   */
+  registerXMLReader(tagName: string, reader: XMLReaderFunc): void;
+  /**
+   * Register a custom XML writer for a specific Lexical node type
+   * @param nodeType - Lexical node type to handle
+   * @param writer - Function that converts Lexical node to XML string
+   */
+  registerXMLWriter(nodeType: string, writer: XMLWriterFunc): void;
+}
+/**
+ * Service ID for Litexml service
+ */
+declare const ILitexmlService: IServiceID<ILitexmlService>;
+/**
+ * Default implementation of ILitexmlService
+ */
+declare class LitexmlService implements ILitexmlService {
+  private readers;
+  private writers;
+  registerXMLReader(tagName: string, reader: XMLReaderFunc): void;
+  registerXMLWriter(nodeType: string, writer: XMLWriterFunc): void;
+  getXMLReaders(): XMLReaderRecord;
+  getXMLWriters(): XMLWriterRecord;
+  hasXMLReader(tagName: string): boolean;
+  hasXMLWriter(nodeType: string): boolean;
+}
+//#endregion
+export { ILitexmlService, LitexmlService, XMLReaderFunc, XMLReaderRecord, XMLWriterFunc, XMLWriterRecord };

package/es/plugins/litexml/service/litexml-service.js

@@ -0,0 +1,42 @@
+import { genServiceId } from "../../../editor-kernel/utils.js";
+//#region src/plugins/litexml/service/litexml-service.ts
+/**
+* Service ID for Litexml service
+*/
+const ILitexmlService = genServiceId("ILitexmlService");
+/**
+* Default implementation of ILitexmlService
+*/
+var LitexmlService = class {
+	constructor() {
+		this.readers = {};
+		this.writers = {};
+	}
+	registerXMLReader(tagName, reader) {
+		const key = tagName.toLowerCase();
+		if (this.readers[key]) {
+			const existing = this.readers[key];
+			this.readers[key] = Array.isArray(existing) ? [...existing, reader] : [existing, reader];
+		} else this.readers[key] = reader;
+	}
+	registerXMLWriter(nodeType, writer) {
+		if (this.writers[nodeType]) {
+			const existing = this.writers[nodeType];
+			this.writers[nodeType] = Array.isArray(existing) ? [...existing, writer] : [existing, writer];
+		} else this.writers[nodeType] = writer;
+	}
+	getXMLReaders() {
+		return { ...this.readers };
+	}
+	getXMLWriters() {
+		return { ...this.writers };
+	}
+	hasXMLReader(tagName) {
+		return !!this.readers[tagName.toLowerCase()];
+	}
+	hasXMLWriter(nodeType) {
+		return !!this.writers[nodeType];
+	}
+};
+//#endregion
+export { ILitexmlService, LitexmlService };