@lobehub/editor 4.5.0 → 4.6.0

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

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

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

@@ -1,101 +0,0 @@
-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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-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 _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 _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 { genServiceId } from "../../../editor-kernel";
-
-/**
- * XML Reader function type - converts XML element to Lexical node
- */
-
-/**
- * XML Writer function type - converts Lexical node to XML string
- */
-
-// return IXmlNode if handled, false to continue with default
-
-/**
- * Record of XML readers indexed by tag name
- */
-
-/**
- * Record of XML writers indexed by node type
- */
-
-/**
- * ILitexmlService - Service interface for extending Litexml plugin
- * Allows other plugins to register custom XML readers and writers
- */
-
-/**
- * Service ID for Litexml service
- */
-// eslint-disable-next-line @typescript-eslint/no-redeclare, no-redeclare
-export var ILitexmlService = genServiceId('ILitexmlService');
-
-/**
- * Default implementation of ILitexmlService
- */
-export var LitexmlService = /*#__PURE__*/function () {
-  function LitexmlService() {
-    _classCallCheck(this, LitexmlService);
-    _defineProperty(this, "readers", {});
-    _defineProperty(this, "writers", {});
-  }
-  _createClass(LitexmlService, [{
-    key: "registerXMLReader",
-    value: function registerXMLReader(tagName, reader) {
-      var key = tagName.toLowerCase();
-      if (this.readers[key]) {
-        // If reader already exists, convert to array
-        var existing = this.readers[key];
-        this.readers[key] = Array.isArray(existing) ? [].concat(_toConsumableArray(existing), [reader]) : [existing, reader];
-      } else {
-        this.readers[key] = reader;
-      }
-    }
-  }, {
-    key: "registerXMLWriter",
-    value: function registerXMLWriter(nodeType, writer) {
-      if (this.writers[nodeType]) {
-        // If writer already exists, convert to array
-        var existing = this.writers[nodeType];
-        this.writers[nodeType] = Array.isArray(existing) ? [].concat(_toConsumableArray(existing), [writer]) : [existing, writer];
-      } else {
-        this.writers[nodeType] = writer;
-      }
-    }
-  }, {
-    key: "getXMLReaders",
-    value: function getXMLReaders() {
-      return _objectSpread({}, this.readers);
-    }
-  }, {
-    key: "getXMLWriters",
-    value: function getXMLWriters() {
-      return _objectSpread({}, this.writers);
-    }
-  }, {
-    key: "hasXMLReader",
-    value: function hasXMLReader(tagName) {
-      return !!this.readers[tagName.toLowerCase()];
-    }
-  }, {
-    key: "hasXMLWriter",
-    value: function hasXMLWriter(nodeType) {
-      return !!this.writers[nodeType];
-    }
-  }]);
-  return LitexmlService;
-}();

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

@@ -1,6 +0,0 @@
-import type { EditorState } from 'lexical';
-import { LexicalEditor, LexicalNode } from 'lexical';
-export declare function $parseSerializedNodeImpl(serializedNode: any, editor: LexicalEditor, keepId?: boolean, state?: EditorState | null): LexicalNode;
-export declare function $cloneNode(node: LexicalNode, editor: LexicalEditor): LexicalNode;
-export declare function idToChar(id: string | number): string;
-export declare function charToId(char: string): string;

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

@@ -1,87 +0,0 @@
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-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 _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; }
-import { $isElementNode, resetRandomKey } from 'lexical';
-export function $parseSerializedNodeImpl(serializedNode, editor) {
-  var keepId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  var state = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-  var type = serializedNode.type;
-  var registeredNode = editor._nodes.get(type);
-  if (registeredNode === undefined) {
-    throw new Error("parseEditorState: type \"".concat(type, "\" not found"));
-  }
-  var nodeClass = registeredNode.klass;
-  if (serializedNode.type !== nodeClass.getType()) {
-    throw new Error("LexicalNode: Node ".concat(nodeClass.name, " does not implement .importJSON()."));
-  }
-  if (keepId && serializedNode.id) {
-    resetRandomKey(Number(serializedNode.id));
-  }
-  var node = nodeClass.importJSON(serializedNode);
-  var children = serializedNode.children;
-  if ($isElementNode(node) && Array.isArray(children)) {
-    var childNodes = [];
-    var _iterator = _createForOfIteratorHelper(children),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var serializedJSONChildNode = _step.value;
-        var childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor, keepId, state);
-        childNodes.push(childNode);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-    node.append.apply(node, childNodes);
-  }
-  return node;
-}
-function exportNodeToJSON(node) {
-  var serializedNode = node.exportJSON();
-  var nodeClass = node.constructor;
-  if (serializedNode.type !== nodeClass.getType()) {
-    throw new Error("LexicalNode: Node ".concat(nodeClass.name, " does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type."));
-  }
-  if ($isElementNode(node)) {
-    var serializedChildren = serializedNode.children;
-    if (!Array.isArray(serializedChildren)) {
-      throw new Error("LexicalNode: Node ".concat(nodeClass.name, " is an element but .exportJSON() does not have a children array."));
-    }
-    var children = node.getChildren();
-    var _iterator2 = _createForOfIteratorHelper(children),
-      _step2;
-    try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        var child = _step2.value;
-        var serializedChildNode = exportNodeToJSON(child);
-        serializedChildren.push(serializedChildNode);
-      }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
-    }
-  }
-
-  // @ts-expect-error
-  return serializedNode;
-}
-export function $cloneNode(node, editor) {
-  var json = exportNodeToJSON(node);
-  return $parseSerializedNodeImpl(json, editor);
-}
-var maxId = 1679616; // 36^4
-var startId = 1000000; // to avoid short ids
-var step = 7211; // a prime number to reduce collisions
-var modInverse = 1394051; // modular inverse of step mod maxId
-
-export function idToChar(id) {
-  var nId = (Number(id) * step + startId) % maxId;
-  return nId.toString(36).padStart(4, '0');
-}
-export function charToId(char) {
-  var nId = parseInt(char, 36);
-  return String((nId - startId + maxId) * modInverse % maxId);
-}

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

@@ -1,12 +0,0 @@
-import type { HistoryStateEntry } from '@lexical/history';
-import { LexicalEditor } from 'lexical';
-import { IEditorKernel } from "../../../types";
-import { MarkdownShortCutService } from '../service/shortcut';
-export declare const INSERT_MARKDOWN_COMMAND: import("lexical").LexicalCommand<{
-    historyState: HistoryStateEntry | null;
-    markdown: string;
-}>;
-export declare const GET_MARKDOWN_SELECTION_COMMAND: import("lexical").LexicalCommand<{
-    onResult: (startLine: number, endLine: number) => void;
-}>;
-export declare function registerMarkdownCommand(editor: LexicalEditor, kernel: IEditorKernel, service: MarkdownShortCutService): () => void;

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

@@ -1,87 +0,0 @@
-import { mergeRegister } from '@lexical/utils';
-import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, HISTORY_PUSH_TAG, createCommand } from 'lexical';
-import { createDebugLogger } from "../../../utils/debug";
-import { parseMarkdownToLexical } from "../data-source/markdown/parse";
-import { $generateNodesFromSerializedNodes, $insertGeneratedNodes } from "../utils";
-var logger = createDebugLogger('plugin', 'markdown');
-export var INSERT_MARKDOWN_COMMAND = createCommand('INSERT_MARKDOWN_COMMAND');
-export var GET_MARKDOWN_SELECTION_COMMAND = createCommand('GET_MARKDOWN_SELECTION_COMMAND');
-function restoreToEntry(editor, entry) {
-  if (!entry) return;
-  editor.setEditorState(entry.editorState, {
-    tag: HISTORIC_TAG
-  });
-}
-var SPICAL_TEXT = "\uFFF0";
-var getLineNumber = function getLineNumber(content, charIndex) {
-  return content.slice(0, Math.max(0, charIndex)).split('\n').length;
-};
-export function registerMarkdownCommand(editor, kernel, service) {
-  return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, function (payload) {
-    var markdown = payload.markdown;
-    logger.debug('INSERT_MARKDOWN_COMMAND payload:', payload);
-    restoreToEntry(editor, payload.historyState);
-    setTimeout(function () {
-      editor.update(function () {
-        try {
-          // Force a new history entry so undo returns to the raw pasted text.
-          var root = parseMarkdownToLexical(markdown, service.markdownReaders);
-          var selection = $getSelection();
-          var nodes = $generateNodesFromSerializedNodes(root.children);
-          logger.debug('INSERT_MARKDOWN_COMMAND nodes:', nodes);
-          $insertGeneratedNodes(editor, nodes, selection);
-          return true;
-        } catch (error) {
-          logger.error('Failed to handle markdown paste:', error);
-        }
-      }, {
-        tag: HISTORY_PUSH_TAG
-      });
-    }, 0);
-    return false;
-  }, COMMAND_PRIORITY_HIGH // Priority
-  ), editor.registerCommand(GET_MARKDOWN_SELECTION_COMMAND, function (payload) {
-    var newEditor = kernel.cloneNodeEditor();
-    var s = kernel.getSelection();
-    if (s) {
-      var _newEditor$getLexical;
-      newEditor.setSelection(s);
-      (_newEditor$getLexical = newEditor.getLexicalEditor()) === null || _newEditor$getLexical === void 0 || _newEditor$getLexical.update(function () {
-        var sel = $getSelection();
-        if (!sel) {
-          return;
-        }
-        if ($isRangeSelection(sel)) {
-          var _sel$anchor = sel.anchor,
-            anchorKey = _sel$anchor.key,
-            anchorOffset = _sel$anchor.offset,
-            anchorType = _sel$anchor.type;
-          var _sel$focus = sel.focus,
-            focusKey = _sel$focus.key,
-            focusOffset = _sel$focus.offset,
-            focusType = _sel$focus.type;
-          var newRang = sel.clone();
-          newRang.anchor.set(anchorKey, anchorOffset, anchorType);
-          newRang.focus.set(anchorKey, anchorOffset, anchorType);
-          newRang.insertText(SPICAL_TEXT);
-          newRang.focus.set(focusKey, focusOffset, focusType);
-          newRang.anchor.set(focusKey, focusOffset, focusType);
-          newRang.insertText(SPICAL_TEXT);
-        }
-      }, {
-        onUpdate: function onUpdate() {
-          var markdownContent = newEditor.getDocument('markdown');
-          var startIndex = markdownContent.indexOf(SPICAL_TEXT);
-          var endIndex = markdownContent.lastIndexOf(SPICAL_TEXT);
-          var startLine = getLineNumber(markdownContent, startIndex);
-          var endLine = getLineNumber(markdownContent, endIndex);
-          payload.onResult(startLine, endLine);
-          logger.debug('GET_MARKDOWN_SELECTION_COMMAND markdownContent:', markdownContent);
-          logger.debug('GET_MARKDOWN_SELECTION_COMMAND startLine:', startLine, 'endLine:', endLine);
-          return markdownContent;
-        }
-      });
-    }
-    return false;
-  }, COMMAND_PRIORITY_HIGH));
-}

package/es/plugins/markdown/data-source/markdown/parse.d.ts

@@ -1,21 +0,0 @@
-import type { Html, PhrasingContent, Root, RootContent } from 'mdast';
-import type { IElementNode, INode, IRootNode, ITextNode } from "../../../../editor-kernel/inode";
-export type MarkdownReadNode = INode | ITextNode | IElementNode;
-export type MarkdownNode = Root | RootContent | PhrasingContent;
-export type MarkdownReaderFunc<K> = (node: Extract<MarkdownNode, {
-    type: K;
-}>, children: MarkdownReadNode[], index: number) => MarkdownReadNode | MarkdownReadNode[] | false;
-export type TransformerRecord = {
-    [K in MarkdownNode['type']]?: MarkdownReaderFunc<K> | Array<MarkdownReaderFunc<K>>;
-};
-export type TransfromerRecordArray = {
-    [K in MarkdownNode['type']]?: Array<MarkdownReaderFunc<K>>;
-};
-export interface IHTMLStack {
-    children: Array<MarkdownReadNode[] | MarkdownReadNode | null>;
-    index: number;
-    isEndTag: boolean;
-    node: Html;
-    tag: string;
-}
-export declare function parseMarkdownToLexical(markdown: string, markdownReaders?: TransformerRecord): IRootNode;

package/es/plugins/markdown/data-source/markdown/parse.js

@@ -1,244 +0,0 @@
-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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-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 _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 _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-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 _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 _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 _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 { preprocessMarkdownContent } from '@lobehub/ui';
-import { remark } from 'remark';
-import remarkCjkFriendly from 'remark-cjk-friendly';
-import remarkGfm from 'remark-gfm';
-import remarkMath from 'remark-math';
-import { INodeHelper } from "../../../../editor-kernel/inode/helper";
-import { logger } from "../../utils/logger";
-
-// 使用条件类型确保类型匹配
-
-var selfClosingHtmlTags = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
-var MarkdownContext = /*#__PURE__*/function () {
-  function MarkdownContext(root) {
-    _classCallCheck(this, MarkdownContext);
-    _defineProperty(this, "stack", []);
-    this.root = root;
-  }
-  _createClass(MarkdownContext, [{
-    key: "push",
-    value: function push(html) {
-      this.stack.push(html);
-    }
-  }, {
-    key: "isReadingHTML",
-    get: function get() {
-      return this.stack.length > 0;
-    }
-  }, {
-    key: "last",
-    get: function get() {
-      return this.stack.at(-1);
-    }
-  }, {
-    key: "pop",
-    value: function pop() {
-      return this.stack.pop();
-    }
-  }]);
-  return MarkdownContext;
-}();
-function convertMdastToLexical(node, index, ctx) {
-  var markdownReaders = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  switch (node.type) {
-    case 'text':
-      {
-        var textNode = INodeHelper.createTextNode(node.value);
-        return textNode;
-      }
-    default:
-      {
-        var _children = [];
-        if ('children' in node && Array.isArray(node.children)) {
-          var htmlStack = []; // 当前循环是否包含 HTML 标签
-          _children = node.children.reduce(function (ret, child, index) {
-            if (child.type === 'html') {
-              var isComment = child.value.startsWith('<!--') && child.value.endsWith('-->');
-              if (isComment) {
-                return ret;
-              }
-              var tag = child.value.replaceAll(/^<\/?|>$/g, '');
-              var isEndTag = child.value.startsWith('</');
-              if (selfClosingHtmlTags.has(tag)) {
-                // Self-closing tag
-                var reader = markdownReaders['html'];
-                if (Array.isArray(reader)) {
-                  var _iterator = _createForOfIteratorHelper(reader),
-                    _step;
-                  try {
-                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                      var element = _step.value;
-                      var inode = element(child, [], index);
-                      if (inode) {
-                        ret.push(inode);
-                        return ret;
-                      }
-                    }
-                  } catch (err) {
-                    _iterator.e(err);
-                  } finally {
-                    _iterator.f();
-                  }
-                } else if (typeof reader === 'function') {
-                  var _inode = reader(child, [], index);
-                  if (_inode) {
-                    ret.push(_inode);
-                    return ret;
-                  }
-                }
-                return ret;
-              }
-              if (isEndTag) {
-                var top = ctx.pop();
-                htmlStack.pop();
-                if ((top === null || top === void 0 ? void 0 : top.tag) !== tag) {
-                  logger.warn('HTML tag mismatch:', tag);
-                  ret.push.apply(ret, _toConsumableArray((top === null || top === void 0 ? void 0 : top.children) || []));
-                  return ret;
-                }
-                var _reader = markdownReaders['html'];
-                var _children2 = top.children.flat().filter(Boolean) || [];
-                if (Array.isArray(_reader)) {
-                  var _iterator2 = _createForOfIteratorHelper(_reader),
-                    _step2;
-                  try {
-                    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                      var _element = _step2.value;
-                      var _inode2 = _element(top.node, _children2, index);
-                      if (_inode2) {
-                        ret.push(_inode2);
-                        return ret;
-                      }
-                    }
-                  } catch (err) {
-                    _iterator2.e(err);
-                  } finally {
-                    _iterator2.f();
-                  }
-                } else if (typeof _reader === 'function') {
-                  var _inode3 = _reader(top.node, _children2, index);
-                  if (_inode3) {
-                    ret.push(_inode3);
-                    return ret;
-                  }
-                }
-                if (top) {
-                  ret.push.apply(ret, _toConsumableArray(top.children));
-                }
-                return ret;
-              }
-              var htmlStackItem = {
-                children: [],
-                index: index,
-                isEndTag: isEndTag,
-                node: child,
-                tag: tag
-              };
-              htmlStack.push(htmlStackItem);
-              ctx.push(htmlStackItem);
-              return ret;
-            }
-            if (htmlStack.length > 0) {
-              var _top = ctx.last;
-              if (_top) {
-                _top.children.push(convertMdastToLexical(child, index, ctx, markdownReaders));
-              }
-              return ret;
-            }
-            ret.push(convertMdastToLexical(child, index, ctx, markdownReaders));
-            return ret;
-          }, []).filter(Boolean).flat();
-          while (htmlStack.length > 0) {
-            var _children3;
-            var tag = htmlStack.shift();
-            ctx.pop();
-            // @ts-expect-error not error
-            (_children3 = _children).push.apply(_children3, [INodeHelper.createTextNode(tag === null || tag === void 0 ? void 0 : tag.node.value)].concat(_toConsumableArray(tag.children.flat())));
-            _children = _children.flat();
-          }
-        }
-        if (markdownReaders[node.type]) {
-          var reader = markdownReaders[node.type];
-          if (Array.isArray(reader)) {
-            var _iterator3 = _createForOfIteratorHelper(reader),
-              _step3;
-            try {
-              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                var element = _step3.value;
-                var inode = element(node, _children, index);
-                if (inode) {
-                  return inode;
-                }
-              }
-            } catch (err) {
-              _iterator3.e(err);
-            } finally {
-              _iterator3.f();
-            }
-          } else if (typeof reader === 'function') {
-            var _inode4 = reader(node, _children, index);
-            if (_inode4) {
-              return _inode4;
-            }
-          }
-        }
-
-        // Fallback for unsupported nodes
-        return _children || null;
-      }
-  }
-}
-function registerDefaultReaders(markdownReaders) {
-  if (!markdownReaders['root']) {
-    markdownReaders['root'] = function (node, children) {
-      return _objectSpread(_objectSpread({}, INodeHelper.createRootNode()), {}, {
-        children: children
-      });
-    };
-  }
-  if (!markdownReaders['paragraph']) {
-    markdownReaders['paragraph'] = function (node, children) {
-      return _objectSpread(_objectSpread({}, INodeHelper.createParagraph()), {}, {
-        children: children
-      });
-    };
-  }
-  if (!markdownReaders['heading']) {
-    markdownReaders['heading'] = function (node, children) {
-      var headingType = "h".concat(Math.min(Math.max(node.depth, 1), 6));
-      return INodeHelper.createElementNode('heading', {
-        children: children,
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        tag: headingType
-      });
-    };
-  }
-}
-export function parseMarkdownToLexical(markdown) {
-  var markdownReaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var ast = remark().use(remarkCjkFriendly).use(remarkMath).use([[remarkGfm, {
-    singleTilde: false
-  }]]).parse(preprocessMarkdownContent(markdown));
-  logger.debug('Parsed MDAST:', ast);
-  var ctx = new MarkdownContext(ast);
-  registerDefaultReaders(markdownReaders);
-  return convertMdastToLexical(ast, 0, ctx, markdownReaders);
-}

package/es/plugins/markdown/data-source/markdown/supersub.d.ts

@@ -1 +0,0 @@
-export default function remarkSupersub(): void;