function _array_like_to_array(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 _array_with_holes(arr) {
    if (Array.isArray(arr)) return arr;
}
function _iterable_to_array_limit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _s, _e;
    try {
        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
        }
    } catch (err) {
        _d = true;
        _e = err;
    } finally{
        try {
            if (!_n && _i["return"] != null) _i["return"]();
        } finally{
            if (_d) throw _e;
        }
    }
    return _arr;
}
function _non_iterable_rest() {
    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 _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 _tagged_template_literal(strings, raw) {
    if (!raw) {
        raw = strings.slice(0);
    }
    return Object.freeze(Object.defineProperties(strings, {
        raw: {
            value: Object.freeze(raw)
        }
    }));
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(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(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
function _templateObject() {
    var data = _tagged_template_literal([
        "d+(?:[,，]d+)*(?:.d+)?(?:[eE][+-]?d+)?"
    ], [
        "\\d+(?:[,，]\\d+)*(?:\\.\\d+)?(?:[eE][+-]?\\d+)?"
    ]);
    _templateObject = function _templateObject() {
        return data;
    };
    return data;
}
function _templateObject1() {
    var data = _tagged_template_literal([
        "^[+-]?",
        "s*%$"
    ], [
        "^[+-]?",
        "\\s*%$"
    ]);
    _templateObject1 = function _templateObject() {
        return data;
    };
    return data;
}
function _templateObject2() {
    var data = _tagged_template_literal([
        "^([+-]?",
        ")s*([kKmMbBtT])$"
    ], [
        "^([+-]?",
        ")\\s*([kKmMbBtT])$"
    ]);
    _templateObject2 = function _templateObject() {
        return data;
    };
    return data;
}
import React from "react";
/**
 * AST 提取工具集——从 mdast / hast / React children 中抽取文本与结构化数据。
 *
 * 这些工具原本散落在 `markdownReactShared.ts` 的开头，按职责单独拆出便于复用与测试。
 */ /**
 * 从 mdast 表格单元格节点中提取纯文本。
 * 递归收集所有 `text` 子节点的 value，去除前后空白。
 */ export var extractCellText = function extractCellText1(cell) {
    if (!(cell === null || cell === void 0 ? void 0 : cell.children)) return '';
    return cell.children.map(function(child) {
        if (child.type === 'text') return child.value || '';
        if (child.children) return extractCellText(child);
        return '';
    }).join('').trim();
};
/**
 * "逗号分组数字"模式（宽松版千分位）：
 * - 可选前缀负号
 * - 必须包含至少一个逗号（中英文皆可）
 * - 最后一段必须 ≥ 3 位数字（千分位的本质是 3 位分组；末段不足 3 位极不可能是数字）
 * - 中间段不限位数（容错用户书写不规范的场景，如 `12,3456`、`1,2,3456`）
 * - 可选小数部分
 *
 * 命中示例：`8,287.44`、`1,234`、`12,3456`、`-29,337.76`、`1，234.5`、`1,234,567`
 * 不命中示例：`1,2`（末段 2 位）、`12,34`（末段 2 位）、`1,2,3`（末段 1 位）、`1,234,abc`（含非数字）
 */ var THOUSAND_SEPARATED_NUMBER_PATTERN = /^-?\d+(?:[,，]\d+)*[,，]\d{3,}(?:\.\d+)?$/;
/**
 * 数字主体（含可选千分位 + 可选小数 + 可选科学计数法指数），不含正负号。
 * 用作百分比 / 紧凑后缀模式的内部子片段。
 *
 * 指数部分要求底数后跟非空指数（如 `1.2e3`、`1e-5`、`3E+10`），
 * 不接受 `1e`（指数缺位）、`e3`（缺底数）这类残缺写法。
 *
 * 注意：紧凑后缀字符集是 `[kKmMbBtT]`，与 `e/E` 不冲突。
 */ var NUMERIC_BODY_SOURCE = String.raw(_templateObject());
/**
 * 百分比模式：`12.5%`、`-3%`、`+12,345.6%`、`100 %`。
 *
 * 设计取舍：百分比保留字面值（`12.5%` → `12.5`），不做 `/100` 转换；
 * 因为 chart 场景下的 y 轴通常会以"百分比"为单位展示，做转换反而会误导。
 */ var PERCENT_PATTERN = new RegExp(String.raw(_templateObject1(), NUMERIC_BODY_SOURCE));
/**
 * 英文紧凑后缀（k/m/b/t，大小写均可）：`1.2k`、`3M`、`-2.5B`、`+1,234t`。
 *
 * 倍率：`k = 1e3`、`m = 1e6`、`b = 1e9`、`t = 1e12`。
 */ var COMPACT_SUFFIX_PATTERN = new RegExp(String.raw(_templateObject2(), NUMERIC_BODY_SOURCE));
var COMPACT_SUFFIX_MULTIPLIER = {
    k: 1e3,
    m: 1e6,
    b: 1e9,
    t: 1e12
};
/**
 * 把"逗号分组数字字符串"转为 number。
 *
 * 调用方必须先用 {@link THOUSAND_SEPARATED_NUMBER_PATTERN} 校验过格式，
 * 否则可能误把 `1,2`、`1,2,3` 之类非千分位字符串解析为数字。
 */ var parseThousandSeparatedNumber = function parseThousandSeparatedNumber(val) {
    return Number(val.replace(/[,，]/g, ''));
};
/**
 * 表格单元格的"字符串 → 数字 or 原值"统一规则。
 *
 * 规则优先级（自上而下）：
 * 1. 空串 → 直接返回空串
 * 2. `Number(val)` 成功 → 直接返回 number（覆盖纯数字 `42` / `3.14` / `-1.5`）
 * 3. 带正号前缀（`+1,234` / `+3.14`）→ 去掉 `+` 后递归
 * 4. 千分位数字（`8,287.44` / `1,234` / `12,3456`）→ 去逗号转 number
 * 5. 百分比（`12.5%` / `-3%`）→ 去 `%` 去逗号转 number（保留字面值，不除以 100）
 * 6. 英文紧凑后缀（`1.2k` / `3M` / `-2.5B` / `+1,234t`）→ base × multiplier
 * 7. 中文金额（`1.5万` / `2亿` / `5万元`）→ 走 `parseChineseCurrencyToNumber`
 * 8. 都不命中 → 返回原字符串
 *
 * @param val - 单元格文本（已 trim）
 * @param parseChineseCurrencyToNumber - 注入的中文金额解析器
 */ export var coerceTableCellValue = function coerceTableCellValue1(val, parseChineseCurrencyToNumber) {
    if (val === '') return val;
    var num = Number(val);
    if (Number.isFinite(num)) return num;
    // 带正号前缀：Number('+1,234') 会失败，但去掉 + 后能命中千分位/紧凑后缀
    if (val.startsWith('+')) {
        var rest = val.slice(1);
        // 防御：避免 '++1' 这类无意义递归
        if (rest && !rest.startsWith('+') && !rest.startsWith('-')) {
            var recursed = coerceTableCellValue(rest, parseChineseCurrencyToNumber);
            if (typeof recursed === 'number') return recursed;
        }
    }
    if (THOUSAND_SEPARATED_NUMBER_PATTERN.test(val)) {
        return parseThousandSeparatedNumber(val);
    }
    if (PERCENT_PATTERN.test(val)) {
        var bare = val.replace(/%\s*$/, '').replace(/[,，]/g, '');
        var n = Number(bare);
        if (Number.isFinite(n)) return n;
    }
    var compactMatch = val.match(COMPACT_SUFFIX_PATTERN);
    if (compactMatch) {
        var _compactMatch = _sliced_to_array(compactMatch, 3), base = _compactMatch[1], suffix = _compactMatch[2];
        var baseNum = Number(base.replace(/[,，]/g, ''));
        var multiplier = COMPACT_SUFFIX_MULTIPLIER[suffix.toLowerCase()];
        if (Number.isFinite(baseNum) && multiplier) {
            return baseNum * multiplier;
        }
    }
    var cn = parseChineseCurrencyToNumber(val);
    return cn !== null ? cn : val;
};
/**
 * 从 mdast `table` 节点提取列定义和数据行。
 *
 * - 第一行视为表头，其余行作为数据
 * - 数据值的字符串 → 数字转换规则参见 {@link coerceTableCellValue}
 *
 * @returns 解析失败（缺表头 / 空表）时返回 `null`
 */ export var extractTableData = function extractTableData(tableNode, parseChineseCurrencyToNumber) {
    var _loop = function(i) {
        var row = tableNode.children[i];
        if (!(row === null || row === void 0 ? void 0 : row.children)) return "continue";
        var record = {
            key: "row-".concat(i)
        };
        row.children.forEach(function(cell, j) {
            if (j < columns.length) {
                var val = extractCellText(cell);
                record[columns[j].dataIndex] = coerceTableCellValue(val, parseChineseCurrencyToNumber);
            }
        });
        dataSource.push(record);
    };
    var _tableNode_children, _headerRow_children;
    if (!((_tableNode_children = tableNode.children) === null || _tableNode_children === void 0 ? void 0 : _tableNode_children.length)) return null;
    var headerRow = tableNode.children[0];
    if (!(headerRow === null || headerRow === void 0 ? void 0 : (_headerRow_children = headerRow.children) === null || _headerRow_children === void 0 ? void 0 : _headerRow_children.length)) return null;
    var columns = headerRow.children.map(function(cell) {
        var text = extractCellText(cell);
        return {
            title: text,
            dataIndex: text,
            key: text
        };
    });
    var dataSource = [];
    for(var i = 1; i < tableNode.children.length; i++)_loop(i);
    return {
        columns: columns,
        dataSource: dataSource
    };
};
/**
 * 从 className 字符串/数组中提取 `language-xxx` 形式的语言标识。
 *
 * 与 `pre > code` 的代码块语言识别配套使用。
 */ export var extractLanguageFromClassName = function extractLanguageFromClassName(className) {
    if (!className) return undefined;
    var flat = typeof className === 'string' ? className : className.map(String).join(' ');
    var classes = flat.split(/\s+/).filter(Boolean);
    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
    try {
        for(var _iterator = classes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
            var cls = _step.value;
            var match = cls.match(/^language-(.+)$/);
            if (match) return match[1];
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally{
        try {
            if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
            }
        } finally{
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }
    return undefined;
};
/**
 * 递归提取 React children 中的纯文本。
 *
 * 用于在 hast → React 转换后，从已渲染的子树重新拿到原始文本（如 `<think>` 内容）。
 */ export var extractChildrenText = function extractChildrenText1(children) {
    var _children_props;
    if (typeof children === 'string') return children;
    if (typeof children === 'number') return String(children);
    if (Array.isArray(children)) return children.map(extractChildrenText).join('');
    if (React.isValidElement(children) && ((_children_props = children.props) === null || _children_props === void 0 ? void 0 : _children_props.children)) {
        return extractChildrenText(children.props.children);
    }
    return '';
};
