@ant-design/agentic-ui 2.30.24 → 2.30.26

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

@@ -124,6 +124,10 @@ function _object_without_properties_loose(source, excluded) {
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -132,10 +136,30 @@ 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 [];
+    }
+    var children = node.children;
+    return Array.isArray(children) ? children : [];
+};
 var createDefaultBlock = function createDefaultBlock() {
     return {
         type: 'paragraph',
@@ -147,7 +171,7 @@ var createDefaultBlock = function createDefaultBlock() {
     };
 };
 var rebuildElement = function rebuildElement(node) {
-    var children = node.children.filter(isValidChild);
+    var children = getChildList(node).filter(isValidChild);
     if (children.length === 0 && 'type' in node && node.type) {
         children = [
             {
@@ -162,52 +186,172 @@ var rebuildElement = function rebuildElement(node) {
         children: children
     });
 };
+var runWithoutHistory = function runWithoutHistory(editor, fn) {
+    if (HistoryEditor.isHistoryEditor(editor)) {
+        HistoryEditor.withoutSaving(editor, fn);
+    } else {
+        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' && !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 = [
+            createDefaultBlock()
+        ];
+        /* eslint-enable no-param-reassign */ return true;
+    }
+    if (editor.children.length === 0) {
+        EditorUtils.replaceEditorContent(editor, [
+            createDefaultBlock()
+        ]);
+        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) {
+        if (!node || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== 'object') {
+            return false;
+        }
+        if (Text.isText(node)) {
+            if ('children' in node) {
+                delete node.children;
+                return true;
+            }
+            return false;
+        }
+        var rawChildren = node.children;
+        if (!Array.isArray(rawChildren)) {
+            Object.assign(node, rebuildElement(node));
+            return true;
+        }
+        if (childArrayHasInvalidEntries(rawChildren)) {
+            var fixedChildren = rawChildren.filter(isValidChild);
+            node.children = fixedChildren.length === 0 ? [
+                {
+                    text: ''
+                }
+            ] : fixedChildren;
+            return true;
+        }
+        for(var i = 0; i < rawChildren.length; i++){
+            if (fixBranch(rawChildren[i])) {
+                return true;
+            }
+        }
+        return false;
+    };
+    for(var i = 0; i < editor.children.length; i++){
+        if (fixBranch(editor.children[i])) {
+            return true;
+        }
+    }
+    return false;
+};
 /**
  * 外部或合并后的 value 可能在 `children` 中混入 `undefined` / `null`；
  * Slate 的 `Node.string` 会对每个子节点调用 `Text.isText`，遇 `undefined` 即抛错。
  * 在 normalize 最外层剔除非法子节点，避免编辑器与 toMarkdown 崩溃。
  */ export var withSanitizeInvalidChildren = function withSanitizeInvalidChildren(editor) {
-    var normalizeNode = editor.normalizeNode;
+    var normalizeNode = editor.normalizeNode, normalize = editor.normalize;
+    editor.normalize = function(options) {
+        // 与 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 _entry = _sliced_to_array(entry, 2), node = _entry[0], path = _entry[1];
+        // 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 hasInvalid = node.children.some(function(c) {
-                return !isValidChild(c);
-            });
-            if (hasInvalid) {
-                var clean = node.children.filter(isValidChild);
-                editor.children = clean.length === 0 ? [
+            var childList = getChildList(node);
+            var hasInvalid = childArrayHasInvalidEntries(childList);
+            if (hasInvalid || childList.length === 0) {
+                var fixedTop = compactEditorRootChildren(childList);
+                var nextNodes = fixedTop.length === 0 ? [
                     createDefaultBlock()
-                ] : clean;
+                ] : fixedTop;
+                EditorUtils.replaceEditorContent(editor, nextNodes);
                 normalizeNode(entry);
                 return;
             }
-            if (node.children.length === 0) {
-                editor.children = [
-                    createDefaultBlock()
-                ];
+            normalizeNode(entry);
+            return;
+        }
+        if (!Editor.isEditor(node) && !Text.isText(node)) {
+            var rawChildren = node.children;
+            if (!Array.isArray(rawChildren)) {
+                Object.assign(node, rebuildElement(node));
                 normalizeNode(entry);
                 return;
             }
-            normalizeNode(entry);
-            return;
         }
-        if (Node.isNode(node)) {
-            var hasInvalid1 = node.children.some(function(c) {
-                return !isValidChild(c);
-            });
+        if (Element.isElement(node)) {
+            var childList1 = getChildList(node);
+            var hasInvalid1 = childArrayHasInvalidEntries(childList1);
             if (hasInvalid1) {
-                Editor.withoutNormalizing(editor, function() {
-                    var rebuilt = rebuildElement(node);
-                    Transforms.removeNodes(editor, {
-                        at: path,
-                        voids: true
-                    });
-                    Transforms.insertNodes(editor, rebuilt, {
-                        at: path,
-                        voids: true
+                var applyRebuild = function applyRebuild() {
+                    Editor.withoutNormalizing(editor, function() {
+                        var rebuilt = rebuildElement(node);
+                        Transforms.removeNodes(editor, {
+                            at: path,
+                            voids: true
+                        });
+                        Transforms.insertNodes(editor, rebuilt, {
+                            at: path,
+                            voids: true
+                        });
                     });
-                });
+                };
+                runWithoutHistory(editor, applyRebuild);
                 return;
             }
         }

package/dist/MarkdownEditor/editor/store.d.ts

@@ -662,9 +662,7 @@ export declare class EditorStore {
         maxResults?: number;
     }): {
         path: Path;
-        range: import("slate").BaseRange; /**
-         * 更新结构不同的表格
-         */
+        range: import("slate").BaseRange;
         node: any;
         matchedText: string;
         offset: {
@@ -672,6 +670,9 @@ export declare class EditorStore {
             end: number;
         };
         lineContent: string;
+        /**
+         * 更新结构不同的表格
+         */
         nodeType?: string | undefined;
         searchVariant?: string | undefined;
         isLink?: boolean | undefined;

package/dist/MarkdownEditor/editor/store.js

@@ -435,6 +435,11 @@ export var EditorStoreContext = createContext(null);
             value: function setMDContent(md, plugins, options) {
                 var _ref, _ref1, _ref2, _ref3;
                 if (md === undefined) return;
+                if (!md) {
+                    if (this._shouldSkipSetContent('')) return;
+                    this.clearContent();
+                    return;
+                }
                 if (this._shouldSkipSetContent(md)) return;
                 this.cancelSetMDContent();
                 var chunkSize = (_ref = options === null || options === void 0 ? void 0 : options.chunkSize) !== null && _ref !== void 0 ? _ref : 5000;

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/style.js

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

package/dist/MarkdownInputField/MarkdownInputField.js

@@ -140,7 +140,6 @@ import { useLocale } from "../I18n";
 import { BaseMarkdownEditor } from "../MarkdownEditor";
 import { BorderBeamAnimation } from "./BorderBeamAnimation";
 import { useFileUploadManager } from "./FileUploadManager";
-import { resolveSendDisabled } from "./SendButton";
 import { useMarkdownInputFieldActions } from "./hooks/useMarkdownInputFieldActions";
 import { useMarkdownInputFieldHandlers } from "./hooks/useMarkdownInputFieldHandlers";
 import { useMarkdownInputFieldLayout } from "./hooks/useMarkdownInputFieldLayout";
@@ -148,6 +147,7 @@ import { useMarkdownInputFieldRefs } from "./hooks/useMarkdownInputFieldRefs";
 import { useMarkdownInputFieldState } from "./hooks/useMarkdownInputFieldState";
 import { useMarkdownInputFieldStyles } from "./hooks/useMarkdownInputFieldStyles";
 import { QuickActions } from "./QuickActions";
+import { resolveSendDisabled } from "./SendButton";
 import { SkillModeBar } from "./SkillModeBar";
 import { useStyle } from "./style";
 import { Suggestion } from "./Suggestion";

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';