@lobehub/editor 1.28.1 → 1.30.0

package/es/editor-kernel/kernel.js

@@ -29,7 +29,7 @@ import { createDebugLogger } from "../utils/debug";
 import { getHotkeyById, registerHotkey as _registerHotkey } from "../utils/hotkey/registerHotkey";
 import { registerEvent } from "./event";
 import { KernelPlugin } from "./plugin";
-import { createEmptyEditorState } from "./utils";
+import { createEmptyEditorState, noop } from "./utils";
 templateSettings.interpolate = /{{([\S\s]+?)}}/g;
 export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   _inherits(Kernel, _EventEmitter);
@@ -687,7 +687,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       }
       var listenersInPriorityOrder = commandsMap.get(command);
       if (listenersInPriorityOrder === undefined) {
-        return function () {};
+        return noop;
       }
       var listeners = listenersInPriorityOrder[priority];
       listeners.add(listener);

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

@@ -1,4 +1,4 @@
-import { LexicalEditor, LexicalNode, NodeKey } from 'lexical';
+import { ElementNode, LexicalEditor, LexicalNode, NodeKey } from 'lexical';
 import type { IEditorKernel, IServiceID } from "../types";
 export declare const DOM_ELEMENT_TYPE = 1;
 export declare const DOM_TEXT_TYPE = 3;
@@ -30,3 +30,6 @@ export declare function getKernelFromEditor(editor: LexicalEditor): IEditorKerne
  * @returns
  */
 export declare function compareNodeOrder(nodeA: LexicalNode, nodeB: LexicalNode): number;
+export declare function $closest(node: LexicalNode | ElementNode | null, test: (node: LexicalNode) => boolean): LexicalNode | null;
+export declare function $closestNodeType(node: LexicalNode | ElementNode | null, type: string | string[]): LexicalNode | null;
+export declare function moment(): Promise<unknown>;

package/es/editor-kernel/utils.js

@@ -108,4 +108,26 @@ export function compareNodeOrder(nodeA, nodeB) {
 
   // This case should not happen as we checked for equality at the start
   return 0;
+}
+export function $closest(node, test) {
+  var current = node;
+  while (current) {
+    if (test(current)) {
+      return current;
+    }
+    current = current.getParent();
+  }
+  return null;
+}
+export function $closestNodeType(node, type) {
+  return $closest(node, function (n) {
+    return Array.isArray(type) ? type.includes(n.getType()) : n.getType() === type;
+  });
+}
+export function moment() {
+  return new Promise(function (resolve) {
+    queueMicrotask(function () {
+      return resolve(true);
+    });
+  });
 }

package/es/index.d.ts

@@ -10,6 +10,7 @@ export * from './plugins/image';
 export * from './plugins/link';
 export * from './plugins/link-highlight';
 export * from './plugins/list';
+export * from './plugins/litexml';
 export * from './plugins/markdown';
 export * from './plugins/math';
 export * from './plugins/mention';

package/es/index.js

@@ -10,6 +10,7 @@ export * from "./plugins/image";
 export * from "./plugins/link";
 export * from "./plugins/link-highlight";
 export * from "./plugins/list";
+export * from "./plugins/litexml";
 export * from "./plugins/markdown";
 export * from "./plugins/math";
 export * from "./plugins/mention";

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

@@ -17,6 +17,7 @@ import { $setSelection, TextNode } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { $createCursorNode, cursorNodeSerialized } from "../../common";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerCodeInlineCommand } from "../command";
 import { $createCodeNode, CodeNode } from "../node/code";
@@ -49,12 +50,34 @@ export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           node.replace($createCodeNode(node.getTextContent())).insertAfter($createCursorNode());
         }
       }));
+      this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(CodeNode.getType(), function (node, ctx) {
+        return ctx.createXmlNode('codeInline', {});
+      });
+      litexmlService.registerXMLReader('codeInline', function (xmlElement, children) {
+        return INodeHelper.createElementNode(CodeNode.getType(), {
+          children: children
+        });
+      });
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
       var markdownService = this.kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
         return;
       }
       markdownService.registerMarkdownWriter(CodeNode.getType(), function (ctx, node) {
-        ctx.appendLine("`".concat(node.getTextContent(), "`"));
+        ctx.appendLine("`".concat(node.getTextContent().replaceAll("\uFEFF", ''), "`"));
         return true;
       });
       markdownService.registerMarkdownShortCuts([{

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

@@ -17,6 +17,7 @@ import { $createCodeNode, $isCodeHighlightNode, $isCodeNode, CodeHighlightNode,
 import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, PASTE_COMMAND, TabNode } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { CustomShikiTokenizer, registerCodeCommand } from "../command";
 import { getCodeLanguageByInput } from "../utils/language";
@@ -121,11 +122,54 @@ export var CodeblockPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         return false;
       }, COMMAND_PRIORITY_EDITOR));
       this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var _this2 = this;
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(CodeNode.getType(), function (node, ctx) {
+        var codeNode = node;
+        var xmlNode = ctx.createXmlNode('code', {
+          lang: codeNode.getLanguage() || 'plaintext'
+        }, codeNode.getTextContent());
+        return xmlNode;
+      });
+      litexmlService.registerXMLReader('code', function (xmlElment, children) {
+        var _this2$config;
+        var text = children.map(function (v) {
+          return v.text || '';
+        }).join('');
+        return INodeHelper.createElementNode(CodeNode.getType(), {
+          children: text.split('\n').flatMap(function (text, index, arr) {
+            var textNode = INodeHelper.createTextNode(text);
+            textNode.type = 'code-highlight';
+            if (index === arr.length - 1) {
+              return textNode;
+            }
+            return [textNode, {
+              type: 'linebreak',
+              version: 1
+            }];
+          }).flat(),
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          language: xmlElment.getAttribute('lang'),
+          textStyle: '--shiki-dark:var(--color-info);--shiki-light:var(--color-info)',
+          theme: "".concat(toMarkdownTheme((_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.shikiTheme), " needUpdate"),
+          version: 1
+        });
+      });
     }
   }, {
     key: "registerMarkdown",
     value: function registerMarkdown() {
-      var _this2 = this;
+      var _this3 = this;
       var kernel = this.kernel;
       var markdownService = kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
@@ -160,7 +204,7 @@ export var CodeblockPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
       });
       markdownService.registerMarkdownReader('code', function (node) {
-        var _this2$config;
+        var _this3$config;
         var language = node.lang ? getCodeLanguageByInput(node.lang) : 'plaintext';
         return INodeHelper.createElementNode('code', {
           children: node.value.split('\n').flatMap(function (text, index, arr) {
@@ -179,7 +223,7 @@ export var CodeblockPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           indent: 0,
           language: language,
           textStyle: '--shiki-dark:var(--color-info);--shiki-light:var(--color-info)',
-          theme: "".concat(toMarkdownTheme((_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.shikiTheme), " needUpdate"),
+          theme: "".concat(toMarkdownTheme((_this3$config = _this3.config) === null || _this3$config === void 0 ? void 0 : _this3$config.shikiTheme), " needUpdate"),
           version: 1
         });
       });

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

@@ -25,8 +25,11 @@ import { registerDragonSupport } from '@lexical/dragon';
 import { registerHistory } from '@lexical/history';
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from '@lexical/rich-text';
 import { CAN_USE_DOM } from '@lexical/utils';
-import { $createLineBreakNode, $createParagraphNode, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND } from 'lexical';
+import { $createLineBreakNode, $createParagraphNode, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, ParagraphNode, TEXT_TYPE_TO_FORMAT, TextNode } from 'lexical';
+import { noop } from "../../../editor-kernel";
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { isPunctuationChar } from "../../markdown/utils";
 import { registerCommands } from "../command";
@@ -199,7 +202,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         markdownService.registerMarkdownShortCuts(textFormatShortcuts);
       }
       markdownService.registerMarkdownWriter('paragraph', function (ctx) {
-        ctx.wrap('', '\n');
+        ctx.wrap('', '\n\n');
       });
       markdownService.registerMarkdownWriter('quote', function (ctx, node) {
         if ($isQuoteNode(node)) {
@@ -323,7 +326,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     key: "onInit",
     value: function onInit(editor) {
       var _this$config2;
-      this.registerClears(registerRichText(editor), CAN_USE_DOM ? registerDragonSupport(editor) : function () {}, registerHistory(editor, this.kernel.getHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
+      this.registerClears(registerRichText(editor), CAN_USE_DOM ? registerDragonSupport(editor) : noop, registerHistory(editor, this.kernel.getHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
         enableHotkey: (_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enableHotkey
       }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor),
       // Convert soft line breaks (Shift+Enter) to hard line breaks (paragraph breaks)
@@ -363,6 +366,108 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         return true; // Prevent default line break behavior
       }, COMMAND_PRIORITY_HIGH));
       this.registerMarkdown(this.kernel);
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(TextNode.getType(), function (node, ctx) {
+        var attr = {};
+        if ($isTextNode(node)) {
+          if (node.hasFormat('bold')) {
+            attr['bold'] = 'true';
+          }
+          if (node.hasFormat('italic')) {
+            attr['italic'] = 'true';
+          }
+          if (node.hasFormat('underline')) {
+            attr['underline'] = 'true';
+          }
+          if (node.hasFormat('strikethrough')) {
+            attr['strikethrough'] = 'true';
+          }
+          if (node.hasFormat('subscript')) {
+            attr['subscript'] = 'true';
+          }
+          if (node.hasFormat('superscript')) {
+            attr['superscript'] = 'true';
+          }
+          return ctx.createXmlNode('span', attr, node.getTextContent());
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('span', function (xmlElement) {
+        var textContent = xmlElement.textContent || '';
+        var bold = xmlElement.getAttribute('bold');
+        var italic = xmlElement.getAttribute('italic');
+        var underline = xmlElement.getAttribute('underline');
+        var strikethrough = xmlElement.getAttribute('strikethrough');
+        var subscript = xmlElement.getAttribute('subscript');
+        var superscript = xmlElement.getAttribute('superscript');
+        var format = 0;
+        if (bold === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['bold'];
+        }
+        if (italic === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['italic'];
+        }
+        if (underline === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['underline'];
+        }
+        if (strikethrough === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['strikethrough'];
+        }
+        if (subscript === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['subscript'];
+        }
+        if (superscript === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['superscript'];
+        }
+        return INodeHelper.createTextNode(textContent, {
+          detail: 0,
+          format: format,
+          mode: 'normal',
+          style: ''
+        });
+      });
+      litexmlService.registerXMLWriter('quote', function (node, ctx) {
+        if ($isQuoteNode(node)) {
+          return ctx.createXmlNode('quote', {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter('heading', function (node, ctx) {
+        if ($isHeadingNode(node)) {
+          return ctx.createXmlNode(node.getTag(), {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(ParagraphNode.getType(), function (node, ctx) {
+        return ctx.createXmlNode('p', {});
+      });
+      litexmlService.registerXMLReader('quote', function (xmlElement, children) {
+        return INodeHelper.createElementNode(QuoteNode.getType(), {
+          children: children
+        });
+      });
+      litexmlService.registerXMLReader('p', function (xmlElement, children) {
+        return INodeHelper.createElementNode(ParagraphNode.getType(), {
+          children: children
+        });
+      });
+      var headingTags = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+      headingTags.forEach(function (tag) {
+        litexmlService.registerXMLReader(tag, function (xmlElement, children) {
+          return INodeHelper.createElementNode(HeadingNode.getType(), {
+            children: children,
+            tag: tag
+          });
+        });
+      });
     }
   }, {
     key: "destroy",

package/es/plugins/common/react/Placeholder/index.js

@@ -7,6 +7,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { mergeRegister } from '@lexical/utils';
 import { $getNodeByKey, $getSelection, $isBlockElementNode, $isRangeSelection } from 'lexical';
 import { memo, useRef, useState } from 'react';
+import { $closestNodeType } from "../../../../editor-kernel";
 import { useLexicalEditor } from "../../../../editor-kernel/react";
 import { $canShowPlaceholderCurry } from "../../utils";
 import { useStyles } from "./style";
@@ -55,7 +56,8 @@ var Placeholder = /*#__PURE__*/memo(function (_ref) {
             while (node && !$isBlockElementNode(node)) {
               node = node.getParent();
             }
-            if (node) {
+            var tableNode = $closestNodeType(node, ['tablecell', 'heading']);
+            if (node && !tableNode) {
               var dom = editor.getElementByKey(node.getKey());
               if (dom && hasOnlyBrChild(dom)) {
                 if (currentPlaceHolderRef.current && currentPlaceHolderRef.current !== dom) {

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

@@ -18,7 +18,9 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { $wrapNodeInElement } from '@lexical/utils';
 import { $createParagraphNode, $createRangeSelection, $insertNodes, $isRootOrShadowRoot, $setSelection } from 'lexical';
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { IUploadService } from "../../upload";
 import { createDebugLogger } from "../../../utils/debug";
@@ -32,7 +34,6 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(FilePlugin, _KernelPlugin);
   var _super = _createSuper(FilePlugin);
   function FilePlugin(kernel, config) {
-    var _kernel$requireServic;
     var _this;
     _classCallCheck(this, FilePlugin);
     _this = _super.call(this);
@@ -47,21 +48,6 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.registerDecorator(kernel, FileNode.getType(), function (node, editor) {
       return config !== null && config !== void 0 && config.decorator ? config.decorator(node, editor) : null;
     });
-    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownWriter(FileNode.getType(), function (ctx, node) {
-      if ($isFileNode(node)) {
-        if (config !== null && config !== void 0 && config.markdownWriter) {
-          ctx.appendLine(config.markdownWriter(node));
-          return;
-        }
-        if (node.status === 'pending') {
-          ctx.appendLine("Uploading ".concat(node.name, "..."));
-        } else if (node.status === 'error') {
-          ctx.appendLine("Failed to upload ".concat(node.name, ": ").concat(node.message));
-        } else {
-          ctx.appendLine("[".concat(node.name, "](").concat(node.fileUrl, ")"));
-        }
-      }
-    });
     return _this;
   }
   _createClass(FilePlugin, [{
@@ -112,6 +98,66 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       }());
       this.register(registerFileCommand(editor, this.config.handleUpload));
       this.register(registerFileNodeSelectionObserver(editor));
+      this.registerLiteXml();
+      this.registerMarkdownWriter();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(FileNode.getType(), function (node, ctx) {
+        if ($isFileNode(node)) {
+          var _node$size;
+          return ctx.createXmlNode('file', {
+            fileUrl: node.fileUrl || '',
+            message: node.message || '',
+            name: node.name,
+            size: ((_node$size = node.size) === null || _node$size === void 0 ? void 0 : _node$size.toString()) || '0',
+            status: node.status
+          });
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('file', function (xmlElement) {
+        var name = xmlElement.getAttribute('name') || 'unknown';
+        var fileUrl = xmlElement.getAttribute('fileUrl') || '';
+        var status = xmlElement.getAttribute('status');
+        return INodeHelper.createTypeNode(FileNode.getType(), {
+          fileUrl: fileUrl,
+          message: xmlElement.getAttribute('message') || '',
+          name: name,
+          size: parseInt(xmlElement.getAttribute('size') || '0', 10),
+          status: status
+        });
+      });
+    }
+  }, {
+    key: "registerMarkdownWriter",
+    value: function registerMarkdownWriter() {
+      var _this3 = this;
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      if (!markdownService) {
+        return;
+      }
+      markdownService.registerMarkdownWriter(FileNode.getType(), function (ctx, node) {
+        if ($isFileNode(node)) {
+          var _this3$config;
+          if ((_this3$config = _this3.config) !== null && _this3$config !== void 0 && _this3$config.markdownWriter) {
+            ctx.appendLine(_this3.config.markdownWriter(node));
+            return;
+          }
+          if (node.status === 'pending') {
+            ctx.appendLine("Uploading ".concat(node.name, "..."));
+          } else if (node.status === 'error') {
+            ctx.appendLine("Failed to upload ".concat(node.name, ": ").concat(node.message));
+          } else {
+            ctx.appendLine("[".concat(node.name, "](").concat(node.fileUrl, ")"));
+          }
+        }
+      });
     }
   }]);
   return FilePlugin;

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

@@ -15,6 +15,7 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerHorizontalRuleCommand } from "../command";
 import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from "../node/HorizontalRuleNode";
@@ -42,8 +43,31 @@ export var HRPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _createClass(HRPlugin, [{
     key: "onInit",
     value: function onInit(editor) {
-      var _this$kernel$requireS, _this$kernel$requireS2, _this$kernel$requireS3;
       this.register(registerHorizontalRuleCommand(editor));
+      this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(HorizontalRuleNode.getType(), function (node, ctx) {
+        if ($isHorizontalRuleNode(node)) {
+          return ctx.createXmlNode('hr', {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('hr', function () {
+        return INodeHelper.createElementNode(HorizontalRuleNode.getType(), {});
+      });
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
+      var _this$kernel$requireS, _this$kernel$requireS2, _this$kernel$requireS3;
       (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownShortCut({
         regExp: /^(---|\*\*\*|___)$/,
         replace: function replace(parentNode, _1, _2, isImport) {

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

@@ -7,4 +7,4 @@ export declare const INSERT_IMAGE_COMMAND: import("lexical").LexicalCommand<{
 }>;
 export declare function registerImageCommand(editor: LexicalEditor, handleUpload: (file: File) => Promise<{
     url: string;
-}>): () => void;
+}>, defaultBlockImage?: boolean): () => void;

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

@@ -9,11 +9,13 @@ function isImageFile(file) {
   return file.type.startsWith('image/');
 }
 export function registerImageCommand(editor, handleUpload) {
+  var defaultBlockImage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   return editor.registerCommand(INSERT_IMAGE_COMMAND, function (payload) {
     var file = payload.file,
       range = payload.range,
       block = payload.block,
       maxWidth = payload.maxWidth;
+    var isBlock = block !== null && block !== void 0 ? block : defaultBlockImage;
     if (!isImageFile(file)) {
       return false; // Not an image file
     }
@@ -26,7 +28,7 @@ export function registerImageCommand(editor, handleUpload) {
         }
         $setSelection(rangeSelection);
       }
-      var imageNode = block ? $createBlockImageNode({
+      var imageNode = isBlock ? $createBlockImageNode({
         altText: file.name,
         maxWidth: maxWidth || 800,
         src: placeholderURL
@@ -36,7 +38,7 @@ export function registerImageCommand(editor, handleUpload) {
         src: placeholderURL
       });
       $insertNodes([imageNode]); // Insert a zero-width space to ensure the image is not the last child
-      if (!block && $isRootOrShadowRoot(imageNode.getParentOrThrow())) {
+      if (!isBlock && $isRootOrShadowRoot(imageNode.getParentOrThrow())) {
         $wrapNodeInElement(imageNode, $createParagraphNode).selectEnd();
       }
       handleUpload(file).then(function (res) {

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

@@ -1,21 +1,17 @@
-import { DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalUpdateJSON, NodeKey, SerializedEditor, SerializedLexicalNode, Spread } from 'lexical';
+import { DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalUpdateJSON, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
 export interface ImagePayload {
     altText: string;
     caption?: LexicalEditor;
-    captionsEnabled?: boolean;
     height?: number;
     key?: NodeKey;
     maxWidth?: number;
-    showCaption?: boolean;
     src: string;
     width?: number;
 }
 export type SerializedImageNode = Spread<{
     altText: string;
-    caption: SerializedEditor;
     height?: number;
     maxWidth: number;
-    showCaption: boolean;
     src: string;
     width?: number;
 }, SerializedLexicalNode>;
@@ -25,18 +21,14 @@ export declare class BaseImageNode extends DecoratorNode<any> {
     __width: 'inherit' | number;
     __height: 'inherit' | number;
     __maxWidth: number;
-    __showCaption: boolean;
-    __caption: LexicalEditor;
-    __captionsEnabled: boolean;
     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, showCaption?: boolean, caption?: LexicalEditor, captionsEnabled?: boolean, key?: NodeKey);
+    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;
-    setShowCaption(showCaption: boolean): void;
     isInline(): boolean;
     createDOM(config: EditorConfig): HTMLElement;
     updateDOM(): false;