@lobehub/editor 1.29.0 → 1.30.0

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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,2 @@
+import { LexicalEditor, LexicalNode } from 'lexical';
+export declare function $parseSerializedNodeImpl(serializedNode: any, editor: LexicalEditor): LexicalNode;

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

@@ -0,0 +1,33 @@
+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 } from 'lexical';
+export function $parseSerializedNodeImpl(serializedNode, editor) {
+  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()."));
+  }
+  var node = nodeClass.importJSON(serializedNode);
+  var children = serializedNode.children;
+  if ($isElementNode(node) && Array.isArray(children)) {
+    var _iterator = _createForOfIteratorHelper(children),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var serializedJSONChildNode = _step.value;
+        var childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor);
+        node.append(childNode);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return node;
+}

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

@@ -22,6 +22,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { $createNodeSelection, $setSelection } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { createDebugLogger } from "../../../utils/debug";
 import { registerMathCommand } from "../command";
@@ -56,6 +57,45 @@ export var MathPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     value: function onInit(editor) {
       this.register(registerMathCommand(editor));
       this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(MathInlineNode.getType(), function (node, ctx) {
+        if (node instanceof MathInlineNode) {
+          var attributes = {
+            code: node.getTextContent()
+          };
+          return ctx.createXmlNode('math', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(MathBlockNode.getType(), function (node, ctx) {
+        if (node instanceof MathBlockNode) {
+          var attributes = {
+            code: node.getTextContent()
+          };
+          return ctx.createXmlNode('mathBlock', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('math', function (xmlNode) {
+        return INodeHelper.createElementNode(MathInlineNode.getType(), {
+          code: xmlNode.getAttribute('code') || '',
+          version: 1
+        });
+      });
+      litexmlService.registerXMLReader('mathBlock', function (xmlNode) {
+        return INodeHelper.createElementNode(MathBlockNode.getType(), {
+          code: xmlNode.getAttribute('code') || '',
+          version: 1
+        });
+      });
     }
   }, {
     key: "registerMarkdown",

package/es/plugins/mention/plugin/index.d.ts

@@ -6,7 +6,7 @@ import { MentionNode, SerializedMentionNode } from '../node/MentionNode';
 export interface MentionPluginOptions {
     decorator: (node: MentionNode, editor: LexicalEditor) => any;
     markdownReader?: (node: Html, children: INode[]) => SerializedMentionNode | null | false;
-    markdownWriter?: (file: MentionNode) => string;
+    markdownWriter?: (mention: MentionNode) => string;
     theme?: {
         mention?: string;
     };

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

@@ -13,7 +13,9 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 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 { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH } from "../../markdown/service/shortcut";
 import { registerMentionCommand } from "../command";
 import { $isMentionNode, MentionNode } from "../node/MentionNode";
@@ -46,14 +48,38 @@ export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       this.register(registerMentionCommand(editor));
       this.register(registerMentionNodeSelectionObserver(editor));
       this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var _this$kernel$requireS, _this$kernel$requireS2;
+      (_this$kernel$requireS = this.kernel.requireService(ILitexmlService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerXMLWriter(MentionNode.getType(), function (node, ctx) {
+        if ($isMentionNode(node)) {
+          var attributes = {
+            label: node.label
+          };
+          if (node.metadata && Object.keys(node.metadata).length > 0) {
+            attributes.metadata = JSON.stringify(node.metadata);
+          }
+          return ctx.createXmlNode('mention', attributes);
+        }
+        return false;
+      });
+      (_this$kernel$requireS2 = this.kernel.requireService(ILitexmlService)) === null || _this$kernel$requireS2 === void 0 || _this$kernel$requireS2.registerXMLReader('mention', function (xmlNode) {
+        return INodeHelper.createElementNode(MentionNode.getType(), {
+          label: xmlNode.getAttribute('label') || '',
+          metadata: xmlNode.getAttribute('metadata') ? JSON.parse(xmlNode.getAttribute('metadata')) : {}
+        });
+      });
     }
   }, {
     key: "registerMarkdown",
     value: function registerMarkdown() {
-      var _this$kernel$requireS,
+      var _this$kernel$requireS3,
         _this2 = this,
         _this$config;
-      (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownWriter(MentionNode.getType(), function (ctx, node) {
+      (_this$kernel$requireS3 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS3 === void 0 || _this$kernel$requireS3.registerMarkdownWriter(MentionNode.getType(), function (ctx, node) {
         if ($isMentionNode(node)) {
           var _this2$config;
           if ((_this2$config = _this2.config) !== null && _this2$config !== void 0 && _this2$config.markdownWriter) {
@@ -64,8 +90,8 @@ export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
       });
       if ((_this$config = this.config) !== null && _this$config !== void 0 && _this$config.markdownReader) {
-        var _this$kernel$requireS2;
-        (_this$kernel$requireS2 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS2 === void 0 || _this$kernel$requireS2.registerMarkdownReader('html', function (node, children) {
+        var _this$kernel$requireS4;
+        (_this$kernel$requireS4 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS4 === void 0 || _this$kernel$requireS4.registerMarkdownReader('html', function (node, children) {
           var _this2$config2;
           return (_this2$config2 = _this2.config) !== null && _this2$config2 !== void 0 && _this2$config2.markdownReader ? _this2.config.markdownReader(node, children) || false : false;
           // return this.config?.markdownReader ? this.config.markdownReader(node, children) || false : false;

package/es/plugins/slash/react/ReactSlashPlugin.js

@@ -9,6 +9,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { mergeRegister } from '@lexical/utils';
 import { COMMAND_PRIORITY_CRITICAL, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_DOWN_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND } from 'lexical';
 import { Children, useCallback, useLayoutEffect, useRef, useState } from 'react';
+import { noop } from "../../../editor-kernel";
 import { useLexicalEditor } from "../../../editor-kernel/react";
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
 import { SlashPlugin } from "../plugin/index";
@@ -51,7 +52,7 @@ var ReactSlashPlugin = function ReactSlashPlugin(_ref) {
     dropdownPosition = _useState12[0],
     setDropdownPosition = _useState12[1];
   var cancelRef = useRef({
-    cancel: function cancel() {}
+    cancel: noop
   });
   var triggerMapRef = useRef(new Map());
   var close = useCallback(function () {

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

@@ -17,6 +17,7 @@ import { $isTableNode, TableCellNode, TableRowNode, registerTableCellUnmergeTran
 import { cx } from 'antd-style';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerTableCommand } from "../command";
 import { TableNode, patchTableNode } from "../node";
@@ -55,6 +56,86 @@ export var TablePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       this.register(registerTableCellUnmergeTransform(editor));
       this.register(registerTableCommand(editor));
       this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(TableNode.getType(), function (node, ctx) {
+        if ($isTableNode(node)) {
+          var attributes = {};
+          var colWidths = node.getColWidths();
+          if (colWidths && colWidths.length > 0) {
+            attributes.colWidths = colWidths.join(',');
+          }
+          return ctx.createXmlNode('table', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(TableRowNode.getType(), function (node, ctx) {
+        if (node instanceof TableRowNode) {
+          return ctx.createXmlNode('tr', {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(TableCellNode.getType(), function (node, ctx) {
+        if (node instanceof TableCellNode) {
+          var attributes = {};
+          if (node.getColSpan() > 1) {
+            attributes.colSpan = node.getColSpan().toString();
+          }
+          if (node.getRowSpan() > 1) {
+            attributes.rowSpan = node.getRowSpan().toString();
+          }
+          if (node.getBackgroundColor()) {
+            attributes.backgroundColor = node.getBackgroundColor();
+          }
+          return ctx.createXmlNode('td', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('table', function (xmlNode, children) {
+        var colWidthsAttr = xmlNode.getAttribute('colWidths');
+        var colWidths = colWidthsAttr ? colWidthsAttr.split(',').map(function (width) {
+          return parseInt(width, 10);
+        }) : [];
+        return INodeHelper.createElementNode(TableNode.getType(), {
+          children: children,
+          // eslint-disable-next-line unicorn/no-new-array
+          colWidths: colWidths.length > 0 ? colWidths : [750],
+          direction: null,
+          format: '',
+          indent: 0,
+          version: 1
+        });
+      });
+      litexmlService.registerXMLReader('tr', function (_xmlNode, children) {
+        return INodeHelper.createElementNode(TableRowNode.getType(), {
+          children: children,
+          direction: 'ltr',
+          format: '',
+          height: 33,
+          indent: 0,
+          version: 1
+        });
+      });
+      litexmlService.registerXMLReader('td', function (xmlNode, children) {
+        return INodeHelper.createElementNode(TableCellNode.getType(), {
+          backgroundColor: xmlNode.getAttribute('backgroundColor') || null,
+          children: children,
+          colSpan: xmlNode.getAttribute('colSpan') ? parseInt(xmlNode.getAttribute('colSpan'), 10) : 1,
+          direction: 'ltr',
+          format: '',
+          headerState: 0,
+          indent: 0,
+          rowSpan: xmlNode.getAttribute('rowSpan') ? parseInt(xmlNode.getAttribute('rowSpan'), 10) : 1,
+          version: 1
+        });
+      });
     }
   }, {
     key: "registerMarkdown",

package/es/react/hooks/useEditorState/index.js

@@ -12,6 +12,7 @@ import { $getNearestNodeOfType, mergeRegister } from '@lexical/utils';
 import { $createNodeSelection, $getSelection, $isParagraphNode, $isRangeSelection, $setSelection, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, COMMAND_PRIORITY_LOW, FORMAT_TEXT_COMMAND, REDO_COMMAND, SELECTION_CHANGE_COMMAND, UNDO_COMMAND } from 'lexical';
 import { debounce } from 'lodash-es';
 import { useCallback, useEffect, useMemo, useState } from 'react';
+import { noop } from "../../../editor-kernel";
 import { INSERT_CODEINLINE_COMMAND } from "../../../plugins/code";
 import { $isSelectionInCodeInline } from "../../../plugins/code/node/code";
 import { UPDATE_CODEBLOCK_LANG } from "../../../plugins/codeblock";
@@ -376,7 +377,7 @@ export function useEditorState(editor) {
   useEffect(function () {
     if (!editor) return;
     var lexicalEditor = editor.getLexicalEditor();
-    var cleanup = function cleanup() {};
+    var cleanup = noop;
     var debounceUpdate = debounce(function () {
       lexicalEditor === null || lexicalEditor === void 0 || lexicalEditor.read(function () {
         $updateToolbar();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.29.0",
+  "version": "1.30.0",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -39,13 +39,14 @@
     "@lexical/selection": "^0.38.2",
     "@lexical/table": "^0.38.2",
     "@lexical/utils": "^0.38.2",
-    "@shikijs/core": "^3.15.0",
-    "@shikijs/engine-javascript": "^3.15.0",
+    "@shikijs/core": "^3.19.0",
+    "@shikijs/engine-javascript": "^3.19.0",
+    "@xmldom/xmldom": "^0.8.11",
     "ahooks": "^3.9.6",
     "antd-style": "^3.7.1",
     "debug": "^4.4.3",
     "eventemitter3": "^5.0.1",
-    "framer-motion": "^12.23.24",
+    "framer-motion": "^12.23.25",
     "fuse.js": "^7.1.0",
     "katex": "^0.16.25",
     "lexical": "^0.38.2",
@@ -54,11 +55,11 @@
     "polished": "^4.3.1",
     "re-resizable": "^6.11.2",
     "react-error-boundary": "^6.0.0",
-    "react-layout-kit": "^2.0.0",
+    "react-layout-kit": "^2.0.1",
     "react-merge-refs": "^3.0.2",
     "remark-cjk-friendly": "^1.2.3",
     "remark-supersub": "^1.0.0",
-    "shiki": "^3.15.0",
+    "shiki": "^3.19.0",
     "ts-key-enum": "^3.0.13",
     "use-merge-value": "^1.2.0"
   },