@lobehub/editor 4.5.0 → 4.6.0

package/es/style-CFkese2R.js

@@ -0,0 +1,999 @@
+import { I as CardLikeElementNode, ht as reconcileDecorator, ot as getKernelFromEditor, st as getKernelFromEditorConfig, ut as init_utils } from "./style-Ub1LiKko.js";
+import { $applyNodeReplacement, DecoratorNode, ElementNode } from "lexical";
+import { addClassNamesToElement } from "@lexical/utils";
+import { createStaticStyles, cx } from "antd-style";
+//#region src/plugins/auto-complete/node/placeholderNode.ts
+var PlaceholderNode = class PlaceholderNode extends ElementNode {
+	static getType() {
+		return "PlaceholderInline";
+	}
+	static clone(node) {
+		return new PlaceholderNode(node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createPlaceholderNode().updateFromJSON(serializedNode);
+	}
+	createDOM(config) {
+		const element = document.createElement("span");
+		element.setAttribute("data-lexical-key", this.getKey());
+		addClassNamesToElement(element, config.theme.placeholderInline);
+		return element;
+	}
+	updateDOM(prevNode, dom, config) {
+		if ((prevNode ? prevNode : null) !== this) addClassNamesToElement(dom, config.theme.placeholderInline);
+		return false;
+	}
+	canBeEmpty() {
+		return false;
+	}
+	isCardLike() {
+		return true;
+	}
+	isInline() {
+		return true;
+	}
+	canIndent() {
+		return false;
+	}
+	canInsertTextBefore() {
+		return true;
+	}
+	canInsertTextAfter() {
+		return true;
+	}
+};
+var PlaceholderBlockNode = class PlaceholderBlockNode extends ElementNode {
+	static getType() {
+		return "PlaceholderBlock";
+	}
+	static clone(node) {
+		return new PlaceholderBlockNode(node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createPlaceholderBlockNode().updateFromJSON(serializedNode);
+	}
+	createDOM(config) {
+		const element = document.createElement("div");
+		element.setAttribute("data-lexical-key", this.getKey());
+		addClassNamesToElement(element, config.theme.placeholderBlock);
+		return element;
+	}
+	updateDOM(prevNode, dom, config) {
+		if ((prevNode ? prevNode : null) !== this) addClassNamesToElement(dom, config.theme.placeholderBlock);
+		return false;
+	}
+	canBeEmpty() {
+		return false;
+	}
+	isCardLike() {
+		return true;
+	}
+	isInline() {
+		return false;
+	}
+	canIndent() {
+		return false;
+	}
+	canInsertTextBefore() {
+		return false;
+	}
+	canInsertTextAfter() {
+		return false;
+	}
+};
+function $createPlaceholderNode() {
+	return $applyNodeReplacement(new PlaceholderNode());
+}
+function $createPlaceholderBlockNode() {
+	return $applyNodeReplacement(new PlaceholderBlockNode());
+}
+//#endregion
+//#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
+//#region src/plugins/file/node/FileNode.ts
+init_utils();
+var FileNode = class FileNode extends DecoratorNode {
+	static getType() {
+		return "file";
+	}
+	static clone(node) {
+		return new FileNode(node.__name, node.__fileUrl, node.__size, node.__status, node.__message, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return new FileNode(serializedNode.name, serializedNode.fileUrl, serializedNode.size, serializedNode.status, serializedNode.message);
+	}
+	static importDOM() {
+		return { span: (node) => {
+			if (node.classList.contains("file")) return {
+				conversion: $convertFileElement,
+				priority: 0
+			};
+			return null;
+		} };
+	}
+	get name() {
+		return this.__name;
+	}
+	get fileUrl() {
+		return this.__fileUrl;
+	}
+	get size() {
+		return this.__size;
+	}
+	get status() {
+		return this.__status;
+	}
+	get message() {
+		return this.__message;
+	}
+	constructor(name, fileUrl, size, status, message, key) {
+		super(key);
+		this.__name = name;
+		this.__fileUrl = fileUrl;
+		this.__size = size;
+		this.__status = status || "pending";
+		this.__message = message;
+	}
+	setUploaded(url) {
+		const writable = this.getWritable();
+		writable.__fileUrl = url;
+		writable.__status = "uploaded";
+		writable.__message = void 0;
+	}
+	setError(message) {
+		const writable = this.getWritable();
+		writable.__status = "error";
+		writable.__message = message;
+	}
+	exportDOM() {
+		return { element: document.createElement("span") };
+	}
+	createDOM(config) {
+		const element = document.createElement("span");
+		addClassNamesToElement(element, config.theme.file);
+		return element;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			fileUrl: this.fileUrl,
+			message: this.message,
+			name: this.name,
+			size: this.size,
+			status: this.status
+		};
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode);
+	}
+	getTextContent() {
+		return "\n";
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator("file");
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+function $createFileNode(name = "unknown", fileUrl, size, status, message) {
+	return $applyNodeReplacement(new FileNode(name, fileUrl, size, status, message));
+}
+function $convertFileElement() {
+	return { node: $createFileNode() };
+}
+function $isFileNode(node) {
+	return node.getType() === FileNode.getType();
+}
+//#endregion
+//#region src/plugins/file/react/style.ts
+const styles$4 = createStaticStyles(({ css, cssVar }) => ({ file: css`
+    user-select: none;
+
+    display: inline-block;
+
+    margin-inline: 0.25em;
+    padding-block: 0.2em;
+    padding-inline: 0.4em;
+    border: 1px solid var(--lobe-markdown-border-color);
+    border-radius: 0.25em;
+
+    font-family: ${cssVar.fontFamilyCode};
+    font-size: 0.875em;
+    line-height: 1;
+    word-break: break-word;
+    white-space: break-spaces;
+
+    background: ${cssVar.colorFillSecondary};
+
+    span {
+      user-select: none;
+    }
+
+    &.selected {
+      color: #000;
+      background: ${cssVar.yellow};
+    }
+  ` }));
+//#endregion
+//#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
+//#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
+//#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$1,
+			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$1(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
+//#region src/plugins/image/node/image-node.tsx
+var ImageNode = class ImageNode extends BaseImageNode {
+	static {
+		this._decorate = () => null;
+	}
+	static setDecorate(decorate) {
+		ImageNode._decorate = decorate;
+	}
+	static getType() {
+		return "image";
+	}
+	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";
+	}
+	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;
+	}
+	setMaxWidth(maxWidth) {
+		const writable = this.getWritable();
+		writable.__maxWidth = maxWidth;
+	}
+	setStatus(status) {
+		const writable = this.getWritable();
+		writable.__status = status;
+	}
+	setWidth(width) {
+		const writable = this.getWritable();
+		writable.__width = width;
+	}
+	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 ImageNode({
+			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 $createImageNode({
+			altText,
+			height,
+			maxWidth,
+			src,
+			status,
+			width
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { img: () => ({
+			conversion: $convertImageElement,
+			priority: 0
+		}) };
+	}
+	decorate() {
+		return ImageNode._decorate(this);
+	}
+};
+function $createImageNode({ altText, height, maxWidth = 500, src, width, key, status }) {
+	return $applyNodeReplacement(new ImageNode({
+		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: $createImageNode({
+		altText,
+		height,
+		src,
+		width
+	}) };
+}
+function $isImageNode(node) {
+	return node.getType() === ImageNode.getType();
+}
+//#endregion
+//#region src/plugins/image/react/style.ts
+const styles$3 = createStaticStyles(({ css, cssVar }) => ({
+	image: css`
+    cursor: default;
+    user-select: none;
+    position: relative;
+    display: inline-block;
+
+    &.selected {
+      background-color: ${cssVar.colorPrimaryBg};
+    }
+  `,
+	blockImage: css`
+    cursor: default;
+    user-select: none;
+
+    position: relative;
+
+    display: block;
+
+    text-align: center;
+
+    &.selected {
+      background-color: ${cssVar.colorPrimaryBg};
+    }
+  `
+}));
+const imageBroken = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA2NDAgNDAwIj48cGF0aCBmaWxsPSIjM0IzQjNCIiBkPSJNMCAwaDY0MHY0MDBIMHoiLz48cGF0aCBzdHJva2U9IiM2MjYyNjIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIxNSIgZD0iTTM3Mi41IDEzMi41aC0xMDVjLTguMjg0IDAtMTUgNi43MTYtMTUgMTV2MTA1YzAgOC4yODQgNi43MTYgMTUgMTUgMTVoMTA1YzguMjg0IDAgMTUtNi43MTYgMTUtMTV2LTEwNWMwLTguMjg0LTYuNzE2LTE1LTE1LTE1eiIvPjxwYXRoIHN0cm9rZT0iIzYyNjI2MiIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjE1IiBkPSJNMjk3LjUgMTkyLjVjOC4yODQgMCAxNS02LjcxNiAxNS0xNSAwLTguMjg0LTYuNzE2LTE1LTE1LTE1LTguMjg0IDAtMTUgNi43MTYtMTUgMTUgMCA4LjI4NCA2LjcxNiAxNSAxNSAxNXpNMzg3LjUgMjIyLjUwMmwtMjMuMTQ1LTIzLjE0NWExNS4wMDEgMTUuMDAxIDAgMDAtMjEuMjEgMEwyNzUgMjY3LjUwMiIvPjwvc3ZnPg==";
+//#endregion
+//#region src/plugins/list/react/style.ts
+const styles$2 = createStaticStyles(({ css, cssVar }) => css`
+    .editor_listUnordered&,
+    .editor_listOrdered& {
+      margin-block: calc(var(--lobe-markdown-margin-multiple) * 0.5em);
+      margin-inline-start: 1em;
+      padding-inline-start: 0;
+      list-style-position: outside;
+
+      > .editor_listUnordered,
+      > ol {
+        margin-block: 0;
+      }
+
+      > .editor_listItem {
+        margin-inline-start: 1em;
+      }
+    }
+
+    .editor_listOrdered& {
+      list-style: auto;
+    }
+
+    .editor_listUnordered& {
+      list-style-type: none;
+
+      > .editor_listItem:not(:has(ul)):not([role='checkbox']) {
+        &::before {
+          content: '-';
+          display: inline-block;
+          margin-inline: -1em 0.5em;
+          opacity: 0.5;
+        }
+      }
+    }
+
+    .editor_listItem {
+      margin-block: calc(var(--lobe-markdown-margin-multiple) * 0.33em);
+      font-family: var(--listitem-marker-font-family);
+      font-size: var(--listitem-marker-font-size);
+      background-color: var(--listitem-marker-background-color);
+
+      &::marker {
+        font-family: var(--listitem-marker-font-family);
+        font-size: var(--listitem-marker-font-size);
+        color: var(--listitem-marker-color);
+        background-color: var(--listitem-marker-background-color);
+      }
+
+      p {
+        display: inline;
+      }
+
+      .editor_listUnordered,
+      .editor_listOrdered {
+        margin: 0;
+      }
+    }
+
+    [role='checkbox'] {
+      position: relative;
+    }
+
+    .editor_listItemChecked::before,
+    .editor_listItemUnchecked::before {
+      border: 1px solid ${cssVar.colorBorder};
+      border-radius: 4px;
+    }
+
+    .editor_listItemChecked::before {
+      background: ${cssVar.colorPrimary};
+    }
+
+    .editor_listItemChecked:not(:has(ul))::after {
+      cursor: pointer;
+      content: '';
+
+      position: absolute;
+      inset-block-start: 50%;
+      inset-inline-start: 0.2em;
+      transform: rotate(45deg) scale(1) translate(-50%, -50%);
+
+      display: block;
+
+      width: 0.3em;
+      height: 0.6em;
+      margin-inline: -1.35em 0.5em;
+      border: 2px solid ${cssVar.colorTextLightSolid};
+      border-block-start: 0;
+      border-inline-start: 0;
+
+      background-size: cover;
+
+      transition: all 0.2s cubic-bezier(0.12, 0.4, 0.29, 1.46) 0.1s;
+    }
+
+    .editor_listItemUnchecked:not(:has(ul))::before,
+    .editor_listItemChecked:not(:has(ul))::before {
+      cursor: pointer;
+      content: '';
+
+      position: absolute;
+      inset-block-start: 50%;
+      inset-inline-start: 0;
+      transform: translateY(-50%);
+
+      display: inline-block;
+      display: block;
+
+      width: 1em;
+      height: 1em;
+      margin-inline: -1.4em 0.5em;
+
+      background-size: cover;
+    }
+
+    .editor_listItemNested {
+      list-style-type: none;
+    }
+  `);
+//#endregion
+//#region src/plugins/math/react/style.ts
+const styles$1 = createStaticStyles(({ css, cssVar }) => {
+	const latex = css`
+    cursor: pointer;
+    user-select: none;
+    font-size: 1em;
+
+    .katex-error {
+      color: ${cssVar.colorError} !important;
+    }
+
+    .katex-html {
+      overflow: auto hidden;
+      padding: 3px;
+
+      .base {
+        margin-block: 0;
+        margin-inline: auto;
+      }
+
+      .tag {
+        position: relative !important;
+        display: inline-block;
+        padding-inline-start: 0.5rem;
+      }
+    }
+
+    &.selected {
+      color: #000;
+      background: ${cssVar.yellow};
+    }
+
+    &:hover {
+      background: ${cssVar.colorFillTertiary};
+    }
+
+    &.editing {
+      background: ${cssVar.colorFillTertiary};
+    }
+
+    &:has(.katex-error) {
+      background: ${cssVar.colorErrorBg};
+    }
+  `;
+	return {
+		mathInline: cx(latex, css`
+        display: inline-block;
+        border-radius: calc(var(--lobe-markdown-border-radius) * 0.5px);
+      `),
+		mathBlock: cx(latex, css`
+        overflow: auto hidden;
+        display: block;
+        border-radius: calc(var(--lobe-markdown-border-radius) * 1px);
+        white-space: nowrap;
+      `),
+		mathEditor: css`
+      width: 320px;
+      background: ${cssVar.colorBgElevated};
+
+      textarea {
+        width: 100%;
+
+        font-family: ${cssVar.fontFamilyCode};
+        font-size: 13px;
+
+        background: transparent !important;
+
+        transition: none !important;
+      }
+    `,
+		mathEditorFooter: css`
+      border-block-start: 1px solid ${cssVar.colorBorderSecondary};
+      background: ${cssVar.colorFillQuaternary};
+    `,
+		mathEditorAnchor: css`
+      pointer-events: none;
+
+      position: absolute;
+      inset-block-start: -9999px;
+      inset-inline-start: -9999px;
+
+      width: 0;
+      height: 0;
+    `,
+		mathEditorTextArea: css`
+      margin-block: 4px;
+    `,
+		mathPlaceholder: css`
+      padding-inline: 0.2em;
+      font-style: italic;
+    `
+	};
+});
+//#endregion
+//#region src/plugins/table/react/style.ts
+const styles = createStaticStyles(({ css, cssVar }) => css`
+    overflow-x: auto;
+    margin-block: calc(var(--lobe-markdown-margin-multiple) * 0.5em)
+      calc(var(--lobe-markdown-margin-multiple) * 0.5em + 16px);
+
+    .editor_table {
+      table-layout: fixed;
+      border-spacing: 0;
+      border-collapse: collapse;
+
+      width: fit-content;
+
+      text-align: start;
+      text-indent: initial;
+      text-wrap: pretty;
+      word-break: auto-phrase;
+      overflow-wrap: break-word;
+
+      background: ${cssVar.colorFillQuaternary};
+
+      > tr:first-of-type {
+        background: ${cssVar.colorFillQuaternary};
+
+        .editor_table_cell_header {
+          font-weight: bold;
+        }
+      }
+    }
+
+    code {
+      word-break: break-word;
+    }
+
+    .editor_table_cell_header {
+      font-weight: normal;
+    }
+
+    .editor_table_cell {
+      position: relative;
+
+      overflow: auto;
+
+      width: 75px;
+      padding-block: 6px;
+      padding-inline: 8px;
+      border: 1px solid ${cssVar.colorFillSecondary};
+
+      text-align: start;
+      vertical-align: top;
+
+      outline: none;
+    }
+
+    .editor_table_cell_selected {
+      color: #000;
+      background-color: ${cssVar.yellow};
+      caret-color: transparent;
+    }
+  `);
+//#endregion
+export { PlaceholderNode as S, $isFileNode as _, styles$3 as a, DiffNode as b, ImageNode as c, BlockImageNode as d, $createHorizontalRuleNode as f, $createFileNode as g, styles$4 as h, imageBroken as i, $createBlockImageNode as l, HorizontalRuleNode as m, styles$1 as n, $createImageNode as o, $isHorizontalRuleNode as p, styles$2 as r, $isImageNode as s, styles as t, $isBlockImageNode as u, FileNode as v, PlaceholderBlockNode as x, $createDiffNode as y };