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 _class_call_check(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, descriptor.key, descriptor);
    }
}
function _create_class(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
}
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);
}
import { applyContextPropsAndConfig } from "./parse/applyContextPropsAndConfig";
import { handleBlockquote, handleFootnoteDefinition, handleHeading, handleList, handleListItem, handleParagraph, handleTextAndInlineElements } from "./parse/parseBlockElements";
import { handleCode, handleYaml } from "./parse/parseCode";
import { handleDefinition, handleInlineCode, handleThematicBreak } from "./parse/parseElements";
import { addEmptyLinesIfNeeded } from "./parse/parseEmptyLines";
import { handleFootnoteReference } from "./parse/parseFootnote";
import { handleHtml, preprocessNonStandardHtmlTags, preprocessThinkTags } from "./parse/parseHtml";
import { handleInlineMath, handleMath } from "./parse/parseMath";
import { handleImage } from "./parse/parseMedia";
import { parseTableOrChart, preprocessMarkdownTableNewlines } from "./parse/parseTable";
import mdastParser from "./remarkParse";
/**
 * Markdown 到 Slate 节点解析器类
 *
 * 将 Markdown 字符串解析为 Slate 编辑器节点，支持配置选项和插件。
 * 使用类形式可以避免在函数调用链中传递配置参数和插件。
 */ export var MarkdownToSlateParser = /*#__PURE__*/ function() {
    "use strict";
    function MarkdownToSlateParser() {
        var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, plugins = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
        _class_call_check(this, MarkdownToSlateParser);
        _define_property(this, "config", void 0);
        _define_property(this, "plugins", void 0);
        this.config = config;
        this.plugins = plugins;
    }
    _create_class(MarkdownToSlateParser, [
        {
            /**
   * 解析 Markdown 字符串并返回解析后的结构和链接信息
   *
   * @param md - 要解析的 Markdown 字符串
   * @returns 一个包含解析后的元素数组和链接信息的对象
   */ key: "parse",
            value: function parse(md) {
                // 先预处理 <think> 标签，然后预处理其他非标准 HTML 标签，最后处理表格换行
                var thinkProcessed = preprocessThinkTags(md || '');
                var nonStandardProcessed = preprocessNonStandardHtmlTags(thinkProcessed);
                // parse() 只执行 parser，需要 runSync() 来执行 transformer 插件
                var ast = mdastParser.parse(preprocessMarkdownTableNewlines(nonStandardProcessed));
                var processedMarkdown = mdastParser.runSync(ast);
                var markdownRoot = processedMarkdown.children;
                // 使用类的配置和插件，通过 this 访问
                var schema = this.parseNodes(markdownRoot, true, undefined);
                return {
                    schema: schema === null || schema === void 0 ? void 0 : schema.filter(function(item) {
                        var _item_children;
                        if (item.type === 'paragraph' && ((_item_children = item.children) === null || _item_children === void 0 ? void 0 : _item_children.length) === 1) {
                            if (item.children[0].text === '\n') {
                                return false;
                            }
                            return true;
                        }
                        return true;
                    }),
                    links: []
                };
            }
        },
        {
            key: "parseNodes",
            value: /**
   * 解析 Markdown AST 节点为 Slate 节点（类方法版本）
   * - 当有插件时，优先使用插件处理
   * - 插件未处理时，使用默认处理逻辑
   */ function parseNodes(nodes) {
                var _this, _loop = function(i) {
                    var _currentElement_value_trim, _currentElement_value, _currentElement_value_trim1, _currentElement_value1;
                    var currentElement = nodes[i];
                    var el = null;
                    var pluginHandled = false;
                    // 检查当前元素是否是 HTML 注释
                    var isHtmlComment = currentElement.type === 'html' && ((_currentElement_value = currentElement.value) === null || _currentElement_value === void 0 ? void 0 : (_currentElement_value_trim = _currentElement_value.trim()) === null || _currentElement_value_trim === void 0 ? void 0 : _currentElement_value_trim.startsWith('<!--')) && ((_currentElement_value1 = currentElement.value) === null || _currentElement_value1 === void 0 ? void 0 : (_currentElement_value_trim1 = _currentElement_value1.trim()) === null || _currentElement_value_trim1 === void 0 ? void 0 : _currentElement_value_trim1.endsWith('-->'));
                    var htmlCommentProps = {};
                    var isOtherPropsComment = false;
                    if (isHtmlComment) {
                        try {
                            var commentContent = currentElement.value.replace('<!--', '').replace('-->', '').trim();
                            htmlCommentProps = JSON.parse(commentContent);
                            // 如果能够成功解析为 JSON 对象，且是对象类型（不是数组或基本类型）
                            if ((typeof htmlCommentProps === "undefined" ? "undefined" : _type_of(htmlCommentProps)) === 'object' && htmlCommentProps !== null && !Array.isArray(htmlCommentProps)) {
                                // 检查是否包含代码块的元数据属性（data-language、data-block、data-state）
                                // 这些属性表明这是代码块的 otherProps 序列化生成的注释
                                var hasCodeMetadataProps = htmlCommentProps['data-language'] || htmlCommentProps['data-block'] || htmlCommentProps['data-state'];
                                // 只有当包含代码块元数据属性时，才认为是 otherProps 注释
                                // 对齐注释（如 {"align":"center"}）不包含这些属性，应该被保留
                                isOtherPropsComment = hasCodeMetadataProps;
                            }
                            if (Array.isArray(htmlCommentProps)) {
                                htmlCommentProps = {
                                    config: htmlCommentProps
                                };
                            }
                        } catch (e) {
                            // 解析失败，不是 JSON 格式的注释，可能是真正的 HTML 注释
                            isOtherPropsComment = false;
                        }
                    }
                    var nextElement = i + 1 < nodes.length ? nodes[i + 1] : null;
                    var isNextCodeBlock = (nextElement === null || nextElement === void 0 ? void 0 : nextElement.type) === 'code';
                    // 如果 HTML 注释是代码块的 otherProps 序列化生成的，应该跳过，避免被解析为独立的 HTML 代码节点
                    // 如果后面跟着代码块，存储注释属性供代码块使用
                    if (isHtmlComment && isOtherPropsComment) {
                        if (isNextCodeBlock) {
                            // 后面有代码块，存储属性供代码块使用
                            pendingHtmlCommentProps = htmlCommentProps;
                        }
                        // 无论后面是否有代码块，都跳过 HTML 注释，避免生成独立的 HTML 代码节点
                        return "continue";
                    }
                    // 确定要使用的 config：优先使用待处理的 HTML 注释属性，否则使用前一个 HTML 代码节点的属性
                    var config = pendingHtmlCommentProps ? pendingHtmlCommentProps : (preElement === null || preElement === void 0 ? void 0 : preElement.type) === 'code' && (preElement === null || preElement === void 0 ? void 0 : preElement.language) === 'html' && (preElement === null || preElement === void 0 ? void 0 : preElement.otherProps) ? preElement === null || preElement === void 0 ? void 0 : preElement.otherProps : {};
                    // 如果 HTML 注释不是代码块元数据注释，但包含 JSON 对象属性（如对齐注释），
                    // 应该跳过注释本身，但将属性应用到下一个元素
                    if (isHtmlComment && !isOtherPropsComment && htmlCommentProps && Object.keys(htmlCommentProps).length > 0) {
                        // 将对齐注释等非代码块元数据注释的属性存储到 contextProps 中，供下一个元素使用
                        contextProps = _object_spread({}, contextProps, htmlCommentProps);
                        // 同时将属性作为 config 传递，以便 applyContextPropsAndConfig 设置 otherProps
                        config = _object_spread({}, config, htmlCommentProps);
                        // 跳过 HTML 注释本身，避免生成独立的 HTML 代码节点
                        return "continue";
                    }
                    // 如果当前元素应该使用 contextProps 中的属性作为 config（用于设置 otherProps）
                    // 这主要针对对齐注释等场景，需要同时设置 contextProps 和 otherProps
                    if (contextProps && Object.keys(contextProps).length > 0) {
                        config = _object_spread({}, config, contextProps);
                    }
                    // 如果使用了待处理的 HTML 注释属性，清空它
                    if (pendingHtmlCommentProps && config === pendingHtmlCommentProps) {
                        pendingHtmlCommentProps = null;
                    }
                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                    try {
                        // 首先尝试使用插件处理，使用 this.plugins
                        for(var _iterator = _this.plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                            var plugin = _step.value;
                            var _plugin_parseMarkdown;
                            var rule = (_plugin_parseMarkdown = plugin.parseMarkdown) === null || _plugin_parseMarkdown === void 0 ? void 0 : _plugin_parseMarkdown.find(function(r) {
                                return r.match(currentElement);
                            });
                            if (rule) {
                                var converted = rule.convert(currentElement);
                                // 检查转换结果是否为 NodeEntry<Text> 格式
                                if (Array.isArray(converted) && converted.length === 2) {
                                    // NodeEntry<Text> 格式: [node, path]
                                    el = converted[0];
                                } else {
                                    // Elements 格式
                                    el = converted;
                                }
                                pluginHandled = true;
                                break;
                            }
                        }
                    } catch (err) {
                        _didIteratorError = true;
                        _iteratorError = err;
                    } finally{
                        try {
                            if (!_iteratorNormalCompletion && _iterator.return != null) {
                                _iterator.return();
                            }
                        } finally{
                            if (_didIteratorError) {
                                throw _iteratorError;
                            }
                        }
                    }
                    if (Object.keys(config).length > 0) {
                        _this.config = _object_spread({}, _this.config, config);
                    }
                    // 如果插件没有处理，使用默认处理逻辑
                    if (!pluginHandled) {
                        // 使用统一的处理函数，通过 this 访问配置和插件
                        var result = _this.handleSingleElement(currentElement, config, parent, htmlTag, preElement);
                        el = result.el;
                        if (result.contextProps) {
                            contextProps = _object_spread({}, contextProps, result.contextProps);
                        }
                        // 更新 htmlTag 数组，以便后续节点可以使用
                        if (result.htmlTag) {
                            htmlTag = result.htmlTag;
                        }
                    }
                    els = addEmptyLinesIfNeeded(els, preNode, currentElement, top);
                    if (el) {
                        el = applyContextPropsAndConfig(el, contextProps, config);
                        // 使用 if-else 而不是条件表达式，避免类型错误
                        if (Array.isArray(el)) {
                            els = _to_consumable_array(els).concat(_to_consumable_array(el));
                        } else {
                            els = _to_consumable_array(els).concat([
                                el
                            ]);
                        }
                    }
                    preNode = currentElement;
                    preElement = el;
                };
                var top = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, parent = arguments.length > 2 ? arguments[2] : void 0;
                if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length)) return [
                    {
                        type: 'paragraph',
                        children: [
                            {
                                text: ''
                            }
                        ]
                    }
                ];
                var els = [];
                var preNode = null;
                var preElement = null;
                var htmlTag = [];
                var contextProps = {};
                var pendingHtmlCommentProps = null;
                for(var i = 0; i < nodes.length; i++)_this = this, _loop(i);
                return els;
            }
        },
        {
            key: "getElementHandlers",
            value: /**
   * 处理单个元素（类方法版本）
   */ /**
   * 获取统一的元素处理器映射表
   */ function getElementHandlers() {
                var _this = this;
                var parseNodesFn = function(nodes, top, parent) {
                    return _this.parseNodes(nodes, top, parent);
                };
                var parseNodesForTable = function(nodes, _plugins, top, parent) {
                    return _this.parseNodes(nodes, top || false, parent);
                };
                return {
                    html: {
                        handler: function() {
                            return null;
                        },
                        needsHtmlResult: true
                    },
                    image: {
                        handler: function(el) {
                            return handleImage(el);
                        }
                    },
                    inlineMath: {
                        handler: function(el) {
                            return handleInlineMath(el);
                        }
                    },
                    math: {
                        handler: function(el) {
                            return handleMath(el);
                        }
                    },
                    footnoteReference: {
                        handler: function(el) {
                            return handleFootnoteReference(el);
                        }
                    },
                    inlineCode: {
                        handler: function(el) {
                            return handleInlineCode(el);
                        }
                    },
                    thematicBreak: {
                        handler: function() {
                            return handleThematicBreak();
                        }
                    },
                    code: {
                        handler: function(el, _plugins, config) {
                            return handleCode(el, config);
                        }
                    },
                    yaml: {
                        handler: function(el) {
                            return handleYaml(el);
                        }
                    },
                    definition: {
                        handler: function(el) {
                            return handleDefinition(el);
                        }
                    },
                    heading: {
                        handler: function(el) {
                            return handleHeading(el, parseNodesFn);
                        }
                    },
                    list: {
                        handler: function(el) {
                            return handleList(el, parseNodesFn);
                        }
                    },
                    listItem: {
                        handler: function(el) {
                            return handleListItem(el, parseNodesFn);
                        }
                    },
                    blockquote: {
                        handler: function(el) {
                            return handleBlockquote(el, parseNodesFn);
                        }
                    },
                    footnoteDefinition: {
                        handler: function(el) {
                            return handleFootnoteDefinition(el, parseNodesFn);
                        }
                    },
                    paragraph: {
                        handler: function(el, _plugins, config) {
                            return handleParagraph(el, config, parseNodesFn);
                        }
                    },
                    table: {
                        handler: function(el, _plugins, _config, parent, _htmlTag, preElement) {
                            return parseTableOrChart(el, preElement || parent, _this.plugins, parseNodesForTable, _this.config);
                        }
                    }
                };
            }
        },
        {
            key: "handleSingleElement",
            value: function handleSingleElement(currentElement, config, parent, htmlTag, preElement) {
                var _this = this;
                var elementType = currentElement.type;
                var elementHandlers = this.getElementHandlers();
                var handlerInfo = elementHandlers[elementType];
                if (handlerInfo === null || handlerInfo === void 0 ? void 0 : handlerInfo.needsHtmlResult) {
                    var htmlResult = handleHtml(currentElement, parent, htmlTag);
                    var result = {
                        el: htmlResult.el
                    };
                    if (htmlResult.contextProps) {
                        result.contextProps = htmlResult.contextProps;
                    }
                    if (htmlResult.htmlTag) {
                        result.htmlTag = htmlResult.htmlTag;
                    }
                    return result;
                }
                if (!handlerInfo) {
                    return {
                        el: handleTextAndInlineElements(currentElement, htmlTag, function(nodes, top, parent) {
                            return _this.parseNodes(nodes, top, parent);
                        }, this.config)
                    };
                }
                var handlerResult = handlerInfo.handler(currentElement, this.plugins, config, parent, htmlTag, preElement, this);
                return {
                    el: handlerResult
                };
            }
        }
    ]);
    return MarkdownToSlateParser;
}();
/**
 * 解析Markdown字符串并返回解析后的结构和链接信息。
 *
 * @param md - 要解析的Markdown字符串。
 * @param plugins - 可选的Markdown编辑器插件数组，用于扩展解析功能。
 * @param config - 可选的解析配置选项。
 * @returns 一个包含解析后的元素数组和链接信息的对象。
 *
 * @property schema - 解析后的元素数组。
 * @property links - 包含路径和目标链接的对象数组。
 *
 * @example
 * ```typescript
 * // 使用函数形式（向后兼容）
 * const result = parserMarkdownToSlateNode(markdown, plugins, { openLinksInNewTab: true });
 *
 * // 使用类形式（推荐，避免配置传递问题）
 * const parser = new MarkdownToSlateParser(
 *   { openLinksInNewTab: true },
 *   plugins
 * );
 * const result = parser.parse(markdown);
 * ```
 */ export var parserMarkdownToSlateNode = function(md, plugins, config) {
    var parser = new MarkdownToSlateParser(config || {}, plugins || []);
    return parser.parse(md);
};
