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_without_holes(arr) {
    if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
function _iterable_to_array(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _non_iterable_spread() {
    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 _object_spread(target) {
    for(var i = 1; i < arguments.length; i++){
        var source = arguments[i] != null ? arguments[i] : {};
        var ownKeys = Object.keys(source);
        if (typeof Object.getOwnPropertySymbols === "function") {
            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
            }));
        }
        ownKeys.forEach(function(key) {
            _define_property(target, key, source[key]);
        });
    }
    return target;
}
function _to_consumable_array(arr) {
    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
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);
    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);
}
/**
 * 表头列名 ↔ 注释字段名 的宽松匹配工具集。
 *
 * **零外部依赖**（仅原生字符串/正则），可被解析层（`parseTable`）与
 * 渲染层（`Plugins/chart/DocCards`）共用而不引入循环依赖或额外 bundle 体积。
 *
 * 设计原则：
 * - 与 `chart` 的 x/y 字段匹配规则保持一致，避免「同一份契约多套实现」漂移；
 * - 不引入任何 React / remark / antd 等运行时依赖。
 */ /**
 * 表头列名在「逻辑名」后仅跟一段或多段中英文括号内的单位/补充说明时的后缀。
 *
 * 例如 `GDP总量（万亿元）`、`销量(万台)`、`指标(A)(B)`。
 */ var TRAILING_UNIT_SUFFIX_PATTERN = /^(\s*[（(][^）)]+[）)])+\s*$/;
/**
 * 判断表头列名 `columnKey` 是否对应注释里配置的字段 `configuredField`。
 *
 * 命中条件：
 * - 精确相等；
 * - 列名 = 配置名 + 中英文括号内的单位/补充说明（如 `GDP总量（万亿元）` 命中 `GDP总量`）。
 */ export var columnKeyMatchesConfiguredField = function columnKeyMatchesConfiguredField(columnKey, configuredField) {
    var ck = (columnKey || '').trim();
    var f = (configuredField || '').trim();
    if (!ck || !f) return false;
    if (ck === f) return true;
    if (!ck.startsWith(f)) return false;
    var rest = ck.slice(f.length);
    return rest === '' || TRAILING_UNIT_SUFFIX_PATTERN.test(rest);
};
/**
 * 将注释中的 x/y 字段名解析为表格列的 dataIndex（表头可带单位括号而注释写短名）。
 *
 * 找不到匹配时返回原 `configuredField`，由后续校验决定是否降级。
 */ export var resolveChartAxisFieldToColumnKey = function resolveChartAxisFieldToColumnKey(configuredField, columnKeys) {
    if (configuredField === undefined || configuredField === null) {
        return configuredField;
    }
    var f = configuredField.trim();
    if (!f) return configuredField;
    var keySet = new Set(columnKeys);
    if (keySet.has(f)) return f;
    var hit = columnKeys.find(function(k) {
        return columnKeyMatchesConfiguredField(k, f);
    });
    return hit !== null && hit !== void 0 ? hit : configuredField;
};
/**
 * docCards 字段别名表（按语义字段聚合）。
 *
 * 列名匹配遵循「精确相等」或「逻辑名 + 中英文括号单位/补充」的宽松规则
 * （复用 {@link columnKeyMatchesConfiguredField}），与 chart x/y 字段匹配一致。
 *
 * 解析层与渲染层引用同一份常量，避免别名漂移。
 */ export var DOC_CARDS_FIELD_ALIASES = {
    title: [
        '名称',
        '标题',
        'name',
        'title',
        'Name',
        'Title'
    ],
    url: [
        '地址',
        '链接',
        'URL',
        'url',
        'Link',
        'link',
        '网址'
    ],
    description: [
        '简介',
        '描述',
        '说明',
        'description',
        'desc',
        'summary'
    ],
    tags: [
        '亮点',
        '标签',
        'tags',
        'tag',
        '关键词'
    ]
};
/**
 * 在表头列名集合中按别名顺序查找首个命中列；同时支持外部覆盖名。
 */ var findFieldKey = function findFieldKey(field, columnKeys, override) {
    var candidates = override ? [
        override
    ].concat(_to_consumable_array(DOC_CARDS_FIELD_ALIASES[field])) : DOC_CARDS_FIELD_ALIASES[field];
    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
    try {
        var _loop = function() {
            var alias = _step.value;
            if (!alias) return "continue";
            if (columnKeys.includes(alias)) return {
                v: alias
            };
            var matched = columnKeys.find(function(key) {
                return columnKeyMatchesConfiguredField(key, alias);
            });
            if (matched) return {
                v: matched
            };
        };
        for(var _iterator = candidates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
            var _ret = _loop();
            if (_type_of(_ret) === "object") return _ret.v;
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally{
        try {
            if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
            }
        } finally{
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }
    return undefined;
};
/**
 * 根据表头列与可选覆盖映射，解析出 docCards 各语义字段对应的 dataIndex。
 *
 * 当 `title` 列无法解析时返回 `null`，调用方应据此降级（解析阶段降为普通表格、
 * 渲染阶段返回空态）。
 */ export var resolveDocCardsFields = function resolveDocCardsFields(columnKeys, override) {
    var title = findFieldKey('title', columnKeys, override === null || override === void 0 ? void 0 : override.title);
    if (!title) return null;
    var url = findFieldKey('url', columnKeys, override === null || override === void 0 ? void 0 : override.url);
    var description = findFieldKey('description', columnKeys, override === null || override === void 0 ? void 0 : override.description);
    var tags = findFieldKey('tags', columnKeys, override === null || override === void 0 ? void 0 : override.tags);
    return _object_spread({
        title: title
    }, url ? {
        url: url
    } : {}, description ? {
        description: description
    } : {}, tags ? {
        tags: tags
    } : {});
};
/**
 * 解析阶段的快速判定：能否在给定表头中锁定 docCards 主标题列。
 *
 * 与 {@link resolveDocCardsFields} 行为对齐，但仅校验 `title` 一项，
 * 用于 `parseTable` 在不引入渲染层的情况下做整表降级判断。
 */ export var canResolveDocCardsTitleColumn = function canResolveDocCardsTitleColumn(columnKeys, override) {
    return findFieldKey('title', columnKeys, override) !== undefined;
};
