@lobehub/editor 4.5.0 → 4.6.1

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

@@ -1,553 +0,0 @@
-var _class;
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-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 { 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_CRITICAL, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, PASTE_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";
-import JSONDataSource from "../data-source/json-data-source";
-import TextDataSource from "../data-source/text-data-source";
-import { patchBreakLine, registerBreakLineClick } from "../node/ElementDOMSlot";
-import { CursorNode, registerCursorNode } from "../node/cursor";
-import { $isCursorInQuote, $isCursorInTable, createBlockNode, sampleReader } from "../utils";
-import { registerMDReader } from "./mdReader";
-import { handleFilePaste, handlePlainTextPaste, handleVSCodePaste, runPasteHandlers } from "./paste-handler";
-import { registerHeaderBackspace, registerLastElement, registerRichKeydown } from "./register";
-patchBreakLine();
-export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
-  _inherits(CommonPlugin, _KernelPlugin);
-  var _super = _createSuper(CommonPlugin);
-  function CommonPlugin(kernel) {
-    var _config$markdownOptio;
-    var _this;
-    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    _classCallCheck(this, CommonPlugin);
-    _this = _super.call(this);
-
-    // Parse markdown options and update formats
-    _defineProperty(_assertThisInitialized(_this), "formats", {
-      bold: true,
-      header: true,
-      italic: true,
-      quote: true,
-      strikethrough: true,
-      subscript: false,
-      superscript: false
-    });
-    _this.kernel = kernel;
-    _this.config = config;
-    var markdownOption = (_config$markdownOptio = config.markdownOption) !== null && _config$markdownOptio !== void 0 ? _config$markdownOptio : true;
-    if (_typeof(markdownOption) === 'object') {
-      var _markdownOption$bold, _markdownOption$heade, _markdownOption$itali, _markdownOption$quote, _markdownOption$strik, _markdownOption$subsc, _markdownOption$super;
-      _this.formats.bold = (_markdownOption$bold = markdownOption.bold) !== null && _markdownOption$bold !== void 0 ? _markdownOption$bold : true;
-      _this.formats.header = (_markdownOption$heade = markdownOption.header) !== null && _markdownOption$heade !== void 0 ? _markdownOption$heade : true;
-      _this.formats.italic = (_markdownOption$itali = markdownOption.italic) !== null && _markdownOption$itali !== void 0 ? _markdownOption$itali : true;
-      _this.formats.quote = (_markdownOption$quote = markdownOption.quote) !== null && _markdownOption$quote !== void 0 ? _markdownOption$quote : true;
-      _this.formats.strikethrough = (_markdownOption$strik = markdownOption.strikethrough) !== null && _markdownOption$strik !== void 0 ? _markdownOption$strik : true;
-      _this.formats.subscript = (_markdownOption$subsc = markdownOption.subscript) !== null && _markdownOption$subsc !== void 0 ? _markdownOption$subsc : false;
-      _this.formats.superscript = (_markdownOption$super = markdownOption.superscript) !== null && _markdownOption$super !== void 0 ? _markdownOption$super : false;
-    } else if (markdownOption === false) {
-      // Disable all formats if markdown is disabled
-      _this.formats.bold = false;
-      _this.formats.header = false;
-      _this.formats.italic = false;
-      _this.formats.quote = false;
-      _this.formats.strikethrough = false;
-      _this.formats.subscript = false;
-      _this.formats.superscript = false;
-    }
-
-    // Register the JSON data source
-    kernel.registerDataSource(new JSONDataSource('json'));
-    // Register the text data source
-    kernel.registerDataSource(new TextDataSource('text'));
-    // Register common nodes and themes
-    kernel.registerNodes([HeadingNode, QuoteNode, CursorNode]);
-    if (config !== null && config !== void 0 && config.theme) {
-      kernel.registerThemes({
-        quote: config.theme.quote,
-        text: {
-          bold: config.theme.textBold,
-          code: config.theme.textCode,
-          highlight: config.theme.textHighlight,
-          italic: config.theme.textItalic,
-          strikethrough: config.theme.textStrikethrough,
-          subscript: config.theme.textSubscript,
-          superscript: config.theme.textSuperscript,
-          underline: config.theme.textUnderline,
-          underlineStrikethrough: config.theme.textUnderlineStrikethrough
-        }
-      });
-    }
-    return _this;
-  }
-  _createClass(CommonPlugin, [{
-    key: "registerMarkdown",
-    value: function registerMarkdown(kernel) {
-      var _this$config$markdown, _this$config;
-      var markdownService = kernel.requireService(IMarkdownShortCutService);
-      if (!markdownService) {
-        return;
-      }
-
-      // Parse markdown options
-      var markdownOption = (_this$config$markdown = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.markdownOption) !== null && _this$config$markdown !== void 0 ? _this$config$markdown : true;
-      var isMarkdownEnabled = markdownOption !== false;
-      var breakMark = isMarkdownEnabled ? '\n\n' : '\n';
-      var formats = this.formats;
-
-      // Register quote shortcut if enabled
-      if (formats.quote) {
-        markdownService.registerMarkdownShortCut({
-          regExp: /^>\s/,
-          replace: function replace(parentNode, children, _match, isImport) {
-            if (isImport) {
-              var previousNode = parentNode.getPreviousSibling();
-              if ($isQuoteNode(previousNode)) {
-                previousNode.splice(previousNode.getChildrenSize(), 0, [$createLineBreakNode()].concat(_toConsumableArray(children)));
-                parentNode.remove();
-                return;
-              }
-            }
-            var node = $createQuoteNode();
-            node.append.apply(node, _toConsumableArray(children));
-            parentNode.replace(node);
-            if (!isImport) {
-              node.select(0, 0);
-            }
-          },
-          type: 'element'
-        });
-      }
-
-      // Register header shortcut if enabled
-      if (formats.header) {
-        markdownService.registerMarkdownShortCut({
-          regExp: /^(#{1,6})\s/,
-          replace: createBlockNode(function (match, parentNode) {
-            var tag = 'h' + match[1].length;
-            if ($isHeadingNode(parentNode) && parentNode.getTag() === tag) {
-              return $createParagraphNode();
-            }
-            return $createHeadingNode(tag);
-          }),
-          type: 'element'
-        });
-      }
-
-      // Register text format shortcuts based on enabled formats
-      var textFormatShortcuts = [];
-      if (formats.bold) {
-        textFormatShortcuts.push({
-          format: ['bold'],
-          tag: '**',
-          type: 'text-format'
-        }, {
-          format: ['bold'],
-          intraword: false,
-          tag: '__',
-          type: 'text-format'
-        });
-      }
-      if (formats.strikethrough) {
-        textFormatShortcuts.push({
-          format: ['strikethrough'],
-          tag: '~~',
-          type: 'text-format'
-        });
-      }
-      if (formats.italic) {
-        textFormatShortcuts.push({
-          format: ['italic'],
-          tag: '*',
-          type: 'text-format'
-        }, {
-          format: ['italic'],
-          intraword: false,
-          tag: '_',
-          type: 'text-format'
-        });
-      }
-      if (formats.superscript) {
-        textFormatShortcuts.push({
-          format: ['superscript'],
-          tag: '^',
-          type: 'text-format'
-        });
-      }
-      if (formats.subscript) {
-        textFormatShortcuts.push({
-          format: ['subscript'],
-          tag: '~',
-          type: 'text-format'
-        });
-      }
-      if (textFormatShortcuts.length > 0) {
-        markdownService.registerMarkdownShortCuts(textFormatShortcuts);
-      }
-      markdownService.registerMarkdownWriter('paragraph', function (ctx) {
-        ctx.wrap('', breakMark);
-      });
-
-      // Register quote writer only if quote format is enabled
-      if (formats.quote) {
-        markdownService.registerMarkdownWriter('quote', function (ctx, node) {
-          if ($isQuoteNode(node)) {
-            ctx.wrap('> ', breakMark);
-          }
-        });
-      }
-
-      // Register heading writer only if header format is enabled
-      if (formats.header) {
-        markdownService.registerMarkdownWriter('heading', function (ctx, node) {
-          if ($isHeadingNode(node)) {
-            switch (node.getTag()) {
-              case 'h1':
-                {
-                  ctx.wrap('# ', '\n\n');
-                  break;
-                }
-              case 'h2':
-                {
-                  ctx.wrap('## ', '\n\n');
-                  break;
-                }
-              case 'h3':
-                {
-                  ctx.wrap('### ', '\n\n');
-                  break;
-                }
-              case 'h4':
-                {
-                  ctx.wrap('#### ', '\n\n');
-                  break;
-                }
-              case 'h5':
-                {
-                  ctx.wrap('##### ', '\n\n');
-                  break;
-                }
-              case 'h6':
-                {
-                  ctx.wrap('###### ', '\n\n');
-                  break;
-                }
-              default:
-                {
-                  ctx.wrap('', '\n\n');
-                  break;
-                }
-            }
-          }
-        });
-      }
-
-      // Register text writer with conditional format handling
-      markdownService.registerMarkdownWriter('text', function (ctx, node) {
-        if (!$isTextNode(node)) {
-          return;
-        }
-        var isBold = formats.bold && node.hasFormat('bold');
-        var isItalic = formats.italic && node.hasFormat('italic');
-        var isUnderline = node.hasFormat('underline');
-        var isStrikethrough = formats.strikethrough && node.hasFormat('strikethrough');
-        var isSuperscript = formats.superscript && node.hasFormat('superscript');
-        var isSubscript = formats.subscript && node.hasFormat('subscript');
-        if (isBold) {
-          ctx.appendLine('**');
-        }
-        if (isStrikethrough) {
-          ctx.appendLine('~~');
-        }
-        if (isItalic) {
-          ctx.appendLine('_');
-        }
-        if (isUnderline) {
-          ctx.appendLine('<ins>');
-        }
-        if (isSuperscript) {
-          ctx.appendLine('^');
-        }
-        if (isSubscript) {
-          ctx.appendLine('~');
-        }
-        var textContent = node.getTextContent();
-        var res = textContent.match(/\s+$/);
-        var tailSpace = '';
-        if (res) {
-          tailSpace = res[0];
-        }
-        var append = textContent.trimEnd();
-        var lastChar = append.at(-1);
-        ctx.appendLine(append);
-        if (isSubscript) {
-          ctx.appendLine('~');
-        }
-        if (isSuperscript) {
-          ctx.appendLine('^');
-        }
-        if (isUnderline) {
-          ctx.appendLine('</ins>');
-        }
-        if (isItalic) {
-          ctx.appendLine('_');
-        }
-        if (isStrikethrough) {
-          ctx.appendLine('~~');
-        }
-        if (isBold) {
-          ctx.appendLine('**');
-        }
-        if (tailSpace) {
-          ctx.appendLine(tailSpace);
-        } else if (lastChar && isPunctuationChar(lastChar)) {
-          ctx.appendLine(' ');
-        }
-      });
-
-      // Register markdown writer for linebreak nodes (soft line breaks)
-      markdownService.registerMarkdownWriter('linebreak', function (ctx) {
-        // In markdown, soft line breaks are represented as two spaces followed by a newline
-        ctx.appendLine('\n');
-      });
-
-      // 注册 markdown reader
-      //
-      registerMDReader(markdownService);
-    }
-  }, {
-    key: "onInit",
-    value: function onInit(editor) {
-      var _this2 = this,
-        _this$config2;
-      this.register(this.kernel.registerHighCommand(PASTE_COMMAND, function (event) {
-        var _this2$config, _this2$config2;
-        if (!(event instanceof ClipboardEvent)) return false;
-        var clipboardData = event.clipboardData;
-        if (!clipboardData) return false;
-        _this2.kernel.emit('onPaste', event);
-        var ctx = {
-          clipboardData: clipboardData,
-          config: _this2.config,
-          editor: editor,
-          event: event
-        };
-
-        // VS Code paste handling is independent of pasteAsPlainText
-        // This ensures code blocks get proper language even in rich text mode
-        if ((_this2$config = _this2.config) !== null && _this2$config !== void 0 && _this2$config.pasteVSCodeAsCodeBlock) {
-          var result = handleVSCodePaste(ctx);
-          if (result === 'handled') {
-            return true;
-          }
-        }
-
-        // If pasteAsPlainText is enabled, run the plain text handlers chain
-        if ((_this2$config2 = _this2.config) !== null && _this2$config2 !== void 0 && _this2$config2.pasteAsPlainText) {
-          return runPasteHandlers(ctx, [handleFilePaste, handlePlainTextPaste]);
-        }
-        return false;
-      }, COMMAND_PRIORITY_CRITICAL));
-      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)
-      // This allows breaking out of code blocks with Shift+Enter
-      editor.registerCommand(INSERT_LINE_BREAK_COMMAND, function () {
-        // editor.getEditorState().read(() => {
-        var selection = $getSelection();
-        if (!$isRangeSelection(selection)) {
-          return false;
-        }
-
-        // Check if cursor is in a table
-        var _$isCursorInTable = $isCursorInTable(selection),
-          inCell = _$isCursorInTable.inCell,
-          inTable = _$isCursorInTable.inTable;
-        if (inCell) {
-          // We're in a table cell, allow normal line break behavior
-          return false;
-        }
-        if (inTable) {
-          // We're in a table but not in a cell, prevent line break
-          return false;
-        }
-
-        // Check if cursor is in a quote
-        var inQuote = $isCursorInQuote(selection);
-        if (inQuote) {
-          // We're in a quote block, allow normal line break behavior
-          // This preserves line breaks within quotes while maintaining quote formatting
-          return false;
-        }
-
-        // Not in a table or quote, convert to paragraph break
-        editor.update(function () {
-          editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);
-        });
-        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;
-      }
-      var formats = this.formats;
-      litexmlService.registerXMLWriter(TextNode.getType(), function (node, ctx) {
-        var attr = {};
-        if ($isTextNode(node)) {
-          if (formats.bold && node.hasFormat('bold')) {
-            attr['bold'] = 'true';
-          }
-          if (formats.italic && node.hasFormat('italic')) {
-            attr['italic'] = 'true';
-          }
-          if (node.hasFormat('underline')) {
-            attr['underline'] = 'true';
-          }
-          if (formats.strikethrough && node.hasFormat('strikethrough')) {
-            attr['strikethrough'] = 'true';
-          }
-          if (formats.subscript && node.hasFormat('subscript')) {
-            attr['subscript'] = 'true';
-          }
-          if (formats.superscript && node.hasFormat('superscript')) {
-            attr['superscript'] = 'true';
-          }
-          return ctx.createXmlNode('span', attr, node.getTextContent());
-        }
-        return false;
-      });
-
-      // Register bold readers only if bold format is enabled
-      if (formats.bold) {
-        litexmlService.registerXMLReader('b', sampleReader.bind(this, TEXT_TYPE_TO_FORMAT['bold']));
-        litexmlService.registerXMLReader('strong', sampleReader.bind(this, TEXT_TYPE_TO_FORMAT['bold']));
-      }
-
-      // Register italic readers only if italic format is enabled
-      if (formats.italic) {
-        litexmlService.registerXMLReader('i', sampleReader.bind(this, TEXT_TYPE_TO_FORMAT['italic']));
-        litexmlService.registerXMLReader('emphasis', sampleReader.bind(this, TEXT_TYPE_TO_FORMAT['italic']));
-      }
-      litexmlService.registerXMLReader('u', sampleReader.bind(this, TEXT_TYPE_TO_FORMAT['underline']));
-      litexmlService.registerXMLReader('ins', sampleReader.bind(this, TEXT_TYPE_TO_FORMAT['underline']));
-      litexmlService.registerXMLReader('span', function (xmlElement, children) {
-        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 (formats.bold && bold === 'true') {
-          format |= TEXT_TYPE_TO_FORMAT['bold'];
-        }
-        if (formats.italic && italic === 'true') {
-          format |= TEXT_TYPE_TO_FORMAT['italic'];
-        }
-        if (underline === 'true') {
-          format |= TEXT_TYPE_TO_FORMAT['underline'];
-        }
-        if (formats.strikethrough && strikethrough === 'true') {
-          format |= TEXT_TYPE_TO_FORMAT['strikethrough'];
-        }
-        if (formats.subscript && subscript === 'true') {
-          format |= TEXT_TYPE_TO_FORMAT['subscript'];
-        }
-        if (formats.superscript && superscript === 'true') {
-          format |= TEXT_TYPE_TO_FORMAT['superscript'];
-        }
-        children.forEach(function (child) {
-          if (INodeHelper.isTextNode(child)) {
-            child.format = (child.format || 0) | format;
-          }
-        });
-        return children;
-      });
-
-      // Register quote writer/reader only if quote format is enabled
-      if (formats.quote) {
-        litexmlService.registerXMLWriter('quote', function (node, ctx) {
-          if ($isQuoteNode(node)) {
-            return ctx.createXmlNode('quote', {});
-          }
-          return false;
-        });
-        litexmlService.registerXMLReader('quote', function (xmlElement, children) {
-          return INodeHelper.createElementNode(QuoteNode.getType(), {
-            children: children
-          });
-        });
-      }
-
-      // Register heading writer/reader only if header format is enabled
-      if (formats.header) {
-        litexmlService.registerXMLWriter('heading', function (node, ctx) {
-          if ($isHeadingNode(node)) {
-            return ctx.createXmlNode(node.getTag(), {});
-          }
-          return false;
-        });
-        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
-            });
-          });
-        });
-      }
-      litexmlService.registerXMLWriter(ParagraphNode.getType(), function (node, ctx) {
-        return ctx.createXmlNode('p', {});
-      });
-      litexmlService.registerXMLReader('p', function (xmlElement, children) {
-        return INodeHelper.createElementNode(ParagraphNode.getType(), {
-          children: children
-        });
-      });
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      // Cleanup logic
-      _get(_getPrototypeOf(CommonPlugin.prototype), "destroy", this).call(this);
-    }
-  }]);
-  return CommonPlugin;
-}(KernelPlugin), _defineProperty(_class, "pluginName", 'CommonPlugin'), _class);

package/es/plugins/common/plugin/mdReader.d.ts

@@ -1,2 +0,0 @@
-import type { IMarkdownShortCutService } from "../../markdown/service/shortcut";
-export declare function registerMDReader(markdownService: IMarkdownShortCutService): void;

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

@@ -1,84 +0,0 @@
-import { IS_BOLD, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE } from 'lexical';
-import { INodeHelper } from "../../../editor-kernel/inode/helper";
-export function registerMDReader(markdownService) {
-  markdownService.registerMarkdownReader('blockquote', function (node, children) {
-    return INodeHelper.createElementNode('quote', {
-      children: children,
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
-    });
-  });
-
-  // strong italic del
-  markdownService.registerMarkdownReader('strong', function (node, children) {
-    return children.map(function (child) {
-      if (INodeHelper.isTextNode(child)) {
-        child.format = (child.format || 0) | IS_BOLD;
-      }
-      return child;
-    });
-  });
-
-  // strong italic del
-  markdownService.registerMarkdownReader('emphasis', function (node, children) {
-    return children.map(function (child) {
-      if (INodeHelper.isTextNode(child)) {
-        child.format = (child.format || 0) | IS_ITALIC;
-      }
-      return child;
-    });
-  });
-
-  // strong italic del
-  markdownService.registerMarkdownReader('delete', function (node, children) {
-    return children.map(function (child) {
-      if (INodeHelper.isTextNode(child)) {
-        child.format = (child.format || 0) | IS_STRIKETHROUGH;
-      }
-      return child;
-    });
-  });
-  markdownService.registerMarkdownReader('subscript', function (node, children) {
-    return children.map(function (child) {
-      if (INodeHelper.isTextNode(child)) {
-        child.format = (child.format || 0) | IS_SUBSCRIPT;
-      }
-      return child;
-    });
-  });
-  markdownService.registerMarkdownReader('superscript', function (node, children) {
-    return children.map(function (child) {
-      if (INodeHelper.isTextNode(child)) {
-        child.format = (child.format || 0) | IS_SUPERSCRIPT;
-      }
-      return child;
-    });
-  });
-  markdownService.registerMarkdownReader('html', function (node, children) {
-    if (['<ins>', '<u>'].includes(node.value.toLocaleLowerCase())) {
-      return children.map(function (child) {
-        if (INodeHelper.isTextNode(child)) {
-          child.format = (child.format || 0) | IS_UNDERLINE;
-        }
-        return child;
-      });
-    } else if (['<em>'].includes(node.value.toLocaleLowerCase())) {
-      return children.map(function (child) {
-        if (INodeHelper.isTextNode(child)) {
-          child.format = (child.format || 0) | IS_ITALIC;
-        }
-        return child;
-      });
-    } else if (['<strong>'].includes(node.value.toLocaleLowerCase())) {
-      return children.map(function (child) {
-        if (INodeHelper.isTextNode(child)) {
-          child.format = (child.format || 0) | IS_BOLD;
-        }
-        return child;
-      });
-    }
-    return false;
-  });
-}

package/es/plugins/common/plugin/paste-handler.d.ts

@@ -1,37 +0,0 @@
-import type { LexicalEditor } from 'lexical';
-/**
- * Configuration options relevant to paste handling
- */
-export interface PasteHandlerConfig {
-    pasteVSCodeAsCodeBlock?: boolean;
-}
-export interface PasteContext {
-    clipboardData: DataTransfer;
-    config: PasteHandlerConfig;
-    editor: LexicalEditor;
-    event: ClipboardEvent;
-}
-/**
- * Paste handler function type.
- * @returns 'handled' - stop the chain, event is handled
- * @returns 'skip' - skip pasteAsPlainText logic, let default behavior handle
- * @returns 'next' - continue to next handler
- */
-export type PasteHandler = (ctx: PasteContext) => 'handled' | 'skip' | 'next';
-/**
- * Check if it's a file paste - skip plain text handling to let file uploads work normally
- */
-export declare const handleFilePaste: PasteHandler;
-/**
- * Handle VS Code paste - create code block with language from vscode-editor-data
- */
-export declare const handleVSCodePaste: PasteHandler;
-/**
- * Handle plain text paste - fallback handler that pastes as plain text
- */
-export declare const handlePlainTextPaste: PasteHandler;
-/**
- * Run paste handlers in sequence (middleware chain pattern)
- * @returns true if event was handled, false to let default behavior continue
- */
-export declare function runPasteHandlers(ctx: PasteContext, handlers: PasteHandler[]): boolean;