@lobehub/editor 4.15.1 → 4.15.2

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

@@ -0,0 +1,114 @@
+import { IEditor } from "../../../types/kernel.js";
+import { ISlashMenuOption, ISlashOption, SlashOptions } from "../service/i-slash-service.js";
+import { FC, ReactElement } from "react";
+import { IFuseOptions } from "fuse.js";
+
+//#region src/plugins/slash/react/type.d.ts
+interface ReactSlashOptionProps {
+  /**
+   * Complete Fuse.js configuration options
+   * @example
+   * {
+   *   keys: ['key', 'label', 'description'],
+   *   threshold: 0.3,
+   *   includeScore: true,
+   *   includeMatches: true
+   * }
+   */
+  fuseOptions?: IFuseOptions<ISlashMenuOption>;
+  /**
+   * Searchable options
+   */
+  items?: SlashOptions['items'];
+  /**
+   * Maximum search length
+   * Default is 75
+   */
+  maxLength?: number;
+  onSelect?: (editor: IEditor, option: ISlashMenuOption) => void;
+  /**
+   * Custom render component
+   */
+  renderComp?: FC<MenuRenderProps>;
+  /**
+   * Fuse.js search keys for fuzzy matching
+   * Default is ['key']
+   * @example ['key', 'label', 'description']
+   * @deprecated Use fuseOptions instead
+   */
+  searchKeys?: string[];
+  /**
+   * Trigger character
+   */
+  trigger?: SlashOptions['trigger'];
+}
+interface MenuRenderProps {
+  /**
+   * Current active option key
+   */
+  activeKey: string | null;
+  /**
+   * Loading state
+   */
+  loading?: boolean;
+  /**
+   * Actively trigger selection
+   * @param option Currently selected element
+   */
+  onSelect?: (option: ISlashMenuOption) => void;
+  open?: boolean;
+  /**
+   * Currently searched options
+   */
+  options: Array<ISlashOption>;
+  /**
+   * Actively set current active option key
+   * @param key
+   * @returns
+   */
+  setActiveKey: (key: string | null) => void;
+}
+/**
+ * SlashMenu component props - only responsible for rendering
+ */
+interface SlashMenuProps {
+  /** Current active option key */
+  activeKey: string | null;
+  /** Anchor element className */
+  anchorClassName?: string;
+  /** Custom render component if provided */
+  customRender?: FC<MenuRenderProps>;
+  /** Custom popup container for portal rendering and scroll tracking */
+  getPopupContainer?: () => HTMLElement | null;
+  /** Loading state */
+  loading: boolean;
+  /** Callback to set active key */
+  onActiveKeyChange: (key: string | null) => void;
+  /** Callback when menu should close */
+  onClose: () => void;
+  /** Callback when an option is selected */
+  onSelect: (option: ISlashMenuOption) => void;
+  /** Whether the menu is open */
+  open: boolean;
+  /** Available options to display */
+  options: Array<ISlashOption>;
+  /** Force menu placement direction, skipping auto-flip detection */
+  placement?: 'bottom' | 'top';
+  /** Menu position */
+  position: {
+    getRect?: () => DOMRect;
+    rect?: DOMRect;
+    x: number;
+    y: number;
+  };
+}
+interface ReactSlashPluginProps {
+  anchorClassName?: string;
+  children?: (ReactElement<ReactSlashOptionProps> | undefined) | (ReactElement<ReactSlashOptionProps> | undefined)[];
+  /** Custom popup container for portal rendering and scroll tracking */
+  getPopupContainer?: () => HTMLElement | null;
+  /** Force menu placement direction, skipping auto-flip detection */
+  placement?: 'bottom' | 'top';
+}
+//#endregion
+export { MenuRenderProps, ReactSlashOptionProps, ReactSlashPluginProps, SlashMenuProps };

package/es/plugins/slash/react/utils.js

@@ -0,0 +1,18 @@
+//#region src/plugins/slash/react/utils.ts
+function setCancelablePromise(executor) {
+	let isCancelled = false;
+	return {
+		cancel: () => {
+			isCancelled = true;
+		},
+		promise: new Promise((resolve, reject) => {
+			executor((value) => {
+				if (!isCancelled) resolve(value);
+			}, (reason) => {
+				if (!isCancelled) reject(reason);
+			});
+		})
+	};
+}
+//#endregion
+export { setCancelablePromise };

package/es/plugins/slash/service/i-slash-service.d.ts

@@ -0,0 +1,50 @@
+import { IEditor, IServiceID } from "../../../types/kernel.js";
+import { DropdownMenuItemType } from "@lobehub/ui";
+import Fuse, { IFuseOptions } from "fuse.js";
+
+//#region src/plugins/slash/service/i-slash-service.d.ts
+type ISlashDividerOption = {
+  type: 'divider';
+};
+interface ISlashMenuOption extends DropdownMenuItemType {
+  metadata?: Record<string, any>;
+  onSelect?: (editor: IEditor, matchingString: string) => void;
+}
+type ISlashOption = ISlashMenuOption | ISlashDividerOption;
+interface SlashOptions {
+  allowWhitespace?: boolean;
+  /**
+   * Complete Fuse.js configuration options
+   * @example
+   * {
+   *   keys: ['key', 'label', 'description'],
+   *   threshold: 0.3,
+   *   includeScore: true,
+   *   includeMatches: true
+   * }
+   */
+  fuseOptions?: IFuseOptions<ISlashMenuOption>;
+  items: Array<ISlashOption> | ((search: {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+  } | null) => Promise<Array<ISlashOption>>);
+  maxLength?: number;
+  minLength?: number;
+  punctuation?: string;
+  /**
+   * Fuse.js search keys for fuzzy matching
+   * Default is ['key']
+   * @example ['key', 'label', 'description']
+   * @deprecated Use fuseOptions instead
+   */
+  searchKeys?: string[];
+  trigger: string;
+}
+interface ISlashService {
+  registerSlash(options: SlashOptions): void;
+  updateOptions(options: SlashOptions[]): void;
+}
+declare const ISlashService: IServiceID<ISlashService>;
+//#endregion
+export { ISlashMenuOption, ISlashOption, ISlashService, SlashOptions };

package/es/plugins/slash/service/i-slash-service.js

@@ -0,0 +1,55 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { genServiceId } from "../../../editor-kernel/utils.js";
+import { getBasicTypeaheadTriggerMatch } from "../utils/utils.js";
+import Fuse from "fuse.js";
+//#region src/plugins/slash/service/i-slash-service.ts
+init_debug();
+const ISlashService = genServiceId("SlashService");
+var SlashService = class {
+	constructor(kernel) {
+		this.kernel = kernel;
+		this.triggerMap = /* @__PURE__ */ new Map();
+		this.triggerFnMap = /* @__PURE__ */ new Map();
+		this.triggerFuseMap = /* @__PURE__ */ new Map();
+		this.logger = createDebugLogger("service", "slash");
+	}
+	registerSlash(options, update = false) {
+		if (this.triggerMap.has(options.trigger) && !update) if (this.kernel.isHotReloadMode()) this.logger.warn(`🔄 Overriding slash trigger "${options.trigger}"`);
+		else throw new Error(`Slash trigger "${options.trigger}" is already registered.`);
+		this.triggerMap.set(options.trigger, options);
+		this.triggerFnMap.set(options.trigger, getBasicTypeaheadTriggerMatch(options.trigger, {
+			allowWhitespace: options.allowWhitespace,
+			maxLength: options.maxLength,
+			minLength: options.minLength,
+			punctuation: options.punctuation
+		}));
+		this.logger.debug(`⚡ Slash trigger: ${options.trigger}`);
+		if (Array.isArray(options.items)) {
+			const searchableItems = options.items.filter((item) => !("type" in item) || item.type !== "divider");
+			const fuseConfig = options.fuseOptions || { keys: options.searchKeys || ["key"] };
+			this.triggerFuseMap.set(options.trigger, new Fuse(searchableItems, fuseConfig));
+		}
+	}
+	removeAllOptions() {
+		this.triggerMap.clear();
+		this.triggerFnMap.clear();
+		this.triggerFuseMap.clear();
+	}
+	updateOptions(options) {
+		this.removeAllOptions();
+		options.forEach((option) => {
+			this.registerSlash(option);
+		});
+	}
+	getSlashOptions(trigger) {
+		return this.triggerMap.get(trigger);
+	}
+	getSlashTriggerFn(trigger) {
+		return this.triggerFnMap.get(trigger);
+	}
+	getSlashFuse(trigger) {
+		return this.triggerFuseMap.get(trigger);
+	}
+};
+//#endregion
+export { ISlashService, SlashService };

package/es/plugins/slash/utils/utils.d.ts

@@ -0,0 +1 @@
+import { LexicalEditor, RangeSelection, TextNode } from "lexical";

package/es/plugins/slash/utils/utils.js

@@ -0,0 +1,97 @@
+import { $getSelection, $isRangeSelection, getDOMSelection } from "lexical";
+//#region src/plugins/slash/utils/utils.ts
+/**
+* Get the text content of the editor up to the anchor point of the selection.
+* Get the text content before the anchor point of the selection
+* @param selection Selection object from Lexical editor
+* @returns
+*/
+function getTextUpToAnchor(selection) {
+	const anchor = selection.anchor;
+	if (anchor.type !== "text") return null;
+	const anchorNode = anchor.getNode();
+	if (!anchorNode.isSimpleText()) return null;
+	const anchorOffset = anchor.offset;
+	return anchorNode.getTextContent().slice(0, anchorOffset);
+}
+/**
+*
+* @param editor Lexical editor instance
+* Get the text content before the selection anchor point in the editor
+* @returns
+*/
+function getQueryTextForSearch(editor) {
+	let text = null;
+	editor.getEditorState().read(() => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return;
+		text = getTextUpToAnchor(selection);
+	});
+	return text;
+}
+function tryToPositionRange(leadOffset, range, editorWindow) {
+	const domSelection = getDOMSelection(editorWindow);
+	if (domSelection === null || !domSelection.isCollapsed) return false;
+	const anchorNode = domSelection.anchorNode;
+	const startOffset = leadOffset;
+	const endOffset = domSelection.anchorOffset;
+	if (anchorNode === null || endOffset === null) return false;
+	try {
+		range.setStart(anchorNode, startOffset);
+		range.setEnd(anchorNode, endOffset);
+	} catch {
+		return false;
+	}
+	return true;
+}
+const PUNCTUATION = "\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'\"~=<>_:;";
+function getBasicTypeaheadTriggerMatch(trigger, { minLength = 0, maxLength = 75, punctuation = PUNCTUATION, allowWhitespace = false }) {
+	return (text) => {
+		const validCharsSuffix = allowWhitespace ? "" : "\\s";
+		const validChars = "[^" + trigger + punctuation + validCharsSuffix + "]";
+		const regexPattern = allowWhitespace ? "(^|\\s|\\()([" + trigger + "]((?:" + validChars + "){0," + maxLength + "}))$" : "(^|\\s|\\()([" + trigger + "]((?:" + validChars + ")*?))(?=\\s|$)";
+		const match = new RegExp(regexPattern).exec(text);
+		if (match !== null) {
+			const maybeLeadingWhitespace = match[1];
+			const matchingString = match[3];
+			if (matchingString.length >= minLength && matchingString.length <= maxLength) return {
+				leadOffset: match.index + maybeLeadingWhitespace.length,
+				matchingString,
+				replaceableString: match[2]
+			};
+		}
+		return null;
+	};
+}
+/**
+* Walk backwards along user input and forward through entity title to try
+* and replace more of the user's text with entity.
+*/
+function getFullMatchOffset(documentText, entryText, offset) {
+	let triggerOffset = offset;
+	for (let i = triggerOffset; i <= entryText.length; i++) if (documentText.slice(-i) === entryText.slice(0, Math.max(0, i))) triggerOffset = i;
+	return triggerOffset;
+}
+/**
+* Split Lexical TextNode and return a new TextNode only containing matched text.
+* Common use cases include: removing the node, replacing with a new node.
+*/
+function $splitNodeContainingQuery(match) {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection) || !selection.isCollapsed()) return null;
+	const anchor = selection.anchor;
+	if (anchor.type !== "text") return null;
+	const anchorNode = anchor.getNode();
+	if (!anchorNode.isSimpleText()) return null;
+	const selectionOffset = anchor.offset;
+	const textContent = anchorNode.getTextContent().slice(0, selectionOffset);
+	const characterOffset = match.replaceableString.length;
+	const startOffset = selectionOffset - getFullMatchOffset(textContent, match.matchingString, characterOffset);
+	if (startOffset < 0) return null;
+	let newNode;
+	if (startOffset === 0) [newNode] = anchorNode.splitText(selectionOffset);
+	else [, newNode] = anchorNode.splitText(startOffset, selectionOffset);
+	return newNode;
+}
+//#endregion
+export { $splitNodeContainingQuery, getBasicTypeaheadTriggerMatch, getQueryTextForSearch, tryToPositionRange };

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

@@ -0,0 +1,17 @@
+import { InsertTableCommandPayloadHeaders } from "@lexical/table";
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/table/command/index.d.ts
+declare const INSERT_TABLE_COMMAND: _$lexical.LexicalCommand<{
+  columns: string;
+  includeHeaders?: InsertTableCommandPayloadHeaders;
+  rows: string;
+}>;
+declare const SELECT_TABLE_COMMAND: _$lexical.LexicalCommand<{
+  columnIndex?: number;
+  rowIndex?: number;
+  table: string;
+}>;
+//#endregion
+export { INSERT_TABLE_COMMAND, SELECT_TABLE_COMMAND };

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

@@ -0,0 +1,57 @@
+import { $createTableNodeWithDimensions, $createTableSelection, $findTableNode, $isTableNode, $isTableSelection } from "@lexical/table";
+import { $getNodeByKey, $getPreviousSelection, $getSelection, $isElementNode, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { $insertNodeToNearestRoot, mergeRegister } from "@lexical/utils";
+//#region src/plugins/table/command/index.ts
+const INSERT_TABLE_COMMAND = createCommand();
+const SELECT_TABLE_COMMAND = createCommand();
+function registerTableCommand(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_TABLE_COMMAND, ({ rows, columns, includeHeaders }) => {
+		const selection = $getSelection() || $getPreviousSelection();
+		if (!selection || !$isRangeSelection(selection)) return false;
+		if ($findTableNode(selection.anchor.getNode())) return false;
+		const anchorNode = selection.anchor.getNode();
+		const tableNode = $createTableNodeWithDimensions(Number(rows), Number(columns), includeHeaders);
+		if ($isElementNode(anchorNode) && anchorNode.isEmpty()) anchorNode.replace(tableNode);
+		else $insertNodeToNearestRoot(tableNode);
+		const firstDescendant = tableNode.getFirstDescendant();
+		if ($isTextNode(firstDescendant)) firstDescendant.select();
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_TABLE_COMMAND, ({ table, columnIndex, rowIndex }) => {
+		editor.update(() => {
+			const prevSelection = $getSelection();
+			const tableNode = $getNodeByKey(table);
+			if (!tableNode || !$isTableNode(tableNode)) return;
+			const tableSelection = $isTableSelection(prevSelection) ? prevSelection : $createTableSelection();
+			if (rowIndex !== void 0) {
+				const firstRow = tableNode.getChildren()[rowIndex];
+				if (!firstRow) return;
+				const firstCell = firstRow.getFirstChild();
+				const lastCell = firstRow.getLastChild();
+				if (!firstCell || !lastCell) return;
+				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+				$setSelection(tableSelection);
+			} else if (columnIndex !== void 0) {
+				const firstRow = tableNode.getFirstChild();
+				const lastRow = tableNode.getLastChild();
+				if (!firstRow || !lastRow) return;
+				const firstCell = firstRow.getChildren()[columnIndex];
+				const lastCell = lastRow.getChildren()[columnIndex];
+				if (!firstCell || !lastCell) return;
+				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+				$setSelection(tableSelection);
+			} else {
+				const firstRow = tableNode.getFirstChild();
+				const lastRow = tableNode.getLastChild();
+				if (!firstRow || !lastRow) return;
+				const firstCell = firstRow.getFirstChild();
+				const lastCell = lastRow.getLastChild();
+				if (!firstCell || !lastCell) return;
+				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+				$setSelection(tableSelection);
+			}
+		});
+		return false;
+	}, COMMAND_PRIORITY_EDITOR));
+}
+//#endregion
+export { INSERT_TABLE_COMMAND, SELECT_TABLE_COMMAND, registerTableCommand };

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

@@ -0,0 +1,3 @@
+import { INSERT_TABLE_COMMAND, SELECT_TABLE_COMMAND } from "./command/index.js";
+import { TablePlugin, TablePluginOptions } from "./plugin/index.js";
+import { ReactTablePlugin } from "./react/index.js";

package/es/plugins/table/node/index.js

@@ -0,0 +1,18 @@
+import { TableNode, TableNode as TableNode$1 } from "@lexical/table";
+//#region src/plugins/table/node/index.ts
+const OriginalCreateDOM = TableNode.prototype.createDOM;
+function patchTableNode() {
+	Object.defineProperty(TableNode.prototype, "createDOM", {
+		configurable: true,
+		enumerable: false,
+		value: function(config, editor) {
+			const table = OriginalCreateDOM.call(this, config, editor);
+			const controller = document.createElement("div");
+			table.append(controller);
+			return table;
+		},
+		writable: true
+	});
+}
+//#endregion
+export { TableNode$1 as TableNode, patchTableNode };

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

@@ -0,0 +1,8 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+//#region src/plugins/table/plugin/index.d.ts
+interface TablePluginOptions {
+  theme?: string;
+}
+declare const TablePlugin: IEditorPluginConstructor<TablePluginOptions>;
+//#endregion
+export { TablePlugin, TablePluginOptions };

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

@@ -0,0 +1,172 @@
+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 { cx } from "../../../utils/cx.js";
+import { registerTableCommand } from "../command/index.js";
+import { TableNode as TableNode$1, patchTableNode } from "../node/index.js";
+import { $isTableNode, TableCellNode, TableRowNode, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive } from "@lexical/table";
+//#region src/plugins/table/plugin/index.ts
+init_helper();
+init_plugin();
+const tableCellProcessor = (before, content, after) => {
+	return before + content.replace(/\n+$/, "").replaceAll(/\n+/g, "<br />") + after;
+};
+function isHeadlessEditor(editor) {
+	return editor._headless === true;
+}
+const TablePlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "TablePlugin";
+	}
+	constructor(kernel, options) {
+		super();
+		this.kernel = kernel;
+		patchTableNode();
+		kernel.registerNodes([
+			TableNode$1,
+			TableRowNode,
+			TableCellNode
+		]);
+		kernel.registerThemes({
+			table: "editor_table",
+			tableCell: "editor_table_cell",
+			tableCellHeader: "editor_table_cell_header",
+			tableCellSelected: "editor_table_cell_selected",
+			tableScrollableWrapper: cx("editor_table_scrollable_wrapper", options?.theme)
+		});
+	}
+	onInit(editor) {
+		this.register(registerTableCellUnmergeTransform(editor));
+		if (!isHeadlessEditor(editor)) {
+			setScrollableTablesActive(editor, true);
+			this.register(registerTablePlugin(editor));
+			this.register(registerTableSelectionObserver(editor));
+			this.register(registerTableCommand(editor));
+		}
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(TableNode$1.getType(), (node, ctx) => {
+			if ($isTableNode(node)) {
+				const attributes = {};
+				const colWidths = node.getColWidths();
+				if (colWidths && colWidths.length > 0) attributes.colWidths = colWidths.join(",");
+				return ctx.createXmlNode("table", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLWriter(TableRowNode.getType(), (node, ctx) => {
+			if (node instanceof TableRowNode) return ctx.createXmlNode("tr", {});
+			return false;
+		});
+		litexmlService.registerXMLWriter(TableCellNode.getType(), (node, ctx) => {
+			if (node instanceof TableCellNode) {
+				const attributes = {};
+				if (node.getColSpan() > 1) attributes.colSpan = node.getColSpan().toString();
+				if (node.getRowSpan() > 1) attributes.rowSpan = node.getRowSpan().toString();
+				if (node.getBackgroundColor()) attributes.backgroundColor = node.getBackgroundColor();
+				return ctx.createXmlNode("td", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLReader("table", (xmlNode, children) => {
+			const colWidthsAttr = xmlNode.getAttribute("colWidths");
+			const colWidths = colWidthsAttr ? colWidthsAttr.split(",").map((width) => parseInt(width, 10)) : [];
+			let maxTdlen = 1;
+			for (const child of children) if ((child.children?.length || -1) > maxTdlen) maxTdlen = child.children.length;
+			return INodeHelper.createElementNode(TableNode$1.getType(), {
+				children,
+				colWidths: colWidths.length > 0 ? colWidths : new Array(maxTdlen).fill(750 / maxTdlen),
+				direction: null,
+				format: "",
+				indent: 0,
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("tr", (_xmlNode, children) => {
+			return INodeHelper.createElementNode(TableRowNode.getType(), {
+				children,
+				direction: "ltr",
+				format: "",
+				height: 33,
+				indent: 0,
+				version: 1
+			});
+		});
+		const tdReader = (xmlNode, children) => {
+			return INodeHelper.createElementNode(TableCellNode.getType(), {
+				backgroundColor: xmlNode.getAttribute("backgroundColor") || null,
+				children,
+				colSpan: xmlNode.getAttribute("colSpan") ? parseInt(xmlNode.getAttribute("colSpan"), 10) : 1,
+				direction: "ltr",
+				format: "",
+				headerState: 0,
+				indent: 0,
+				rowSpan: xmlNode.getAttribute("rowSpan") ? parseInt(xmlNode.getAttribute("rowSpan"), 10) : 1,
+				version: 1
+			});
+		};
+		litexmlService.registerXMLReader("th", tdReader);
+		litexmlService.registerXMLReader("td", tdReader);
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownWriter(TableNode$1.getType(), (ctx) => {
+			ctx.wrap("", "\n");
+		});
+		markdownService.registerMarkdownWriter(TableRowNode.getType(), (ctx, node) => {
+			const parent = node.getParent();
+			if (!$isTableNode(parent)) return;
+			if (!node.getPreviousSibling()) ctx.wrap("", `\n${parent.getColWidths()?.map(() => {
+				return "|:--";
+			}).join("")}|\n`);
+			else ctx.wrap("", "\n");
+		});
+		markdownService.registerMarkdownWriter(TableCellNode.getType(), (ctx, node) => {
+			ctx.addProcessor(tableCellProcessor);
+			if (!node.getNextSibling()) ctx.wrap("|", "|");
+			else ctx.wrap("|", "");
+		});
+		markdownService.registerMarkdownReader("table", (node, children) => {
+			const colLen = node.children[0]?.children.length || 1;
+			return INodeHelper.createElementNode("table", {
+				children,
+				colWidths: new Array(colLen).fill(750 / colLen),
+				direction: null,
+				format: "",
+				indent: 0,
+				version: 1
+			});
+		});
+		markdownService.registerMarkdownReader("tableRow", (_node, children) => {
+			return INodeHelper.createElementNode("tablerow", {
+				children,
+				direction: "ltr",
+				format: "",
+				height: 33,
+				indent: 0,
+				version: 1
+			});
+		});
+		markdownService.registerMarkdownReader("tableCell", (_node, children) => {
+			return INodeHelper.createElementNode("tablecell", {
+				backgroundColor: null,
+				children,
+				colSpan: 1,
+				direction: "ltr",
+				format: "",
+				headerState: 0,
+				indent: 0,
+				rowSpan: 1,
+				version: 1
+			});
+		});
+	}
+};
+//#endregion
+export { TablePlugin };