@lobehub/editor 4.4.0 → 4.6.0

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

@@ -1,312 +0,0 @@
-var _class;
-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 _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 { $isCodeNode } from '@lexical/code';
-import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, HISTORIC_TAG, KEY_ENTER_COMMAND, PASTE_COMMAND } from 'lexical';
-import { KernelPlugin } from "../../../editor-kernel/plugin";
-import { createDebugLogger } from "../../../utils/debug";
-import { registerMarkdownCommand } from "../command";
-import MarkdownDataSource from "../data-source/markdown-data-source";
-import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
-import { canContainTransformableMarkdown } from "../utils";
-import { detectCodeLanguage, detectLanguage } from "../utils/detectLanguage";
-export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
-  _inherits(MarkdownPlugin, _KernelPlugin);
-  var _super = _createSuper(MarkdownPlugin);
-  function MarkdownPlugin(kernel, config) {
-    var _this;
-    _classCallCheck(this, MarkdownPlugin);
-    _this = _super.call(this);
-    _defineProperty(_assertThisInitialized(_this), "logger", createDebugLogger('plugin', 'markdown'));
-    _defineProperty(_assertThisInitialized(_this), "service", void 0);
-    _this.kernel = kernel;
-    _this.config = config;
-    _this.service = new MarkdownShortCutService(kernel);
-    kernel.registerService(IMarkdownShortCutService, _this.service);
-    kernel.registerDataSource(new MarkdownDataSource('markdown', _this.service, function (serviceId) {
-      return kernel.requireService(serviceId);
-    }));
-    return _this;
-  }
-  _createClass(MarkdownPlugin, [{
-    key: "onInit",
-    value: function onInit(editor) {
-      var _this2 = this;
-      this.register(editor.registerUpdateListener(function (_ref) {
-        var tags = _ref.tags,
-          dirtyLeaves = _ref.dirtyLeaves,
-          editorState = _ref.editorState,
-          prevEditorState = _ref.prevEditorState;
-        // Ignore updates from collaboration and undo/redo (as changes already calculated)
-        if (tags.has(COLLABORATION_TAG) || tags.has(HISTORIC_TAG)) {
-          return;
-        }
-
-        // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
-        if (editor.isComposing()) {
-          return;
-        }
-        var selection = editorState.read($getSelection);
-        var prevSelection = prevEditorState.read($getSelection);
-
-        // We expect selection to be a collapsed range and not match previous one (as we want
-        // to trigger transforms only as user types)
-        if (!$isRangeSelection(prevSelection) || !$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) {
-          return;
-        }
-        var anchorKey = selection.anchor.key;
-        var anchorOffset = selection.anchor.offset;
-        var anchorNode = editorState._nodeMap.get(anchorKey);
-        if (!$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
-          return;
-        }
-        editor.update(function () {
-          if (!canContainTransformableMarkdown(anchorNode)) {
-            return;
-          }
-          var parentNode = anchorNode.getParent();
-          if (parentNode === null || $isCodeNode(parentNode)) {
-            return;
-          }
-          _this2.service.runTransformers(parentNode, anchorNode, selection.anchor.offset);
-        });
-      }));
-      this.register(editor.registerCommand(KEY_ENTER_COMMAND, function (payload) {
-        var ret = editor.getEditorState().read(function () {
-          var selection = $getSelection();
-          if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
-            return false;
-          }
-          var anchorKey = selection.anchor.key;
-          var anchorNode = $getNodeByKey(anchorKey);
-          if (!anchorNode) return false;
-          return {
-            anchorNode: anchorNode,
-            offset: selection.anchor.offset
-          };
-        });
-        if (!ret) return false;
-        var anchorNode = ret.anchorNode,
-          offset = ret.offset;
-        if (!canContainTransformableMarkdown(anchorNode)) {
-          return false;
-        }
-        var parentNode = anchorNode.getParent();
-        if (parentNode === null || $isCodeNode(parentNode)) {
-          return false;
-        }
-        if (_this2.service.testTransformers(parentNode, anchorNode, offset, 'enter')) {
-          queueMicrotask(function () {
-            editor.update(function () {
-              _this2.service.runTransformers(parentNode, anchorNode, offset, 'enter');
-            });
-          });
-          payload === null || payload === void 0 || payload.stopPropagation();
-          payload === null || payload === void 0 || payload.stopImmediatePropagation();
-          payload === null || payload === void 0 || payload.preventDefault();
-          return true;
-        }
-        return false;
-      }, COMMAND_PRIORITY_CRITICAL));
-      this.register(editor.registerCommand(PASTE_COMMAND, function (event) {
-        if (!(event instanceof ClipboardEvent)) return false;
-        var clipboardData = event.clipboardData;
-        if (!clipboardData) return false;
-
-        // Get clipboard content and clean BOM/zero-width characters
-        var rawText = clipboardData.getData('text/plain').trimEnd();
-        // Remove BOM, zero-width spaces, and other invisible characters
-        var text = rawText.replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, '');
-        var html = clipboardData.getData('text/html').trimEnd();
-
-        // If there's no text content, let Lexical handle it
-        if (!text) return false;
-        _this2.logger.debug('paste content analysis:', {
-          clipboardTypes: Array.from(clipboardData.types || []),
-          hasHTML: !!(html && html.trim()),
-          htmlLength: (html === null || html === void 0 ? void 0 : html.length) || 0,
-          textLength: text.length
-        });
-
-        // Check if the pasted plain text contains markdown patterns
-        var hasMarkdownContent = _this2.detectMarkdownContent(text);
-        if (hasMarkdownContent) {
-          // Markdown detected - show confirmation dialog
-          _this2.logger.debug('markdown patterns detected:', _this2.getMarkdownPatterns(text));
-          var historyState = _this2.kernel.getHistoryState().current;
-          setTimeout(function () {
-            _this2.kernel.emit('markdownParse', {
-              cacheState: editor.getEditorState(),
-              historyState: historyState,
-              markdown: text
-            });
-          }, 10);
-        } else {
-          // No markdown detected - plain text is already inserted
-          _this2.logger.debug('no markdown patterns detected, keeping as plain text');
-        }
-        return false;
-      }, COMMAND_PRIORITY_CRITICAL));
-      this.register(registerMarkdownCommand(editor, this.kernel, this.service, this.kernel.getHistoryState()));
-    }
-
-    /**
-     * Detect if content is code and should be inserted as code block
-     * Uses advanced language detection with pattern matching
-     * Excludes markdown as it should be handled by markdown formatting dialog
-     */
-  }, {
-    key: "detectCodeContent",
-    value: function detectCodeContent(text) {
-      // Use the advanced language detector
-      var detected = detectLanguage(text);
-      if (detected && detected.confidence > 50) {
-        // Don't insert markdown as code block - it should trigger the formatting dialog
-        if (detected.language === 'markdown') {
-          return null;
-        }
-        this.logger.debug('language detected:', detected);
-        return detected;
-      }
-
-      // Fallback to fast detection for common formats
-      var fastDetected = detectCodeLanguage(text);
-      if (fastDetected) {
-        // Don't insert markdown as code block
-        if (fastDetected === 'markdown') {
-          return null;
-        }
-        return {
-          confidence: 80,
-          language: fastDetected
-        };
-      }
-      return null;
-    }
-
-    /**
-     * Detect if text contains markdown patterns
-     * Returns false if content is likely code (will be handled by detectCodeContent)
-     */
-  }, {
-    key: "detectMarkdownContent",
-    value: function detectMarkdownContent(text) {
-      // If code is detected, don't treat as markdown
-      if (this.detectCodeContent(text)) {
-        return false;
-      }
-      var markdownPatterns = [
-      // Headers
-      /^#{1,6}\s+/m,
-      // Bold/italic
-      /\*{1,2}[^*]+\*{1,2}/, /__?[^_]+__?/,
-      // Code blocks
-      /```[\S\s]*```/,
-      // Inline code
-      /`[^`]+`/,
-      // Links
-      /\[[^\]]*]\([^)]+\)/,
-      // Images
-      /!\[[^\]]*]\([^)]+\)/,
-      // Lists
-      /^[*+-]\s+/m, /^\d+\.\s+/m,
-      // Blockquotes
-      /^>\s+/m,
-      // Tables
-      /\|.*\|.*\|/,
-      // Horizontal rules
-      /^---+$/m, /^\*\*\*+$/m,
-      // Strikethrough
-      /~~[^~]+~~/];
-      return markdownPatterns.some(function (pattern) {
-        return pattern.test(text);
-      });
-    }
-
-    /**
-     * Get specific markdown patterns found in text
-     */
-  }, {
-    key: "getMarkdownPatterns",
-    value: function getMarkdownPatterns(text) {
-      var patterns = [{
-        name: 'headers',
-        regex: /^#{1,6}\s+/m
-      }, {
-        name: 'bold',
-        regex: /\*{2}[^*]+\*{2}/
-      }, {
-        name: 'italic',
-        regex: /\*[^*]+\*/
-      }, {
-        name: 'code-blocks',
-        regex: /```[\S\s]*```/
-      }, {
-        name: 'inline-code',
-        regex: /`[^`]+`/
-      }, {
-        name: 'links',
-        regex: /\[[^\]]*]\([^)]+\)/
-      }, {
-        name: 'images',
-        regex: /!\[[^\]]*]\([^)]+\)/
-      }, {
-        name: 'lists',
-        regex: /^[*+-]\s+/m
-      }, {
-        name: 'ordered-lists',
-        regex: /^\d+\.\s+/m
-      }, {
-        name: 'blockquotes',
-        regex: /^>\s+/m
-      }, {
-        name: 'tables',
-        regex: /\|.*\|.*\|/
-      }, {
-        name: 'horizontal-rules',
-        regex: /^---+$/m
-      }, {
-        name: 'strikethrough',
-        regex: /~~[^~]+~~/
-      }];
-      return patterns.filter(function (_ref2) {
-        var regex = _ref2.regex;
-        return regex.test(text);
-      }).map(function (_ref3) {
-        var name = _ref3.name;
-        return name;
-      });
-    }
-
-    // /**
-    //  * Handle markdown paste by parsing and inserting as structured content
-    //  */
-    // private handleMarkdownPaste(editor: LexicalEditor, text: string): boolean {
-    //   try {
-    //     // Use the markdown data source to parse the content
-    //     const root = parseMarkdownToLexical(text, this.service.markdownReaders);
-    //     const selection = $getSelection();
-    //     const nodes = $generateNodesFromSerializedNodes(root.children);
-    //     $insertGeneratedNodes(editor, nodes, selection!);
-    //     return true;
-    //   } catch (error) {
-    //     this.logger.error('Failed to handle markdown paste:', error);
-    //   }
-
-    //   return false;
-    // }
-  }]);
-  return MarkdownPlugin;
-}(KernelPlugin), _defineProperty(_class, "pluginName", 'MarkdownPlugin'), _class);

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

@@ -1,3 +0,0 @@
-import { type FC } from 'react';
-declare const ReactMarkdownPlugin: FC<void>;
-export default ReactMarkdownPlugin;

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

@@ -1,72 +0,0 @@
-'use client';
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-import { Button } from '@lobehub/ui';
-import { Space, notification } from 'antd';
-import { useLayoutEffect } from 'react';
-import { useLexicalComposerContext } from "../../../editor-kernel/react";
-import { useTranslation } from "../../../editor-kernel/react/useTranslation";
-import { INodePlugin } from "../../inode";
-import { INSERT_MARKDOWN_COMMAND } from "../command";
-import { MarkdownPlugin } from "../plugin";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
-var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  var _notification$useNoti = notification.useNotification(),
-    _notification$useNoti2 = _slicedToArray(_notification$useNoti, 2),
-    api = _notification$useNoti2[0],
-    contextHolder = _notification$useNoti2[1];
-  var t = useTranslation();
-  useLayoutEffect(function () {
-    editor.registerPlugin(INodePlugin);
-    editor.registerPlugin(MarkdownPlugin);
-    var handleEvent = function handleEvent(_ref) {
-      var markdown = _ref.markdown,
-        historyState = _ref.historyState;
-      var key = "open".concat(Date.now());
-      var actions = /*#__PURE__*/_jsxs(Space, {
-        children: [/*#__PURE__*/_jsx(Button, {
-          onClick: function onClick() {
-            return api.destroy();
-          },
-          size: "small",
-          children: t('markdown.cancel')
-        }), /*#__PURE__*/_jsx(Button, {
-          onClick: function onClick() {
-            editor.dispatchCommand(INSERT_MARKDOWN_COMMAND, {
-              historyState: historyState,
-              markdown: markdown
-            });
-            api.destroy();
-          },
-          size: "small",
-          type: "primary",
-          children: t('markdown.confirm')
-        })]
-      });
-      api.open({
-        actions: actions,
-        description: t('markdown.parseMessage'),
-        duration: 5,
-        key: key,
-        message: t('markdown.parseTitle'),
-        showProgress: true
-      });
-    };
-    editor.on('markdownParse', handleEvent);
-    return function () {
-      editor.off('markdownParse', handleEvent);
-    };
-  }, [editor]);
-  return contextHolder;
-};
-ReactMarkdownPlugin.displayName = 'ReactMarkdownPlugin';
-export default ReactMarkdownPlugin;

package/es/plugins/markdown/service/shortcut.d.ts

@@ -1,90 +0,0 @@
-import { BaseSelection, ElementNode, LexicalEditor, LexicalNode, TextNode } from 'lexical';
-import { IRootNode } from "../../../editor-kernel/inode";
-import type { IEditorKernel, IServiceID } from "../../../types/kernel";
-import { type MarkdownReaderFunc, type TransformerRecord, type TransfromerRecordArray } from '../data-source/markdown/parse';
-import type { Transformer } from './transformers';
-export interface IMarkdownWriterContext {
-    /**
-     * Add processor
-     * @param processor
-     */
-    addProcessor(processor: (before: string, content: string, after: string) => string): void;
-    /**
-     * Direct output
-     * @param line
-     * @returns
-     */
-    appendLine: (line: string) => void;
-    /**
-     * Control child node to markdown
-     * @param parentCtx
-     * @param child
-     * @returns
-     */
-    processChild: (parentCtx: IMarkdownWriterContext, child: LexicalNode) => void;
-    /**
-     * Wrap child elements
-     * @param before
-     * @param after
-     * @returns
-     */
-    wrap: (before: string, after: string) => void;
-}
-export declare const MARKDOWN_WRITER_LEVEL_MAX = 0;
-export declare const MARKDOWN_READER_LEVEL_HIGH = 1;
-export declare const MARKDOWN_READER_LEVEL_NORMAL = 2;
-export type MARKDOWN_READER_LEVEL = typeof MARKDOWN_READER_LEVEL_HIGH | typeof MARKDOWN_READER_LEVEL_NORMAL | typeof MARKDOWN_WRITER_LEVEL_MAX;
-export interface IMarkdownShortCutService {
-    insertIRootNode(editor: LexicalEditor, root: IRootNode, selection: BaseSelection): void;
-    parseMarkdownToLexical(markdown: string): IRootNode;
-    /**
-     * Register Markdown reader
-     */
-    registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
-    registerMarkdownShortCut(transformer: Transformer): void;
-    registerMarkdownShortCuts(transformers: Transformer[]): void;
-    /**
-     * Register Markdown writer
-     * @param type Lexical Node type
-     * @param writer
-     */
-    registerMarkdownWriter(type: string, writer: (ctx: IMarkdownWriterContext, node: LexicalNode) => void | boolean): void;
-}
-export declare const IMarkdownShortCutService: IServiceID<IMarkdownShortCutService>;
-export declare class MarkdownShortCutService implements IMarkdownShortCutService {
-    private kernel?;
-    private elementTransformers;
-    private textFormatTransformers;
-    private textMatchTransformers;
-    private logger;
-    private _markdownWriters;
-    private _markdownReaders;
-    constructor(kernel?: IEditorKernel | undefined);
-    get markdownWriters(): Record<string, (_ctx: IMarkdownWriterContext, _node: LexicalNode) => boolean | void>;
-    get markdownReaders(): TransfromerRecordArray;
-    private _textFormatTransformersByTrigger;
-    private _textMatchTransformersByTrigger;
-    get textMatchTransformersByTrigger(): Readonly<Record<string, Readonly<{
-        getEndIndex?: ((node: TextNode, match: RegExpMatchArray) => number | false) | undefined;
-        importRegExp?: RegExp | undefined;
-        regExp: RegExp;
-        replace?: ((node: TextNode, match: RegExpMatchArray) => void | TextNode) | undefined;
-        trigger?: string | undefined;
-        type: "text-match";
-    }>[]>>;
-    get textFormatTransformersByTrigger(): Readonly<Record<string, readonly Readonly<{
-        format?: readonly import("lexical").TextFormatType[] | undefined;
-        intraword?: boolean | undefined;
-        process?: ((selection: import("lexical").RangeSelection) => boolean | void) | undefined;
-        tag: string;
-        type: "text-format";
-    }>[]>>;
-    registerMarkdownShortCut(transformer: Transformer): void;
-    registerMarkdownShortCuts(transformers: Transformer[]): void;
-    testTransformers(parentNode: ElementNode, anchorNode: TextNode, anchorOffset: number, trigger?: 'enter'): boolean;
-    runTransformers(parentNode: ElementNode, anchorNode: TextNode, anchorOffset: number, trigger?: 'enter'): boolean;
-    registerMarkdownWriter(type: string, writer: (ctx: IMarkdownWriterContext, node: LexicalNode) => boolean | void): void;
-    registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
-    parseMarkdownToLexical(markdown: string): IRootNode;
-    insertIRootNode(editor: LexicalEditor, root: IRootNode, selection: BaseSelection): void;
-}

package/es/plugins/markdown/service/shortcut.js

@@ -1,185 +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 _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 _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); }
-/* eslint-disable no-redeclare */
-/* eslint-disable @typescript-eslint/no-redeclare */
-
-import { genServiceId } from "../../../editor-kernel";
-import { createDebugLogger } from "../../../utils/debug";
-import { parseMarkdownToLexical as _parseMarkdownToLexical } from "../data-source/markdown/parse";
-import { indexBy, insertIRootNode as _insertIRootNode } from "../utils";
-import { $runTextFormatTransformers, runElementTransformers, runTextMatchTransformers, testElementTransformers } from "./transformers";
-export var MARKDOWN_WRITER_LEVEL_MAX = 0;
-export var MARKDOWN_READER_LEVEL_HIGH = 1;
-export var MARKDOWN_READER_LEVEL_NORMAL = 2;
-export var IMarkdownShortCutService = genServiceId('MarkdownShortCutService');
-export var MarkdownShortCutService = /*#__PURE__*/function () {
-  function MarkdownShortCutService(kernel) {
-    _classCallCheck(this, MarkdownShortCutService);
-    _defineProperty(this, "elementTransformers", []);
-    _defineProperty(this, "textFormatTransformers", []);
-    _defineProperty(this, "textMatchTransformers", []);
-    _defineProperty(this, "logger", createDebugLogger('service', 'markdown'));
-    _defineProperty(this, "_markdownWriters", {});
-    _defineProperty(this, "_markdownReaders", [{}, {}, {}]);
-    _defineProperty(this, "_textFormatTransformersByTrigger", null);
-    _defineProperty(this, "_textMatchTransformersByTrigger", null);
-    this.kernel = kernel;
-  }
-  _createClass(MarkdownShortCutService, [{
-    key: "markdownWriters",
-    get: function get() {
-      return this._markdownWriters;
-    }
-  }, {
-    key: "markdownReaders",
-    get: function get() {
-      return this._markdownReaders.reduce(function (acc, curr) {
-        // @ts-expect-error not error
-        Object.keys(curr).forEach(function (key) {
-          if (!acc[key]) {
-            acc[key] = [];
-          }
-          var existing = acc[key];
-          var adding = curr[key];
-          existing.push.apply(existing, _toConsumableArray(adding));
-        });
-        return acc;
-      }, {});
-    }
-  }, {
-    key: "textMatchTransformersByTrigger",
-    get: function get() {
-      if (!this._textMatchTransformersByTrigger) {
-        this._textMatchTransformersByTrigger = indexBy(this.textMatchTransformers, function (_ref) {
-          var trigger = _ref.trigger;
-          return trigger;
-        });
-      }
-      return this._textMatchTransformersByTrigger;
-    }
-  }, {
-    key: "textFormatTransformersByTrigger",
-    get: function get() {
-      if (!this._textFormatTransformersByTrigger) {
-        this._textFormatTransformersByTrigger = indexBy(this.textFormatTransformers, function (_ref2) {
-          var tag = _ref2.tag;
-          return tag.at(-1);
-        });
-      }
-      return this._textFormatTransformersByTrigger;
-    }
-  }, {
-    key: "registerMarkdownShortCut",
-    value: function registerMarkdownShortCut(transformer) {
-      switch (transformer.type) {
-        case 'element':
-          {
-            this.elementTransformers.push(transformer);
-            break;
-          }
-        case 'text-format':
-          {
-            this.textFormatTransformers.push(transformer);
-            break;
-          }
-        case 'text-match':
-          {
-            this.textMatchTransformers.push(transformer);
-            break;
-          }
-        default:
-          {
-            throw new Error("Unknown transformer type: ".concat(transformer));
-          }
-      }
-    }
-  }, {
-    key: "registerMarkdownShortCuts",
-    value: function registerMarkdownShortCuts(transformers) {
-      var _iterator = _createForOfIteratorHelper(transformers),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _transformer = _step.value;
-          this.registerMarkdownShortCut(_transformer);
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-    }
-  }, {
-    key: "testTransformers",
-    value: function testTransformers(parentNode, anchorNode, anchorOffset, trigger) {
-      if (testElementTransformers(parentNode, anchorNode, anchorOffset, this.elementTransformers, trigger)) {
-        return true;
-      }
-      return false;
-    }
-  }, {
-    key: "runTransformers",
-    value: function runTransformers(parentNode, anchorNode, anchorOffset, trigger) {
-      if (runElementTransformers(parentNode, anchorNode, anchorOffset, this.elementTransformers, trigger)) {
-        return true;
-      }
-      if (runTextMatchTransformers(anchorNode, anchorOffset, this.textMatchTransformersByTrigger)) {
-        return true;
-      }
-      if ($runTextFormatTransformers(anchorNode, anchorOffset, this.textFormatTransformersByTrigger)) {
-        return true;
-      }
-      return false;
-    }
-  }, {
-    key: "registerMarkdownWriter",
-    value: function registerMarkdownWriter(type, writer) {
-      var _this$kernel;
-      if (!this._markdownWriters[type]) {
-        this._markdownWriters[type] = writer;
-        return;
-      }
-      if ((_this$kernel = this.kernel) !== null && _this$kernel !== void 0 && _this$kernel.isHotReloadMode()) {
-        this.logger.warn("\uD83D\uDD04 Hot reload: markdown writer \"".concat(type, "\""));
-        this._markdownWriters[type] = writer;
-        return;
-      }
-      throw new Error("Markdown writer for type \"".concat(type, "\" is already registered."));
-    }
-  }, {
-    key: "registerMarkdownReader",
-    value: function registerMarkdownReader(type, reader) {
-      var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MARKDOWN_READER_LEVEL_NORMAL;
-      if (!this._markdownReaders[level][type]) {
-        this._markdownReaders[level][type] = [];
-      }
-      if (this._markdownReaders[level]) {
-        var _this$_markdownReader;
-        (_this$_markdownReader = this._markdownReaders[level][type]) === null || _this$_markdownReader === void 0 || _this$_markdownReader.push(reader);
-      }
-    }
-  }, {
-    key: "parseMarkdownToLexical",
-    value: function parseMarkdownToLexical(markdown) {
-      return _parseMarkdownToLexical(markdown, this.markdownReaders);
-    }
-  }, {
-    key: "insertIRootNode",
-    value: function insertIRootNode(editor, root, selection) {
-      _insertIRootNode(editor, root, selection);
-    }
-  }]);
-  return MarkdownShortCutService;
-}();