@ant-design/agentic-ui 2.30.25 → 2.30.27

package/dist/MarkdownEditor/editor/plugins/withSanitizeInvalidChildren.js

@@ -136,12 +136,23 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-import { Editor, Node, Transforms } from "slate";
+import { Editor, Element, Node, Text, Transforms } from "slate";
 import { HistoryEditor } from "slate-history";
 import { EditorUtils } from "../utils/editorUtils";
 var isValidChild = function isValidChild(child) {
     return child !== undefined && child !== null && Node.isNode(child);
 };
+/**
+ * `Array.prototype.some` skips sparse holes; Slate still sees missing indices and
+ * can pass `undefined` as `leaf` into `renderLeaf`, which then throws in `Text.isText`.
+ */ var childArrayHasInvalidEntries = function childArrayHasInvalidEntries(rawChildren) {
+    for(var i = 0; i < rawChildren.length; i += 1){
+        if (!(i in rawChildren) || !isValidChild(rawChildren[i])) {
+            return true;
+        }
+    }
+    return false;
+};
 var getChildList = function getChildList(node) {
     if (!('children' in node)) {
         return [];
@@ -186,12 +197,29 @@ var runWithoutHistory = function runWithoutHistory(editor, fn) {
  * Slate 的 `Node.nodes` / `Editor.normalize` 在遍历时假定非文本节点必有数组型 `children`。
  * 若仅有 `type` 而缺少 `children`，会在进入自定义 `normalizeNode` 之前就抛错，必须先修树。
  */ var rebuildOrDefaultBlock = function rebuildOrDefaultBlock(raw) {
-    if (raw && (typeof raw === "undefined" ? "undefined" : _type_of(raw)) === 'object' && //@ts-ignore
-    !(Node === null || Node === void 0 ? void 0 : Node.isText(raw)) && typeof raw.type === 'string') {
+    if (raw && (typeof raw === "undefined" ? "undefined" : _type_of(raw)) === 'object' && !Text.isText(raw) && typeof raw.type === 'string') {
         return rebuildElement(raw);
     }
     return createDefaultBlock();
 };
+/** 压缩根级子节点：去掉空洞与 null/undefined；残缺元素对象则 rebuild，不凭空多插空段落。 */ var compactEditorRootChildren = function compactEditorRootChildren(raw) {
+    var out = [];
+    for(var i = 0; i < raw.length; i += 1){
+        if (!(i in raw)) {
+            continue;
+        }
+        var c = raw[i];
+        if (isValidChild(c)) {
+            out.push(c);
+            continue;
+        }
+        if (c === undefined || c === null) {
+            continue;
+        }
+        out.push(rebuildOrDefaultBlock(c));
+    }
+    return out;
+};
 var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
     if (!Array.isArray(editor.children)) {
         /* eslint-disable no-param-reassign */ editor.children = [
@@ -205,20 +233,26 @@ var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
         ]);
         return true;
     }
-    for(var i = 0; i < editor.children.length; i++){
-        var child = editor.children[i];
-        if (!isValidChild(child)) {
-            /* eslint-disable no-param-reassign */ editor.children[i] = rebuildOrDefaultBlock(child);
-            /* eslint-enable no-param-reassign */ return true;
-        }
+    if (childArrayHasInvalidEntries(editor.children)) {
+        var fixedRoot = compactEditorRootChildren(editor.children);
+        if (fixedRoot.length === 0) {
+            EditorUtils.replaceEditorContent(editor, [
+                createDefaultBlock()
+            ]);
+        } else {
+            /* eslint-disable no-param-reassign */ editor.children = fixedRoot;
+        /* eslint-enable no-param-reassign */ }
+        return true;
     }
     var fixBranch = function fixBranch1(node) {
-        var _Node_isText;
         if (!node || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== 'object') {
             return false;
         }
-        //@ts-ignore
-        if (Node === null || Node === void 0 ? void 0 : (_Node_isText = Node.isText) === null || _Node_isText === void 0 ? void 0 : _Node_isText.call(Node, node)) {
+        if (Text.isText(node)) {
+            if ('children' in node) {
+                delete node.children;
+                return true;
+            }
             return false;
         }
         var rawChildren = node.children;
@@ -226,9 +260,7 @@ var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
             Object.assign(node, rebuildElement(node));
             return true;
         }
-        if (rawChildren === null || rawChildren === void 0 ? void 0 : rawChildren.some(function(c) {
-            return !isValidChild(c);
-        })) {
+        if (childArrayHasInvalidEntries(rawChildren)) {
             var fixedChildren = rawChildren.filter(isValidChild);
             node.children = fixedChildren.length === 0 ? [
                 {
@@ -244,8 +276,8 @@ var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
         }
         return false;
     };
-    for(var i1 = 0; i1 < editor.children.length; i1++){
-        if (fixBranch(editor.children[i1])) {
+    for(var i = 0; i < editor.children.length; i++){
+        if (fixBranch(editor.children[i])) {
             return true;
         }
     }
@@ -258,41 +290,54 @@ var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
  */ export var withSanitizeInvalidChildren = function withSanitizeInvalidChildren(editor) {
     var normalizeNode = editor.normalizeNode, normalize = editor.normalize;
     editor.normalize = function(options) {
-        var guard = 0;
-        while(guard < 100 && repairBrokenChildArrays(editor)){
-            guard += 1;
+        // 与 Slate 默认 `normalize` 一致：在 `withoutNormalizing` 嵌套批次末尾仍会调用
+        // `Editor.normalize`，此时 `isNormalizing` 为 false，文档可能短暂为空（合法中间态）。
+        // 若在此处 `repairBrokenChildArrays` 强行插入默认块，会与后续 `insertNodes` 叠成双段落。
+        if (Editor.isNormalizing(editor)) {
+            var guard = 0;
+            while(guard < 100 && repairBrokenChildArrays(editor)){
+                guard += 1;
+            }
         }
         return normalize.call(editor, options);
     };
     editor.normalizeNode = function(entry) {
-        var _Node_isText;
         var _entry = _sliced_to_array(entry, 2), node = _entry[0], path = _entry[1];
-        // `Node.isNode` is true for text leaves, but they have no `children`; never call `.some` on them.
-        //@ts-ignore
-        if (Node === null || Node === void 0 ? void 0 : (_Node_isText = Node.isText) === null || _Node_isText === void 0 ? void 0 : _Node_isText.call(Node, node)) {
+        // Text leaves have no `children`; also strip invalid `children` on text (Slate may treat as element).
+        if (Text.isText(node)) {
+            if ('children' in node) {
+                delete node.children;
+            }
             normalizeNode(entry);
             return;
         }
         if (Editor.isEditor(node) && path.length === 0) {
             var childList = getChildList(node);
-            var hasInvalid = childList.some(function(c) {
-                return !isValidChild(c);
-            });
+            var hasInvalid = childArrayHasInvalidEntries(childList);
             if (hasInvalid || childList.length === 0) {
-                var nextNodes = childList.length === 0 ? [
+                var fixedTop = compactEditorRootChildren(childList);
+                var nextNodes = fixedTop.length === 0 ? [
                     createDefaultBlock()
-                ] : childList.map(function(c) {
-                    return isValidChild(c) ? c : rebuildOrDefaultBlock(c);
-                });
+                ] : fixedTop;
                 EditorUtils.replaceEditorContent(editor, nextNodes);
                 normalizeNode(entry);
                 return;
             }
+            // 清空后 Slate 规范化可能再插一个空段，根上出现多个仅空文本的 paragraph；
+            // 与 replaceEditorContent 已插入的一块叠成双 DOM（见 debug H6）。
+            var validTop = childList.filter(isValidChild);
+            if (validTop.length > 1) {
+                var collapsed = EditorUtils.coalesceRootAllEmptyParagraphs(validTop);
+                if (collapsed.length < validTop.length) {
+                    EditorUtils.replaceEditorContent(editor, collapsed);
+                    normalizeNode(entry);
+                    return;
+                }
+            }
             normalizeNode(entry);
             return;
         }
-        //@ts-ignore
-        if (!Editor.isEditor(node) && !Node.isText(node)) {
+        if (!Editor.isEditor(node) && !Text.isText(node)) {
             var rawChildren = node.children;
             if (!Array.isArray(rawChildren)) {
                 Object.assign(node, rebuildElement(node));
@@ -300,12 +345,9 @@ var repairBrokenChildArrays = function repairBrokenChildArrays(editor) {
                 return;
             }
         }
-        //@ts-ignore
-        if (Node.isElement(node)) {
+        if (Element.isElement(node)) {
             var childList1 = getChildList(node);
-            var hasInvalid1 = childList1.some(function(c) {
-                return !isValidChild(c);
-            });
+            var hasInvalid1 = childArrayHasInvalidEntries(childList1);
             if (hasInvalid1) {
                 var applyRebuild = function applyRebuild() {
                     Editor.withoutNormalizing(editor, function() {

package/dist/MarkdownEditor/editor/store.js

@@ -436,6 +436,7 @@ export var EditorStoreContext = createContext(null);
                 var _ref, _ref1, _ref2, _ref3;
                 if (md === undefined) return;
                 if (!md) {
+                    if (this._shouldSkipSetContent('')) return;
                     this.clearContent();
                     return;
                 }

package/dist/MarkdownEditor/editor/tools/InsertAutocomplete.js

@@ -994,6 +994,7 @@ export var InsertAutocomplete = function InsertAutocomplete(props) {
             e.preventDefault();
         }
     }, !state.insertLink && !state.insertAttachment && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(Menu, {
+        _internalDisableMenuItemTitleTooltip: true,
         items: (_props_optionsRender = props.optionsRender) === null || _props_optionsRender === void 0 ? void 0 : _props_optionsRender.call(props, state.filterOptions.map(function(l) {
             var _l_label, _l_children_, _l_children, _l_children1;
             return {

package/dist/MarkdownEditor/editor/utils/editorUtils.d.ts

@@ -11,6 +11,12 @@ export declare class EditorUtils {
             readonly text: "";
         }];
     };
+    /**
+     * 当根节点全部为「仅空白」的段落时，合并为单个空段。
+     * 避免解析 `\\n\\n` 或外部 schema 产生多个空段，导致 Slate/占位与双 DOM。
+     * 仅一个根块时原样返回，以保留单空段上的 align 等段落级字段。
+     */
+    static coalesceRootAllEmptyParagraphs(nodes: Node[]): Node[];
     /**
      * 通过 Slate Transforms API 安全替换编辑器全部内容。
      * 避免直接赋值 editor.children，确保 Operation/History/Normalizer 管线正常运行。

package/dist/MarkdownEditor/editor/utils/editorUtils.js

@@ -157,6 +157,32 @@ export var EditorUtils = /*#__PURE__*/ function() {
                 };
             }
         },
+        {
+            key: "coalesceRootAllEmptyParagraphs",
+            value: /**
+   * 当根节点全部为「仅空白」的段落时，合并为单个空段。
+   * 避免解析 `\\n\\n` 或外部 schema 产生多个空段，导致 Slate/占位与双 DOM。
+   * 仅一个根块时原样返回，以保留单空段上的 align 等段落级字段。
+   */ function coalesceRootAllEmptyParagraphs(nodes) {
+                if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length)) {
+                    return [
+                        JSON.parse(JSON.stringify(EditorUtils.p))
+                    ];
+                }
+                if (nodes.length === 1) {
+                    return nodes;
+                }
+                var onlyEmptyParagraphs = nodes.every(function(n) {
+                    return Element.isElement(n) && n.type === 'paragraph' && Node.string(n).trim() === '';
+                });
+                if (onlyEmptyParagraphs) {
+                    return [
+                        JSON.parse(JSON.stringify(EditorUtils.p))
+                    ];
+                }
+                return nodes;
+            }
+        },
         {
             key: "replaceEditorContent",
             value: /**
@@ -169,6 +195,7 @@ export var EditorUtils = /*#__PURE__*/ function() {
    */ function replaceEditorContent(editor, nodes, options) {
                 var _ref = options || {}, _ref_withoutHistory = _ref.withoutHistory, withoutHistory = _ref_withoutHistory === void 0 ? true : _ref_withoutHistory;
                 var doReplace = function doReplace() {
+                    var normalized = EditorUtils.coalesceRootAllEmptyParagraphs(nodes);
                     Editor.withoutNormalizing(editor, function() {
                         if (editor.selection) {
                             Transforms.deselect(editor);
@@ -181,7 +208,7 @@ export var EditorUtils = /*#__PURE__*/ function() {
                                 ]
                             });
                         }
-                        Transforms.insertNodes(editor, nodes, {
+                        Transforms.insertNodes(editor, normalized, {
                             at: [
                                 0
                             ]

package/dist/MarkdownEditor/style.js

@@ -580,12 +580,6 @@ var genStyle = function genStyle(token) {
                     fill: '#fff'
                 }
             },
-            // 强制设置所有文字样式
-            '& text': {
-                // 确保文字不会被裁剪
-                dominantBaseline: 'middle',
-                textAnchor: 'middle'
-            },
             // 节点标签 - 更大的字体
             '& .nodeLabel': {
                 fontWeight: 500,

package/dist/MarkdownInputField/hooks/useMarkdownInputFieldRefs.js

@@ -94,9 +94,6 @@ import { ReactEditor } from "slate-react";
             // ReactEditor.isFocused can throw if the editor is being torn down
             }
         }
-        if (props.value === undefined || props.value === '') {
-            return;
-        }
         (_markdownEditorRef_current1 = markdownEditorRef.current) === null || _markdownEditorRef_current1 === void 0 ? void 0 : (_markdownEditorRef_current_store = _markdownEditorRef_current1.store) === null || _markdownEditorRef_current_store === void 0 ? void 0 : _markdownEditorRef_current_store.setMDContent((_props_value = props.value) !== null && _props_value !== void 0 ? _props_value : '');
     }, [
         props.value

package/dist/MarkdownRenderer/MarkdownRenderer.js

@@ -138,15 +138,15 @@ import React, { forwardRef, useContext, useEffect, useImperativeHandle, useMemo,
 import { useStyle as useContentStyle } from "../MarkdownEditor/editor/style";
 import { useStyle as useEditorStyle } from "../MarkdownEditor/style";
 import { CharacterQueue } from "./CharacterQueue";
+import { extractFootnoteDefinitionsFromMarkdown } from "./extractFootnoteDefinitions";
+import { AgenticUiFileMapBlockRenderer } from "./renderers/AgenticUiFileMapBlockRenderer";
 import { AgenticUiTaskBlockRenderer } from "./renderers/AgenticUiTaskBlockRenderer";
 import { AgenticUiToolUseBarBlockRenderer } from "./renderers/AgenticUiToolUseBarBlockRenderer";
-import { AgenticUiFileMapBlockRenderer } from "./renderers/AgenticUiFileMapBlockRenderer";
 import { ChartBlockRenderer } from "./renderers/ChartRenderer";
 import { CodeBlockRenderer } from "./renderers/CodeRenderer";
 import { MermaidBlockRenderer } from "./renderers/MermaidRenderer";
 import { SchemaBlockRenderer } from "./renderers/SchemaRenderer";
 import { useRendererVarStyle } from "./style";
-import { extractFootnoteDefinitionsFromMarkdown } from "./extractFootnoteDefinitions";
 import { useMarkdownToReact } from "./useMarkdownToReact";
 import { useStreaming } from "./useStreaming";
 var SCHEMA_LANGUAGES = new Set([

package/dist/MarkdownRenderer/index.d.ts

@@ -1,6 +1,7 @@
 export { default as AnimationText } from './AnimationText';
 export type { AnimationConfig, AnimationTextProps } from './AnimationText';
 export { CharacterQueue } from './CharacterQueue';
+export type { UseMarkdownToReactOptions } from './markdownReactShared';
 export { default as MarkdownRenderer } from './MarkdownRenderer';
 export { AgenticUiFileMapBlockRenderer } from './renderers/AgenticUiFileMapBlockRenderer';
 export { AgenticUiTaskBlockRenderer } from './renderers/AgenticUiTaskBlockRenderer';
@@ -9,8 +10,7 @@ export { ChartBlockRenderer } from './renderers/ChartRenderer';
 export { CodeBlockRenderer } from './renderers/CodeRenderer';
 export { MermaidBlockRenderer } from './renderers/MermaidRenderer';
 export { SchemaBlockRenderer } from './renderers/SchemaRenderer';
+export { useStreamingMarkdownReact } from './streaming/useStreamingMarkdownReact';
 export type { CharacterQueueOptions, FileMapConfig, MarkdownRendererEleProps, MarkdownRendererProps, MarkdownRendererRef, RenderMode, RendererBlockProps, } from './types';
-export type { UseMarkdownToReactOptions } from './markdownReactShared';
 export { markdownToReactSync, useMarkdownToReact } from './useMarkdownToReact';
-export { useStreamingMarkdownReact } from './streaming/useStreamingMarkdownReact';
 export { useStreaming } from './useStreaming';

package/dist/MarkdownRenderer/index.js

@@ -8,6 +8,6 @@ export { ChartBlockRenderer } from "./renderers/ChartRenderer";
 export { CodeBlockRenderer } from "./renderers/CodeRenderer";
 export { MermaidBlockRenderer } from "./renderers/MermaidRenderer";
 export { SchemaBlockRenderer } from "./renderers/SchemaRenderer";
-export { markdownToReactSync, useMarkdownToReact } from "./useMarkdownToReact";
 export { useStreamingMarkdownReact } from "./streaming/useStreamingMarkdownReact";
+export { markdownToReactSync, useMarkdownToReact } from "./useMarkdownToReact";
 export { useStreaming } from "./useStreaming";

package/dist/MarkdownRenderer/streaming/MarkdownBlockPiece.d.ts

@@ -1,5 +1,5 @@
-import type { Processor } from 'unified';
 import React from 'react';
+import type { Processor } from 'unified';
 export interface MarkdownBlockPieceProps {
     variant: 'sealed' | 'tail';
     blockSource: string;

package/dist/MarkdownRenderer/streaming/MarkdownBlockPiece.js

@@ -9,11 +9,24 @@ import { shouldReparseLastBlock } from "./lastBlockThrottle";
     var variant = param.variant, blockSource = param.blockSource, processor = param.processor, components = param.components, streaming = param.streaming;
     var lastParsedRef = useRef(null);
     var cacheRef = useRef(new Map());
+    var processorRef = useRef(null);
+    /**
+   * 宿主常把 `components: { __codeBlock: X }` 内联在每次 render，引用恒变。
+   * 若列入 useMemo 依赖，末块晋升为 sealed 时会误触发重 parse，子树卸载重挂。
+   * 密封命中缓存时故意不随 components 引用抖动；需重算时由 variant / blockSource / processor 驱动。
+   */ var componentsRef = useRef(components);
+    componentsRef.current = components;
     var node = useMemo(function() {
+        if (processorRef.current !== processor) {
+            processorRef.current = processor;
+            cacheRef.current.clear();
+            lastParsedRef.current = null;
+        }
+        var comps = componentsRef.current;
         var cached = cacheRef.current.get(blockSource);
         if (cached && variant === 'sealed') return cached;
         if (variant === 'sealed' || !streaming) {
-            var el = renderMarkdownBlock(blockSource, processor, components);
+            var el = renderMarkdownBlock(blockSource, processor, comps);
             cacheRef.current.set(blockSource, el);
             if (variant === 'tail') lastParsedRef.current = {
                 source: blockSource,
@@ -25,7 +38,7 @@ import { shouldReparseLastBlock } from "./lastBlockThrottle";
         if (prev && !shouldReparseLastBlock(prev.source, blockSource, true)) {
             return prev.node;
         }
-        var el1 = renderMarkdownBlock(blockSource, processor, components);
+        var el1 = renderMarkdownBlock(blockSource, processor, comps);
         cacheRef.current.set(blockSource, el1);
         lastParsedRef.current = {
             source: blockSource,
@@ -36,7 +49,6 @@ import { shouldReparseLastBlock } from "./lastBlockThrottle";
         variant,
         blockSource,
         processor,
-        components,
         streaming
     ]);
     var animateBlock = variant === 'tail' && streaming;

package/dist/MarkdownRenderer/streaming/useStreamingMarkdownReact.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { type UseMarkdownToReactOptions } from '../markdownReactShared';
 /**
- * 流式优先的 Markdown → React：每块独立 memo 组件；tail 与 sealed 共用组件类型以便块晋升时复用实例。
+ * 流式优先的 Markdown → React：每块独立 MarkdownBlockPiece，末块 tail、其余 sealed。
+ * 块 key 仅用修订代 + 下标，使「末块晋升为 sealed」时外层组件类型不变，避免子树卸载重挂。
  */
 export declare const useStreamingMarkdownReact: (content: string, options?: UseMarkdownToReactOptions) => React.ReactNode;

package/dist/MarkdownRenderer/streaming/useStreamingMarkdownReact.js

@@ -1,11 +1,12 @@
-import { JINJA_DOLLAR_PLACEHOLDER, preprocessNormalizeLeafToContainerDirective } from "../../MarkdownEditor/editor/parser/constants";
 import React, { useMemo, useRef } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { JINJA_DOLLAR_PLACEHOLDER, preprocessNormalizeLeafToContainerDirective } from "../../MarkdownEditor/editor/parser/constants";
 import { buildEditorAlignedComponents, createHastProcessor, splitMarkdownBlocks } from "../markdownReactShared";
 import { MarkdownBlockPiece } from "./MarkdownBlockPiece";
 import { shouldResetRevisionProgress } from "./revisionPolicy";
 /**
- * 流式优先的 Markdown → React：每块独立 memo 组件；tail 与 sealed 共用组件类型以便块晋升时复用实例。
+ * 流式优先的 Markdown → React：每块独立 MarkdownBlockPiece，末块 tail、其余 sealed。
+ * 块 key 仅用修订代 + 下标，使「末块晋升为 sealed」时外层组件类型不变，避免子树卸载重挂。
  */ export var useStreamingMarkdownReact = function useStreamingMarkdownReact(content, options) {
     var revisionSource = (options === null || options === void 0 ? void 0 : options.contentRevisionSource) !== undefined ? options.contentRevisionSource : content;
     var prevRevisionRef = useRef(undefined);
@@ -45,14 +46,13 @@ import { shouldResetRevisionProgress } from "./revisionPolicy";
             var gen = revisionGenerationRef.current;
             var elements = blocks.map(function(blockSource, index) {
                 var isLast = index === blocks.length - 1;
-                // 仅用修订代 + 块下标作 key，避免末块随文本增长导致 identity 变化而整段 remount
                 var key = "b-".concat(gen, "-").concat(index);
                 return jsx(MarkdownBlockPiece, {
                     variant: isLast ? 'tail' : 'sealed',
                     blockSource: blockSource,
                     processor: processor,
                     components: components,
-                    streaming: !!((options === null || options === void 0 ? void 0 : options.streaming) && isLast)
+                    streaming: !!(options === null || options === void 0 ? void 0 : options.streaming)
                 }, key);
             });
             return jsxs(Fragment, {

package/dist/Plugins/chart/BarChart/index.js

@@ -120,8 +120,8 @@ import React, { useContext, useEffect, useMemo, useRef, useState } from "react";
 import { Bar } from "react-chartjs-2";
 import { ChartContainer, ChartFilter, ChartStatistic, ChartToolBar, downloadChart } from "../components";
 import { defaultColorList } from "../const";
-import { extractAndSortXValues, findDataPointByXValue, hexToRgba, resolveCssVariable, toNumber } from "../utils";
 import { useChartTheme } from "../hooks";
+import { extractAndSortXValues, findDataPointByXValue, hexToRgba, resolveCssVariable, toNumber } from "../utils";
 import { useStyle } from "./style";
 /**
  * @fileoverview 柱状图组件文件

package/dist/Plugins/chart/ChartAttrToolBar/index.js

@@ -1,7 +1,7 @@
 import { DeleteOutlined } from "@ant-design/icons";
 import { ConfigProvider, Tooltip } from "antd";
-import React, { useContext, useRef } from "react";
 import clsx from "clsx";
+import React, { useContext, useRef } from "react";
 import { Transforms } from "slate";
 import { ReactEditor } from "slate-react";
 import { I18nContext } from "../../../I18n";

package/dist/Plugins/chart/index.d.ts

@@ -29,7 +29,7 @@ export { default as RadarChart } from './RadarChart';
 export { default as ScatterChart } from './ScatterChart';
 export type { AreaChartConfigItem, AreaChartDataItem, AreaChartProps, } from './AreaChart';
 export type { BarChartConfigItem, BarChartDataItem, BarChartProps, } from './BarChart';
-export type { BoxPlotChartDataItem, BoxPlotChartProps, } from './BoxPlotChart';
+export type { BoxPlotChartDataItem, BoxPlotChartProps } from './BoxPlotChart';
 export type { ChartStatisticClassNames, ChartStatisticProps, ChartStatisticStyles, } from './ChartStatistic';
 export type { DonutChartConfig, DonutChartData, DonutChartProps, } from './DonutChart';
 export type { FunnelChartDataItem, FunnelChartProps } from './FunnelChart';

package/dist/Plugins/code/utils/index.d.ts

@@ -4,4 +4,4 @@
  * @author Code Plugin Team
  */
 export { langOptions } from './langOptions';
-export { openHtmlLocalPreview, openMarkdownLocalPreview, } from './localPreview';
+export { openHtmlLocalPreview, openMarkdownLocalPreview } from './localPreview';