@matechat/ng 0.0.1-alpha.0 → 20.0.1-alpha.0

package/esm2022/MarkdownCard/markdown-card.component.mjs

@@ -0,0 +1,436 @@
+import { DiffDOM } from 'diff-dom';
+import { Component, Input, ViewChild, Output, EventEmitter, ViewContainerRef, } from '@angular/core';
+import markdownit from 'markdown-it';
+import { MDCardService } from '../components-common/MarkdownCard/common/MDCardService';
+import { CodeBlockComponent } from './code-block.component';
+import BaseComponent from '../Base/base.component';
+import { MarkdownCardFoundation, } from '../components-common/MarkdownCard/foundation';
+import MdParserUtils from '../components-common/MarkdownCard/common/parser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class MarkdownCardComponent extends BaseComponent {
+    constructor(renderer, cdr) {
+        super();
+        this.renderer = renderer;
+        this.cdr = cdr;
+        this.content = '';
+        this.typing = false;
+        this.enableThink = false;
+        this.typingOptions = {};
+        this.thinkOptions = {};
+        this.mdOptions = {};
+        this.mdPlugins = [];
+        this.customXssRules = [];
+        this.theme = 'light';
+        this.enableMermaid = false;
+        this.mermaidConfig = {};
+        this.actionsTemplate = null;
+        this.headerTemplate = null;
+        this.contentTemplate = null;
+        // 组件缓存映射表，用于存储已创建的CodeBlockComponent实例
+        this.codeBlockComponentsCache = new Map();
+        this.afterMdtInit = new EventEmitter();
+        this.typingStart = new EventEmitter();
+        this.typingEvent = new EventEmitter();
+        this.typingEnd = new EventEmitter();
+        this.typingIndex = 0;
+        this.isTyping = false;
+        this.timer = null;
+        this.parser = MdParserUtils;
+        this.noDiff = false;
+        this.mdt = markdownit({
+            breaks: true,
+            linkify: true,
+            html: true,
+            highlight: (str, lang) => {
+                // 与Vue组件保持一致的高亮处理
+                return '';
+            },
+            ...this.mdOptions,
+        });
+        this.mdCardService = new MDCardService();
+        this.foundation = new MarkdownCardFoundation(this.adapter);
+        // 初始化 diffDom 实例
+        this.diffDom = new DiffDOM({
+            // 配置filterOuterDiff钩子，识别code-block-wrapper元素并直接替换
+            filterOuterDiff: (t1, t2, diffs) => {
+                // 检查是否是class为code-block-wrapper的div元素
+                const isTargetElement = t2.nodeName === 'DIV' &&
+                    t2.attributes &&
+                    t2.attributes.class &&
+                    t2.attributes.class.includes('code-block-wrapper');
+                if (isTargetElement) {
+                    t1.innerDone = true;
+                    t2.innerDone = true;
+                }
+            },
+        });
+    }
+    ngOnInit() {
+        this.mdCardService.setMdPlugins(this.mdPlugins || [], this.mdt);
+        this.parseContent();
+        this.afterMdtInit.emit(this.mdt);
+    }
+    get adapter() {
+        return {
+            ...super.adapter,
+            locale: (key, params) => this.adapter.locale(key, params),
+            typingStart: () => this.typingStart.emit(),
+            typingEnd: () => this.typingEnd.emit(),
+            typingEvent: () => this.typingEvent.emit(),
+            parseContent: (content) => {
+                // 解析 Markdown 内容
+                const tokens = this.mdt.parse(content, {});
+                const ast = this.parser.tokensToAst(tokens);
+                const vnodes = this.astToVnodes(ast);
+                this.renderContent(vnodes);
+            },
+        };
+    }
+    ngOnChanges(changes) {
+        if (changes['content']) {
+            if (!this.typing) {
+                this.typingIndex = this.content?.length || 0;
+                this.parseContent();
+                return;
+            }
+            if (this.content.indexOf(changes['content']?.previousValue) === -1) {
+                this.typingIndex = 0;
+            }
+            // 使用setTimeout模拟Vue的nextTick行为
+            setTimeout(() => this.typewriterStart());
+        }
+        if (changes['enableThink'] || changes['thinkOptions'] || changes['theme']) {
+            this.parseContent();
+        }
+        if (changes['customXssRules']) {
+            this.mdCardService.setCustomXssRules(this.customXssRules || []);
+            this.parseContent();
+        }
+        if (changes['mdPlugins']) {
+            this.mdCardService.setMdPlugins(this.mdPlugins || [], this.mdt);
+            this.parseContent();
+        }
+    }
+    parseContent() {
+        this.foundation.parseContent();
+    }
+    renderContent(vnodes) {
+        if (!this.markdownContainer || !this.markdownContainer.element) {
+            return;
+        }
+        if (this.noDiff) {
+            this.renderContentNoDiff(vnodes);
+            return;
+        }
+        const container = this.markdownContainer.element.nativeElement;
+        const parser = new DOMParser();
+        const newContainerDiv = parser.parseFromString(`<div></div>`, 'text/html');
+        const codeBlockWrappers = vnodes.filter((node) => {
+            return (node.nodeName === 'DIV' &&
+                node.className?.includes('code-block-wrapper'));
+        });
+        vnodes.forEach((node) => {
+            if (node &&
+                (node.nodeType ||
+                    typeof node === 'string' ||
+                    node instanceof HTMLElement)) {
+                if (codeBlockWrappers.includes(node)) {
+                    newContainerDiv.body.firstChild?.appendChild(this.getEmptyCodeBlock(node));
+                }
+                else {
+                    newContainerDiv.body.firstChild?.appendChild(node);
+                }
+            }
+        });
+        let newContainerDivHTML = newContainerDiv.body?.firstChild?.outerHTML || '';
+        const patches = this.diffDom.diff(container, newContainerDivHTML);
+        this.diffDom.apply(container, patches);
+        // 将codeBlockWrappers中的每个div元素替换container中的对应key属性的元素
+        codeBlockWrappers.forEach((newCodeBlock) => {
+            if (newCodeBlock &&
+                newCodeBlock.attributes &&
+                newCodeBlock.attributes.key) {
+                const key = newCodeBlock?.attributes?.key?.value;
+                const existingElement = container.querySelector(`[key="${key}"]`);
+                if (existingElement &&
+                    newCodeBlock instanceof HTMLElement &&
+                    existingElement !== newCodeBlock) {
+                    existingElement.replaceWith(newCodeBlock);
+                }
+            }
+        });
+    }
+    getEmptyCodeBlock(node) {
+        const codeNode = document.createElement('div');
+        codeNode.className = 'code-block-wrapper';
+        codeNode.setAttribute('key', node?.attributes?.key?.value);
+        return codeNode;
+    }
+    astToVnodes(nodes) {
+        return nodes.map((node) => this.processASTNode(node));
+    }
+    processASTNode(node) {
+        if (node.nodeType === 'html_inline' || node.nodeType === 'html_block') {
+            return this.processHTMLNode(node);
+        }
+        if (node.nodeType === 'inline') {
+            return this.processInlineToken(node);
+        }
+        if (this.foundation.isToken(node)) {
+            return this.processToken(node);
+        }
+        return this.processASTNodeInternal(node);
+    }
+    processHTMLNode(node) {
+        if (!node.openNode?.content)
+            return;
+        const parser = new DOMParser();
+        const tagName = node.nodeType === 'html_block' ? 'div' : 'span';
+        const containerDocument = parser.parseFromString(`<${tagName}>${node.openNode.content}</${tagName}>`, 'text/html');
+        const containerBody = containerDocument.body.firstChild;
+        // 处理子节点
+        if (node.children && node.children.length > 0) {
+            node.children.forEach((child) => {
+                const childVnode = this.processASTNode(child);
+                if (childVnode && containerBody) {
+                    (containerBody?.firstChild || containerBody).appendChild(childVnode);
+                }
+            });
+        }
+        return containerBody;
+    }
+    renderContentNoDiff(vnodes) {
+        const container = this.markdownContainer.element.nativeElement;
+        const newContentFragement = this.renderer.createElement('div');
+        vnodes.forEach((node) => {
+            if (node &&
+                (node.nodeType ||
+                    typeof node === 'string' ||
+                    node instanceof HTMLElement)) {
+                newContentFragement.appendChild(node);
+            }
+        });
+        while (container.firstChild) {
+            container.removeChild(container.firstChild);
+        }
+        container.appendChild(newContentFragement);
+    }
+    processInlineToken(node) {
+        let html = '';
+        try {
+            if (!node.openNode) {
+                return null;
+            }
+            html = this.mdt.renderer.render([node.openNode], this.mdt.options, {});
+        }
+        catch (error) {
+            console.error('Error rendering inline token:', node);
+            return null;
+        }
+        // 将HTML字符串转换为DOM节点
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(`<div>${html}</div>`, 'text/html');
+        const token = doc.body.firstChild;
+        // 如果只有一个子节点，直接返回子节点而不是包含div
+        if (token && token.childNodes.length === 1) {
+            return token.firstChild;
+        }
+        return token;
+    }
+    processFenceNode(token) {
+        const language = token.info?.replace(/<span\b[^>]*>/i, '').replace('</span>', '') || '';
+        const code = token.content || '';
+        return this.createCodeBlock(language, code, token.tokenIndex || 0);
+    }
+    processASTNodeInternal(node) {
+        let tagName = 'div';
+        if (node.openNode?.tag && this.parser.isValidTagName(node.openNode?.tag)) {
+            tagName = node.openNode?.tag;
+        }
+        const element = this.renderer.createElement(tagName);
+        // 设置属性
+        if (node.openNode.attrs) {
+            node.openNode.attrs.forEach(([key, value]) => {
+                this.renderer.setAttribute(element, key, value);
+            });
+        }
+        // 特殊处理fence类型的token
+        if (node.openNode.type === 'fence') {
+            return this.processFenceNode(node.openNode);
+        }
+        // 处理所有带tag的AST节点
+        if (node.openNode?.tag) {
+            let tagName = this.parser.isValidTagName(node.openNode?.tag)
+                ? node.openNode?.tag
+                : 'div';
+            const element = this.renderer.createElement(tagName);
+            // 递归处理所有子节点并添加到当前元素
+            node.children.forEach((child) => {
+                const childNode = this.processASTNode(child);
+                if (childNode) {
+                    element.appendChild(childNode);
+                }
+            });
+            return element;
+        }
+        node.children.forEach((child) => {
+            const childNode = this.processASTNode(child);
+            if (childNode) {
+                element.appendChild(childNode);
+            }
+        });
+        return element;
+    }
+    processToken(token) {
+        if (token.type === 'text') {
+            return this.renderer.createText(token.content || '');
+        }
+        if (token.type === 'inline') {
+            return this.processInlineToken(token);
+        }
+        if (token.type === 'fence') {
+            return this.processFenceNode(token);
+        }
+        if (token.type === 'softbreak') {
+            if (this.mdt.options.breaks) {
+                return this.renderer.createElement('br');
+            }
+            else {
+                return this.renderer.createText('\n');
+            }
+        }
+        if (token.type === 'html_block' || token.type === 'html_inline') {
+            const parser = new DOMParser();
+            const tagName = token.type === 'html_block' ? 'div' : 'span';
+            const doc = parser.parseFromString(`<${tagName}>${token.content}</${tagName}>`, 'text/html');
+            const tokenDom = doc.body;
+            // 如果只有一个子节点，直接返回子节点而不是包含div
+            if (tokenDom.firstChild && tokenDom.childNodes.length === 1) {
+                return tokenDom.firstChild;
+            }
+            return tokenDom;
+        }
+        if (token.tag) {
+            const tagName = this.parser.isValidTagName(token.tag) ? token.tag : 'div';
+            const element = this.renderer.createElement(tagName);
+            if (token.attrs) {
+                token.attrs.forEach(([key, value]) => {
+                    this.renderer.setAttribute(element, key, value);
+                });
+            }
+            // 设置内容
+            if (token.content) {
+                const textNode = this.renderer.createText(token.content);
+                element.appendChild(textNode);
+            }
+            return element;
+        }
+        return this.renderer.createText(token.content || '');
+    }
+    createCodeBlock(language, code, blockIndex) {
+        const key = `code-block-${blockIndex}`;
+        // 检查缓存中是否已存在相同blockIndex的组件
+        if (this.codeBlockComponentsCache.has(key)) {
+            const cachedItem = this.codeBlockComponentsCache.get(key);
+            if (cachedItem) {
+                // 更新现有组件的属性
+                const componentRef = cachedItem.componentRef;
+                componentRef.setInput('language', language);
+                componentRef.setInput('code', code);
+                componentRef.setInput('theme', this.theme);
+                // 触发变更检测
+                componentRef.changeDetectorRef.detectChanges();
+                // 返回缓存的容器，无需重新创建
+                return cachedItem.container;
+            }
+        }
+        // 缓存中不存在，创建新组件
+        const codeBlockContainer = this.renderer.createElement('div');
+        this.renderer.setAttribute(codeBlockContainer, 'key', key);
+        const componentRef = this.markdownContainer.createComponent(CodeBlockComponent, {
+            projectableNodes: [],
+            injector: this.markdownContainer.injector,
+        });
+        // 设置组件属性
+        componentRef.instance.language = language;
+        componentRef.instance.code = code;
+        componentRef.instance.blockIndex = blockIndex;
+        componentRef.instance.theme = this.theme;
+        componentRef.instance.enableMermaid = this.enableMermaid;
+        componentRef.instance.mermaidConfig = this.mermaidConfig || {};
+        componentRef.instance.actionsTemplate = this.actionsTemplate;
+        componentRef.instance.headerTemplate = this.headerTemplate;
+        componentRef.instance.contentTemplate = this.contentTemplate;
+        // 触发变更检测
+        componentRef.changeDetectorRef.detectChanges();
+        // 将组件的DOM元素附加到容器中
+        this.renderer.appendChild(codeBlockContainer, componentRef.location.nativeElement);
+        // 添加样式类
+        this.renderer.addClass(codeBlockContainer, 'code-block-wrapper');
+        // 缓存组件实例和容器
+        this.codeBlockComponentsCache.set(key, {
+            componentRef: componentRef,
+            container: codeBlockContainer,
+        });
+        // 返回创建的DOM容器
+        return codeBlockContainer;
+    }
+    typewriterStart() {
+        this.foundation.typewriterStart();
+    }
+    // 在组件销毁时清理缓存，避免内存泄漏
+    ngOnDestroy() {
+        // 销毁所有缓存的组件实例
+        this.codeBlockComponentsCache.forEach((cachedItem) => {
+            cachedItem.componentRef.destroy();
+        });
+        this.codeBlockComponentsCache.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: MarkdownCardComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.0", type: MarkdownCardComponent, selector: "mc-markdown-card", inputs: { content: "content", typing: "typing", enableThink: "enableThink", typingOptions: "typingOptions", thinkOptions: "thinkOptions", mdOptions: "mdOptions", mdPlugins: "mdPlugins", customXssRules: "customXssRules", theme: "theme", enableMermaid: "enableMermaid", mermaidConfig: "mermaidConfig", actionsTemplate: "actionsTemplate", headerTemplate: "headerTemplate", contentTemplate: "contentTemplate" }, outputs: { afterMdtInit: "afterMdtInit", typingStart: "typingStart", typingEvent: "typingEvent", typingEnd: "typingEnd" }, viewQueries: [{ propertyName: "markdownContainer", first: true, predicate: ["markdownContainer"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div class=\"mc-markdown-render\" [ngClass]=\"theme === 'dark' ? 'mc-markdown-render-dark' : 'mc-markdown-render-light'\">\n  <div #markdownContainer></div>\n</div>\n<ng-content></ng-content>", styles: [".mc-markdown-render ::ng-deep .h1,.mc-markdown-render ::ng-deep .h2,.mc-markdown-render ::ng-deep .h3,.mc-markdown-render ::ng-deep .h4,.mc-markdown-render ::ng-deep .h5,.mc-markdown-render ::ng-deep .h6,.mc-markdown-render ::ng-deep h1,.mc-markdown-render ::ng-deep h2,.mc-markdown-render ::ng-deep h3,.mc-markdown-render ::ng-deep h4,.mc-markdown-render ::ng-deep h5,.mc-markdown-render ::ng-deep h6{line-height:1.1;margin:16px 0 12px}.mc-markdown-render ::ng-deep .h1:first-child,.mc-markdown-render ::ng-deep .h2:first-child,.mc-markdown-render ::ng-deep .h3:first-child,.mc-markdown-render ::ng-deep .h4:first-child,.mc-markdown-render ::ng-deep .h5:first-child,.mc-markdown-render ::ng-deep .h6:first-child,.mc-markdown-render ::ng-deep h1:first-child,.mc-markdown-render ::ng-deep h2:first-child,.mc-markdown-render ::ng-deep h3:first-child,.mc-markdown-render ::ng-deep h4:first-child,.mc-markdown-render ::ng-deep h5:first-child,.mc-markdown-render ::ng-deep h6:first-child{margin-top:0}.mc-markdown-render ::ng-deep h1{font-size:32px;line-height:40px;overflow-wrap:break-word}.mc-markdown-render ::ng-deep h3{line-height:28px;font-size:20px;overflow-wrap:break-word}.mc-markdown-render ::ng-deep caption{border:1px dashed var(--devui-line, #d7d8da);border-bottom:0;padding:3px;text-align:center}.mc-markdown-render ::ng-deep p{overflow-wrap:break-word;margin:0;padding:0;line-height:24px}.mc-markdown-render ::ng-deep p:last-child{margin:0}.mc-markdown-render ::ng-deep ul,.mc-markdown-render ::ng-deep ol{margin:0;padding:0;padding-inline-start:1.75em}.mc-markdown-render ::ng-deep ul>li,.mc-markdown-render ::ng-deep ol>li{line-height:21px}.mc-markdown-render ::ng-deep ul{list-style-type:disc}.mc-markdown-render ::ng-deep ul li::marker{font-size:20px}.mc-markdown-render ::ng-deep ol{list-style-type:decimal}.mc-markdown-render ::ng-deep table{margin-bottom:10px;border-collapse:collapse;display:table}.mc-markdown-render ::ng-deep td,.mc-markdown-render ::ng-deep th{padding:5px 10px;border:1px solid var(--devui-dividing-line, #f2f2f3);background-color:var(--devui-base-bg, #ffffff)}.mc-markdown-render ::ng-deep th{border-top:1px solid var(--devui-dividing-line, #f2f2f3);background-color:var(--devui-global-bg, #f6f6f8)}.mc-markdown-render ::ng-deep td p{margin:0;padding:0}.mc-markdown-render ::ng-deep blockquote{padding:0 8px;margin:0;color:var(--devui-text-weak, #575d6c);border-left:5px solid var(--devui-dividing-line, #f2f2f3)}.mc-markdown-render ::ng-deep a{color:var(--devui-link, #526ecc);text-decoration:none;cursor:pointer}.mc-markdown-render ::ng-deep a:hover{color:var(--devui-link-active, #526ecc)}.mc-markdown-render ::ng-deep img{max-width:100%}.mc-markdown-render{font-size:var(--devui-font-size, 14px);overflow-x:auto}.mc-markdown-render.mc-markdown-render-dark{color:#ced1db}.mc-markdown-render.mc-markdown-render-light{color:#252b3a}::ng-deep .mc-think-block{color:var(--devui-aide-text, #71757f);border-left:1px solid var(--devui-line, #d7d8da);padding-left:8px;margin-bottom:1rem}::ng-deep .mc-typewriter-color{background-image:-webkit-linear-gradient(left,#191919,#5588f0,#e171ee,#f2c55c);background-clip:text;-webkit-background-clip:text;-webkit-text-fill-color:transparent}::ng-deep .mc-typewriter-gradient{background:linear-gradient(to right,var(--devui-text, #252b3a),var(--devui-base-bg, #ffffff));background-clip:text;-webkit-background-clip:text;-webkit-text-fill-color:transparent}::ng-deep .mc-typewriter-cursor{font-weight:900;animation:typewriter .8s linear 0s infinite}@keyframes typewriter{0%{opacity:1}50%{opacity:0}to{opacity:1}}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: MarkdownCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mc-markdown-card', template: "<div class=\"mc-markdown-render\" [ngClass]=\"theme === 'dark' ? 'mc-markdown-render-dark' : 'mc-markdown-render-light'\">\n  <div #markdownContainer></div>\n</div>\n<ng-content></ng-content>", styles: [".mc-markdown-render ::ng-deep .h1,.mc-markdown-render ::ng-deep .h2,.mc-markdown-render ::ng-deep .h3,.mc-markdown-render ::ng-deep .h4,.mc-markdown-render ::ng-deep .h5,.mc-markdown-render ::ng-deep .h6,.mc-markdown-render ::ng-deep h1,.mc-markdown-render ::ng-deep h2,.mc-markdown-render ::ng-deep h3,.mc-markdown-render ::ng-deep h4,.mc-markdown-render ::ng-deep h5,.mc-markdown-render ::ng-deep h6{line-height:1.1;margin:16px 0 12px}.mc-markdown-render ::ng-deep .h1:first-child,.mc-markdown-render ::ng-deep .h2:first-child,.mc-markdown-render ::ng-deep .h3:first-child,.mc-markdown-render ::ng-deep .h4:first-child,.mc-markdown-render ::ng-deep .h5:first-child,.mc-markdown-render ::ng-deep .h6:first-child,.mc-markdown-render ::ng-deep h1:first-child,.mc-markdown-render ::ng-deep h2:first-child,.mc-markdown-render ::ng-deep h3:first-child,.mc-markdown-render ::ng-deep h4:first-child,.mc-markdown-render ::ng-deep h5:first-child,.mc-markdown-render ::ng-deep h6:first-child{margin-top:0}.mc-markdown-render ::ng-deep h1{font-size:32px;line-height:40px;overflow-wrap:break-word}.mc-markdown-render ::ng-deep h3{line-height:28px;font-size:20px;overflow-wrap:break-word}.mc-markdown-render ::ng-deep caption{border:1px dashed var(--devui-line, #d7d8da);border-bottom:0;padding:3px;text-align:center}.mc-markdown-render ::ng-deep p{overflow-wrap:break-word;margin:0;padding:0;line-height:24px}.mc-markdown-render ::ng-deep p:last-child{margin:0}.mc-markdown-render ::ng-deep ul,.mc-markdown-render ::ng-deep ol{margin:0;padding:0;padding-inline-start:1.75em}.mc-markdown-render ::ng-deep ul>li,.mc-markdown-render ::ng-deep ol>li{line-height:21px}.mc-markdown-render ::ng-deep ul{list-style-type:disc}.mc-markdown-render ::ng-deep ul li::marker{font-size:20px}.mc-markdown-render ::ng-deep ol{list-style-type:decimal}.mc-markdown-render ::ng-deep table{margin-bottom:10px;border-collapse:collapse;display:table}.mc-markdown-render ::ng-deep td,.mc-markdown-render ::ng-deep th{padding:5px 10px;border:1px solid var(--devui-dividing-line, #f2f2f3);background-color:var(--devui-base-bg, #ffffff)}.mc-markdown-render ::ng-deep th{border-top:1px solid var(--devui-dividing-line, #f2f2f3);background-color:var(--devui-global-bg, #f6f6f8)}.mc-markdown-render ::ng-deep td p{margin:0;padding:0}.mc-markdown-render ::ng-deep blockquote{padding:0 8px;margin:0;color:var(--devui-text-weak, #575d6c);border-left:5px solid var(--devui-dividing-line, #f2f2f3)}.mc-markdown-render ::ng-deep a{color:var(--devui-link, #526ecc);text-decoration:none;cursor:pointer}.mc-markdown-render ::ng-deep a:hover{color:var(--devui-link-active, #526ecc)}.mc-markdown-render ::ng-deep img{max-width:100%}.mc-markdown-render{font-size:var(--devui-font-size, 14px);overflow-x:auto}.mc-markdown-render.mc-markdown-render-dark{color:#ced1db}.mc-markdown-render.mc-markdown-render-light{color:#252b3a}::ng-deep .mc-think-block{color:var(--devui-aide-text, #71757f);border-left:1px solid var(--devui-line, #d7d8da);padding-left:8px;margin-bottom:1rem}::ng-deep .mc-typewriter-color{background-image:-webkit-linear-gradient(left,#191919,#5588f0,#e171ee,#f2c55c);background-clip:text;-webkit-background-clip:text;-webkit-text-fill-color:transparent}::ng-deep .mc-typewriter-gradient{background:linear-gradient(to right,var(--devui-text, #252b3a),var(--devui-base-bg, #ffffff));background-clip:text;-webkit-background-clip:text;-webkit-text-fill-color:transparent}::ng-deep .mc-typewriter-cursor{font-weight:900;animation:typewriter .8s linear 0s infinite}@keyframes typewriter{0%{opacity:1}50%{opacity:0}to{opacity:1}}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }], propDecorators: { content: [{
+                type: Input
+            }], typing: [{
+                type: Input
+            }], enableThink: [{
+                type: Input
+            }], typingOptions: [{
+                type: Input
+            }], thinkOptions: [{
+                type: Input
+            }], mdOptions: [{
+                type: Input
+            }], mdPlugins: [{
+                type: Input
+            }], customXssRules: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], enableMermaid: [{
+                type: Input
+            }], mermaidConfig: [{
+                type: Input
+            }], actionsTemplate: [{
+                type: Input
+            }], headerTemplate: [{
+                type: Input
+            }], contentTemplate: [{
+                type: Input
+            }], afterMdtInit: [{
+                type: Output
+            }], typingStart: [{
+                type: Output
+            }], typingEvent: [{
+                type: Output
+            }], typingEnd: [{
+                type: Output
+            }], markdownContainer: [{
+                type: ViewChild,
+                args: ['markdownContainer', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown-card.component.js","sourceRoot":"","sources":["../../../../projects/components-ng/src/MarkdownCard/markdown-card.component.ts","../../../../projects/components-ng/src/MarkdownCard/markdown-card.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EACL,SAAS,EACT,KAAK,EAML,SAAS,EACT,MAAM,EACN,YAAY,EAEZ,gBAAgB,GAEjB,MAAM,eAAe,CAAC;AACvB,OAAO,UAAU,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,aAAa,EAAE,MAAM,wDAAwD,CAAC;AAEvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAK5D,OAAO,aAAa,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAEL,sBAAsB,GACvB,MAAM,8CAA8C,CAAC;AACtD,OAAO,aAAa,MAAM,iDAAiD,CAAC;;;AAO5E,MAAM,OAAO,qBACX,SAAQ,aAAqC;IAyC7C,YAAoB,QAAmB,EAAS,GAAsB;QACpE,KAAK,EAAE,CAAC;QADU,aAAQ,GAAR,QAAQ,CAAW;QAAS,QAAG,GAAH,GAAG,CAAmB;QArC7D,YAAO,GAAW,EAAE,CAAC;QACrB,WAAM,GAAY,KAAK,CAAC;QACxB,gBAAW,GAAY,KAAK,CAAC;QAC7B,kBAAa,GAA6C,EAAE,CAAC;QAC7D,iBAAY,GAAsC,EAAE,CAAC;QACrD,cAAS,GAAmC,EAAE,CAAC;QAC/C,cAAS,GAAmC,EAAE,CAAC;QAC/C,mBAAc,GAAwC,EAAE,CAAC;QACzD,UAAK,GAA2B,OAAO,CAAC;QACxC,kBAAa,GAAY,KAAK,CAAC;QAC/B,kBAAa,GAAuC,EAAE,CAAC;QACvD,oBAAe,GAA4B,IAAI,CAAC;QAChD,mBAAc,GAA4B,IAAI,CAAC;QAC/C,oBAAe,GAA4B,IAAI,CAAC;QAEzD,uCAAuC;QAC/B,6BAAwB,GAG5B,IAAI,GAAG,EAAE,CAAC;QAEJ,iBAAY,GAAG,IAAI,YAAY,EAAc,CAAC;QAC9C,gBAAW,GAAG,IAAI,YAAY,EAAQ,CAAC;QACvC,gBAAW,GAAG,IAAI,YAAY,EAAQ,CAAC;QACvC,cAAS,GAAG,IAAI,YAAY,EAAQ,CAAC;QAM/C,gBAAW,GAAW,CAAC,CAAC;QACxB,aAAQ,GAAY,KAAK,CAAC;QAC1B,UAAK,GAAkB,IAAI,CAAC;QAC5B,WAAM,GAAG,aAAa,CAAC;QAEvB,WAAM,GAAY,KAAK,CAAC;QAItB,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC;YACpB,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE,IAAI;YACb,IAAI,EAAE,IAAI;YACV,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;gBACvB,kBAAkB;gBAClB,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,GAAG,IAAI,CAAC,SAAS;SAClB,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QACzC,IAAI,CAAC,UAAU,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE3D,iBAAiB;QACjB,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC;YACzB,kDAAkD;YAClD,eAAe,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;gBACjC,sCAAsC;gBACtC,MAAM,eAAe,GACnB,EAAE,CAAC,QAAQ,KAAK,KAAK;oBACrB,EAAE,CAAC,UAAU;oBACb,EAAE,CAAC,UAAU,CAAC,KAAK;oBACnB,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;gBAErD,IAAI,eAAe,EAAE,CAAC;oBACpB,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC;oBACpB,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC;gBACtB,CAAC;YACH,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAChE,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,IAAa,OAAO;QAClB,OAAO;YACL,GAAG,KAAK,CAAC,OAAO;YAChB,MAAM,EAAE,CAAC,GAAW,EAAE,MAA+B,EAAE,EAAE,CACvD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC;YAClC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE;YAC1C,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE;YACtC,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE;YAC1C,YAAY,EAAE,CAAC,OAAe,EAAE,EAAE;gBAChC,iBAAiB;gBACjB,MAAM,MAAM,GAAQ,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBAChD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gBAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;gBACrC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC7B,CAAC;SACF,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACjB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC,CAAC;gBAC7C,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;gBACnE,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;YACvB,CAAC;YACD,+BAA+B;YAC/B,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,OAAO,CAAC,aAAa,CAAC,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1E,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;QAED,IAAI,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC;YAChE,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;QAED,IAAI,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;YAChE,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;IACjC,CAAC;IAEO,aAAa,CAAC,MAAM;QAC1B,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;YAC/D,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YACjC,OAAO;QACT,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,aAAa,CAAC;QAC/D,MAAM,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;QAC/B,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAC3E,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YAC/C,OAAO,CACL,IAAI,CAAC,QAAQ,KAAK,KAAK;gBACvB,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,oBAAoB,CAAC,CAC/C,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACtB,IACE,IAAI;gBACJ,CAAC,IAAI,CAAC,QAAQ;oBACZ,OAAO,IAAI,KAAK,QAAQ;oBACxB,IAAI,YAAY,WAAW,CAAC,EAC9B,CAAC;gBACD,IAAI,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;oBACrC,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC7E,CAAC;qBAAM,CAAC;oBACN,eAAe,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;gBACrD,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,mBAAmB,GACpB,eAAe,CAAC,IAAI,EAAE,UAA0B,EAAE,SAAS,IAAI,EAAE,CAAC;QACrE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QAClE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACvC,qDAAqD;QACrD,iBAAiB,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE;YACzC,IACE,YAAY;gBACZ,YAAY,CAAC,UAAU;gBACvB,YAAY,CAAC,UAAU,CAAC,GAAG,EAC3B,CAAC;gBACD,MAAM,GAAG,GAAG,YAAY,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC;gBACjD,MAAM,eAAe,GAAG,SAAS,CAAC,aAAa,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;gBAClE,IACE,eAAe;oBACf,YAAY,YAAY,WAAW;oBACnC,eAAe,KAAK,YAAY,EAChC,CAAC;oBACD,eAAe,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;gBAC5C,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,iBAAiB,CAAC,IAAI;QAC5B,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC/C,QAAQ,CAAC,SAAS,GAAG,oBAAoB,CAAC;QAC1C,QAAQ,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;QAC3D,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,WAAW,CAAC,KAAgB;QAClC,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC;IAEO,cAAc,CAAC,IAA2B;QAChD,IAAI,IAAI,CAAC,QAAQ,KAAK,aAAa,IAAI,IAAI,CAAC,QAAQ,KAAK,YAAY,EAAE,CAAC;YACtE,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;QAED,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QAED,OAAO,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEO,eAAe,CAAC,IAAa;QACnC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO;YAAE,OAAO;QAEpC,MAAM,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,KAAK,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAChE,MAAM,iBAAiB,GAAG,MAAM,CAAC,eAAe,CAC9C,IAAI,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,KAAK,OAAO,GAAG,EACnD,WAAW,CACZ,CAAC;QACF,MAAM,aAAa,GAAG,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC;QACxD,QAAQ;QACR,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9C,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC9B,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,KAAY,CAAC,CAAC;gBACrD,IAAI,UAAU,IAAI,aAAa,EAAE,CAAC;oBAChC,CAAC,aAAa,EAAE,UAAU,IAAI,aAAa,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;gBACvE,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,aAAa,CAAC;IACvB,CAAC;IAEO,mBAAmB,CAAC,MAAM;QAChC,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,aAAa,CAAC;QAC/D,MAAM,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC/D,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACtB,IACE,IAAI;gBACJ,CAAC,IAAI,CAAC,QAAQ;oBACZ,OAAO,IAAI,KAAK,QAAQ;oBACxB,IAAI,YAAY,WAAW,CAAC,EAC9B,CAAC;gBACD,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YACxC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC,UAAU,EAAE,CAAC;YAC5B,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC9C,CAAC;QACD,SAAS,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC;IAC7C,CAAC;IAEO,kBAAkB,CAAC,IAAmB;QAC5C,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACnB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACzE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,IAAI,CAAC,CAAC;YACrD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,mBAAmB;QACnB,MAAM,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,eAAe,CAAC,QAAQ,IAAI,QAAQ,EAAE,WAAW,CAAC,CAAC;QACtE,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC;QAClC,4BAA4B;QAC5B,IAAI,KAAK,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3C,OAAO,KAAK,CAAC,UAAU,CAAC;QAC1B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,gBAAgB,CAAC,KAAY;QACnC,MAAM,QAAQ,GACZ,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;QACzE,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,IAAI,EAAG,KAAa,CAAC,UAAU,IAAI,CAAC,CAAC,CAAC;IAC9E,CAAC;IAEO,sBAAsB,CAAC,IAAmB;QAChD,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE,CAAC;YACzE,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC;QAC/B,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAErD,OAAO;QACP,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACxB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;gBAC3C,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YAClD,CAAC,CAAC,CAAC;QACL,CAAC;QAED,oBAAoB;QACpB,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAA4B,CAAC,CAAC;QAClE,CAAC;QAED,iBAAiB;QACjB,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC;YACvB,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC;gBAC1D,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG;gBACpB,CAAC,CAAC,KAAK,CAAC;YACV,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAErD,oBAAoB;YACpB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gBAC7C,IAAI,SAAS,EAAE,CAAC;oBACd,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;gBACjC,CAAC;YACH,CAAC,CAAC,CAAC;YACH,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC7C,IAAI,SAAS,EAAE,CAAC;gBACd,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;YACjC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,YAAY,CAAC,KAAY;QAC/B,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACtC,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC3C,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACxC,CAAC;QACH,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YAChE,MAAM,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;YAC/B,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;YAC7D,MAAM,GAAG,GAAG,MAAM,CAAC,eAAe,CAChC,IAAI,OAAO,IAAI,KAAK,CAAC,OAAO,KAAK,OAAO,GAAG,EAC3C,WAAW,CACZ,CAAC;YACF,MAAM,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC;YAC1B,4BAA4B;YAC5B,IAAI,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC5D,OAAO,QAAQ,CAAC,UAAU,CAAC;YAC7B,CAAC;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;YACd,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;YAC1E,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAErD,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;gBAChB,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;oBACnC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;gBAClD,CAAC,CAAC,CAAC;YACL,CAAC;YAED,OAAO;YACP,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACzD,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;IACvD,CAAC;IAEO,eAAe,CAAC,QAAgB,EAAE,IAAY,EAAE,UAAkB;QACxE,MAAM,GAAG,GAAG,cAAc,UAAU,EAAE,CAAC;QAEvC,4BAA4B;QAC5B,IAAI,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC1D,IAAI,UAAU,EAAE,CAAC;gBACf,YAAY;gBACZ,MAAM,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;gBAC7C,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gBAC5C,YAAY,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACpC,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;gBAE3C,SAAS;gBACT,YAAY,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;gBAC/C,iBAAiB;gBACjB,OAAO,UAAU,CAAC,SAAS,CAAC;YAC9B,CAAC;QACH,CAAC;QAED,eAAe;QACf,MAAM,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC9D,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,kBAAkB,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;QAE3D,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,CACzD,kBAAkB,EAClB;YACE,gBAAgB,EAAE,EAAE;YACpB,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,QAAQ;SAC1C,CACF,CAAC;QAEF,SAAS;QACT,YAAY,CAAC,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC1C,YAAY,CAAC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC;QAClC,YAAY,CAAC,QAAQ,CAAC,UAAU,GAAG,UAAU,CAAC;QAC9C,YAAY,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzC,YAAY,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzD,YAAY,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC;QAC/D,YAAY,CAAC,QAAQ,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC7D,YAAY,CAAC,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAC3D,YAAY,CAAC,QAAQ,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAE7D,SAAS;QACT,YAAY,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QAE/C,kBAAkB;QAClB,IAAI,CAAC,QAAQ,CAAC,WAAW,CACvB,kBAAkB,EAClB,YAAY,CAAC,QAAQ,CAAC,aAAa,CACpC,CAAC;QAEF,QAAQ;QACR,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC;QAEjE,YAAY;QACZ,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,EAAE;YACrC,YAAY,EAAE,YAAY;YAC1B,SAAS,EAAE,kBAAkB;SAC9B,CAAC,CAAC;QAEH,aAAa;QACb,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC;IACpC,CAAC;IAED,oBAAoB;IACX,WAAW;QAClB,cAAc;QACd,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;YACnD,UAAU,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,wBAAwB,CAAC,KAAK,EAAE,CAAC;IACxC,CAAC;8GAldU,qBAAqB;kGAArB,qBAAqB,8qBA+BQ,gBAAgB,uFCpE1D,iMAGyB;;2FDkCZ,qBAAqB;kBALjC,SAAS;+BACE,kBAAkB;8GASnB,OAAO;sBAAf,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,eAAe;sBAAvB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,eAAe;sBAAvB,KAAK;gBAQI,YAAY;sBAArB,MAAM;gBACG,WAAW;sBAApB,MAAM;gBACG,WAAW;sBAApB,MAAM;gBACG,SAAS;sBAAlB,MAAM;gBAGP,iBAAiB;sBADhB,SAAS;uBAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import { DiffDOM } from 'diff-dom';\nimport {\n  Component,\n  Input,\n  OnInit,\n  OnChanges,\n  OnDestroy,\n  ChangeDetectorRef,\n  SimpleChanges,\n  ViewChild,\n  Output,\n  EventEmitter,\n  Renderer2,\n  ViewContainerRef,\n  TemplateRef,\n} from '@angular/core';\nimport markdownit from 'markdown-it';\nimport type { Token } from 'markdown-it';\nimport { MDCardService } from '../components-common/MarkdownCard/common/MDCardService';\nimport type { ASTNode } from '../components-common/MarkdownCard/common/mdCard.types';\nimport { CodeBlockComponent } from './code-block.component';\nimport {\n  MarkdownCardProps,\n  defaultTypingConfig,\n} from '../components-common/MarkdownCard/common/mdCard.types';\nimport BaseComponent from '../Base/base.component';\nimport {\n  MarkdownCardAdapter,\n  MarkdownCardFoundation,\n} from '../components-common/MarkdownCard/foundation';\nimport MdParserUtils from '../components-common/MarkdownCard/common/parser';\n\n@Component({\n  selector: 'mc-markdown-card',\n  templateUrl: './markdown-card.component.html',\n  styleUrls: ['./markdown-card.component.scss'],\n})\nexport class MarkdownCardComponent\n  extends BaseComponent<MarkdownCardFoundation>\n  implements OnInit, OnChanges, OnDestroy\n{\n  private diffDom: DiffDOM;\n  @Input() content: string = '';\n  @Input() typing: boolean = false;\n  @Input() enableThink: boolean = false;\n  @Input() typingOptions: MarkdownCardProps['typingOptions'] | any = {};\n  @Input() thinkOptions: MarkdownCardProps['thinkOptions'] = {};\n  @Input() mdOptions: MarkdownCardProps['mdOptions'] = {};\n  @Input() mdPlugins: MarkdownCardProps['mdPlugins'] = [];\n  @Input() customXssRules: MarkdownCardProps['customXssRules'] = [];\n  @Input() theme: 'light' | 'dark' | any = 'light';\n  @Input() enableMermaid: boolean = false;\n  @Input() mermaidConfig: MarkdownCardProps['mermaidConfig'] = {};\n  @Input() actionsTemplate: TemplateRef<any> | null = null;\n  @Input() headerTemplate: TemplateRef<any> | null = null;\n  @Input() contentTemplate: TemplateRef<any> | null = null;\n\n  // 组件缓存映射表，用于存储已创建的CodeBlockComponent实例\n  private codeBlockComponentsCache: Map<\n    string,\n    { componentRef: any; container: HTMLElement }\n  > = new Map();\n\n  @Output() afterMdtInit = new EventEmitter<markdownit>();\n  @Output() typingStart = new EventEmitter<void>();\n  @Output() typingEvent = new EventEmitter<void>();\n  @Output() typingEnd = new EventEmitter<void>();\n\n  @ViewChild('markdownContainer', { read: ViewContainerRef, static: true })\n  markdownContainer!: ViewContainerRef;\n\n  private mdt: markdownit;\n  typingIndex: number = 0;\n  isTyping: boolean = false;\n  timer: number | null = null;\n  parser = MdParserUtils;\n  mdCardService;\n  noDiff: boolean = false;\n\n  constructor(private renderer: Renderer2, public cdr: ChangeDetectorRef) {\n    super();\n    this.mdt = markdownit({\n      breaks: true,\n      linkify: true,\n      html: true,\n      highlight: (str, lang) => {\n        // 与Vue组件保持一致的高亮处理\n        return '';\n      },\n      ...this.mdOptions,\n    });\n    this.mdCardService = new MDCardService();\n    this.foundation = new MarkdownCardFoundation(this.adapter);\n\n    // 初始化 diffDom 实例\n    this.diffDom = new DiffDOM({\n      // 配置filterOuterDiff钩子，识别code-block-wrapper元素并直接替换\n      filterOuterDiff: (t1, t2, diffs) => {\n        // 检查是否是class为code-block-wrapper的div元素\n        const isTargetElement =\n          t2.nodeName === 'DIV' &&\n          t2.attributes &&\n          t2.attributes.class &&\n          t2.attributes.class.includes('code-block-wrapper');\n\n        if (isTargetElement) {\n          t1.innerDone = true;\n          t2.innerDone = true;\n        }\n      },\n    });\n  }\n\n  ngOnInit(): void {\n    this.mdCardService.setMdPlugins(this.mdPlugins || [], this.mdt);\n    this.parseContent();\n    this.afterMdtInit.emit(this.mdt);\n  }\n\n  override get adapter(): MarkdownCardAdapter {\n    return {\n      ...super.adapter,\n      locale: (key: string, params?: Record<string, string>) =>\n        this.adapter.locale(key, params),\n      typingStart: () => this.typingStart.emit(),\n      typingEnd: () => this.typingEnd.emit(),\n      typingEvent: () => this.typingEvent.emit(),\n      parseContent: (content: string) => {\n        // 解析 Markdown 内容\n        const tokens: any = this.mdt.parse(content, {});\n        const ast = this.parser.tokensToAst(tokens);\n        const vnodes = this.astToVnodes(ast);\n        this.renderContent(vnodes);\n      },\n    };\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['content']) {\n      if (!this.typing) {\n        this.typingIndex = this.content?.length || 0;\n        this.parseContent();\n        return;\n      }\n      if (this.content.indexOf(changes['content']?.previousValue) === -1) {\n        this.typingIndex = 0;\n      }\n      // 使用setTimeout模拟Vue的nextTick行为\n      setTimeout(() => this.typewriterStart());\n    }\n\n    if (changes['enableThink'] || changes['thinkOptions'] || changes['theme']) {\n      this.parseContent();\n    }\n\n    if (changes['customXssRules']) {\n      this.mdCardService.setCustomXssRules(this.customXssRules || []);\n      this.parseContent();\n    }\n\n    if (changes['mdPlugins']) {\n      this.mdCardService.setMdPlugins(this.mdPlugins || [], this.mdt);\n      this.parseContent();\n    }\n  }\n\n  private parseContent() {\n    this.foundation.parseContent();\n  }\n\n  private renderContent(vnodes) {\n    if (!this.markdownContainer || !this.markdownContainer.element) {\n      return;\n    }\n\n    if (this.noDiff) {\n      this.renderContentNoDiff(vnodes);\n      return;\n    }\n\n    const container = this.markdownContainer.element.nativeElement;\n    const parser = new DOMParser();\n    const newContainerDiv = parser.parseFromString(`<div></div>`, 'text/html');\n    const codeBlockWrappers = vnodes.filter((node) => {\n      return (\n        node.nodeName === 'DIV' &&\n        node.className?.includes('code-block-wrapper')\n      );\n    });\n\n    vnodes.forEach((node) => {\n      if (\n        node &&\n        (node.nodeType ||\n          typeof node === 'string' ||\n          node instanceof HTMLElement)\n      ) {\n        if (codeBlockWrappers.includes(node)) {\n          newContainerDiv.body.firstChild?.appendChild(this.getEmptyCodeBlock(node));\n        } else {\n          newContainerDiv.body.firstChild?.appendChild(node);\n        }\n      }\n    });\n    let newContainerDivHTML =\n      (newContainerDiv.body?.firstChild as HTMLElement)?.outerHTML || '';\n    const patches = this.diffDom.diff(container, newContainerDivHTML);\n    this.diffDom.apply(container, patches);\n    // 将codeBlockWrappers中的每个div元素替换container中的对应key属性的元素\n    codeBlockWrappers.forEach((newCodeBlock) => {\n      if (\n        newCodeBlock &&\n        newCodeBlock.attributes &&\n        newCodeBlock.attributes.key\n      ) {\n        const key = newCodeBlock?.attributes?.key?.value;\n        const existingElement = container.querySelector(`[key=\"${key}\"]`);\n        if (\n          existingElement &&\n          newCodeBlock instanceof HTMLElement &&\n          existingElement !== newCodeBlock\n        ) {\n          existingElement.replaceWith(newCodeBlock);\n        }\n      }\n    });\n  }\n\n  private getEmptyCodeBlock(node) {\n    const codeNode = document.createElement('div');\n    codeNode.className = 'code-block-wrapper';\n    codeNode.setAttribute('key', node?.attributes?.key?.value);\n    return codeNode;\n  }\n\n  private astToVnodes(nodes: ASTNode[]) {\n    return nodes.map((node) => this.processASTNode(node));\n  }\n\n  private processASTNode(node: ASTNode | Token | any) {\n    if (node.nodeType === 'html_inline' || node.nodeType === 'html_block') {\n      return this.processHTMLNode(node);\n    }\n\n    if (node.nodeType === 'inline') {\n      return this.processInlineToken(node);\n    }\n    if (this.foundation.isToken(node)) {\n      return this.processToken(node);\n    }\n\n    return this.processASTNodeInternal(node);\n  }\n\n  private processHTMLNode(node: ASTNode) {\n    if (!node.openNode?.content) return;\n\n    const parser = new DOMParser();\n    const tagName = node.nodeType === 'html_block' ? 'div' : 'span';\n    const containerDocument = parser.parseFromString(\n      `<${tagName}>${node.openNode.content}</${tagName}>`,\n      'text/html'\n    );\n    const containerBody = containerDocument.body.firstChild;\n    // 处理子节点\n    if (node.children && node.children.length > 0) {\n      node.children.forEach((child) => {\n        const childVnode = this.processASTNode(child as any);\n        if (childVnode && containerBody) {\n          (containerBody?.firstChild || containerBody).appendChild(childVnode);\n        }\n      });\n    }\n    return containerBody;\n  }\n\n  private renderContentNoDiff(vnodes) {\n    const container = this.markdownContainer.element.nativeElement;\n    const newContentFragement = this.renderer.createElement('div');\n    vnodes.forEach((node) => {\n      if (\n        node &&\n        (node.nodeType ||\n          typeof node === 'string' ||\n          node instanceof HTMLElement)\n      ) {\n        newContentFragement.appendChild(node);\n      }\n    });\n    while (container.firstChild) {\n      container.removeChild(container.firstChild);\n    }\n    container.appendChild(newContentFragement);\n  }\n\n  private processInlineToken(node: ASTNode | any) {\n    let html = '';\n    try {\n      if (!node.openNode) {\n        return null;\n      }\n      html = this.mdt.renderer.render([node.openNode], this.mdt.options, {});\n    } catch (error) {\n      console.error('Error rendering inline token:', node);\n      return null;\n    }\n\n    // 将HTML字符串转换为DOM节点\n    const parser = new DOMParser();\n    const doc = parser.parseFromString(`<div>${html}</div>`, 'text/html');\n    const token = doc.body.firstChild;\n    // 如果只有一个子节点，直接返回子节点而不是包含div\n    if (token && token.childNodes.length === 1) {\n      return token.firstChild;\n    }\n    return token;\n  }\n\n  private processFenceNode(token: Token) {\n    const language =\n      token.info?.replace(/<span\\b[^>]*>/i, '').replace('</span>', '') || '';\n    const code = token.content || '';\n    return this.createCodeBlock(language, code, (token as any).tokenIndex || 0);\n  }\n\n  private processASTNodeInternal(node: ASTNode | any) {\n    let tagName = 'div';\n    if (node.openNode?.tag && this.parser.isValidTagName(node.openNode?.tag)) {\n      tagName = node.openNode?.tag;\n    }\n    const element = this.renderer.createElement(tagName);\n\n    // 设置属性\n    if (node.openNode.attrs) {\n      node.openNode.attrs.forEach(([key, value]) => {\n        this.renderer.setAttribute(element, key, value);\n      });\n    }\n\n    // 特殊处理fence类型的token\n    if (node.openNode.type === 'fence') {\n      return this.processFenceNode(node.openNode as unknown as Token);\n    }\n\n    // 处理所有带tag的AST节点\n    if (node.openNode?.tag) {\n      let tagName = this.parser.isValidTagName(node.openNode?.tag)\n        ? node.openNode?.tag\n        : 'div';\n      const element = this.renderer.createElement(tagName);\n\n      // 递归处理所有子节点并添加到当前元素\n      node.children.forEach((child) => {\n        const childNode = this.processASTNode(child);\n        if (childNode) {\n          element.appendChild(childNode);\n        }\n      });\n      return element;\n    }\n\n    node.children.forEach((child) => {\n      const childNode = this.processASTNode(child);\n      if (childNode) {\n        element.appendChild(childNode);\n      }\n    });\n    return element;\n  }\n\n  private processToken(token: Token) {\n    if (token.type === 'text') {\n      return this.renderer.createText(token.content || '');\n    }\n\n    if (token.type === 'inline') {\n      return this.processInlineToken(token);\n    }\n\n    if (token.type === 'fence') {\n      return this.processFenceNode(token);\n    }\n\n    if (token.type === 'softbreak') {\n      if (this.mdt.options.breaks) {\n        return this.renderer.createElement('br');\n      } else {\n        return this.renderer.createText('\\n');\n      }\n    }\n\n    if (token.type === 'html_block' || token.type === 'html_inline') {\n      const parser = new DOMParser();\n      const tagName = token.type === 'html_block' ? 'div' : 'span';\n      const doc = parser.parseFromString(\n        `<${tagName}>${token.content}</${tagName}>`,\n        'text/html'\n      );\n      const tokenDom = doc.body;\n      // 如果只有一个子节点，直接返回子节点而不是包含div\n      if (tokenDom.firstChild && tokenDom.childNodes.length === 1) {\n        return tokenDom.firstChild;\n      }\n      return tokenDom;\n    }\n\n    if (token.tag) {\n      const tagName = this.parser.isValidTagName(token.tag) ? token.tag : 'div';\n      const element = this.renderer.createElement(tagName);\n\n      if (token.attrs) {\n        token.attrs.forEach(([key, value]) => {\n          this.renderer.setAttribute(element, key, value);\n        });\n      }\n\n      // 设置内容\n      if (token.content) {\n        const textNode = this.renderer.createText(token.content);\n        element.appendChild(textNode);\n      }\n      return element;\n    }\n\n    return this.renderer.createText(token.content || '');\n  }\n\n  private createCodeBlock(language: string, code: string, blockIndex: number) {\n    const key = `code-block-${blockIndex}`;\n\n    // 检查缓存中是否已存在相同blockIndex的组件\n    if (this.codeBlockComponentsCache.has(key)) {\n      const cachedItem = this.codeBlockComponentsCache.get(key);\n      if (cachedItem) {\n        // 更新现有组件的属性\n        const componentRef = cachedItem.componentRef;\n        componentRef.setInput('language', language);\n        componentRef.setInput('code', code);\n        componentRef.setInput('theme', this.theme);\n\n        // 触发变更检测\n        componentRef.changeDetectorRef.detectChanges();\n        // 返回缓存的容器，无需重新创建\n        return cachedItem.container;\n      }\n    }\n\n    // 缓存中不存在，创建新组件\n    const codeBlockContainer = this.renderer.createElement('div');\n    this.renderer.setAttribute(codeBlockContainer, 'key', key);\n\n    const componentRef = this.markdownContainer.createComponent(\n      CodeBlockComponent,\n      {\n        projectableNodes: [],\n        injector: this.markdownContainer.injector,\n      }\n    );\n\n    // 设置组件属性\n    componentRef.instance.language = language;\n    componentRef.instance.code = code;\n    componentRef.instance.blockIndex = blockIndex;\n    componentRef.instance.theme = this.theme;\n    componentRef.instance.enableMermaid = this.enableMermaid;\n    componentRef.instance.mermaidConfig = this.mermaidConfig || {};\n    componentRef.instance.actionsTemplate = this.actionsTemplate;\n    componentRef.instance.headerTemplate = this.headerTemplate;\n    componentRef.instance.contentTemplate = this.contentTemplate;\n\n    // 触发变更检测\n    componentRef.changeDetectorRef.detectChanges();\n\n    // 将组件的DOM元素附加到容器中\n    this.renderer.appendChild(\n      codeBlockContainer,\n      componentRef.location.nativeElement\n    );\n\n    // 添加样式类\n    this.renderer.addClass(codeBlockContainer, 'code-block-wrapper');\n\n    // 缓存组件实例和容器\n    this.codeBlockComponentsCache.set(key, {\n      componentRef: componentRef,\n      container: codeBlockContainer,\n    });\n\n    // 返回创建的DOM容器\n    return codeBlockContainer;\n  }\n\n  private typewriterStart(): void {\n    this.foundation.typewriterStart();\n  }\n\n  // 在组件销毁时清理缓存，避免内存泄漏\n  override ngOnDestroy(): void {\n    // 销毁所有缓存的组件实例\n    this.codeBlockComponentsCache.forEach((cachedItem) => {\n      cachedItem.componentRef.destroy();\n    });\n    this.codeBlockComponentsCache.clear();\n  }\n}\n","<div class=\"mc-markdown-render\" [ngClass]=\"theme === 'dark' ? 'mc-markdown-render-dark' : 'mc-markdown-render-light'\">\n  <div #markdownContainer></div>\n</div>\n<ng-content></ng-content>"]}

package/esm2022/MarkdownCard/markdown-card.module.mjs

@@ -0,0 +1,44 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TranslatePipe } from '../Locale';
+import { MarkdownCardComponent } from './markdown-card.component';
+import { CodeBlockComponent } from './code-block.component';
+import { LocaleModule } from '../Locale';
+import * as i0 from "@angular/core";
+export class MarkdownCardModule {
+    static forRoot() {
+        return {
+            ngModule: MarkdownCardModule,
+            providers: []
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: MarkdownCardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.0", ngImport: i0, type: MarkdownCardModule, declarations: [MarkdownCardComponent,
+            CodeBlockComponent], imports: [CommonModule,
+            TranslatePipe,
+            LocaleModule], exports: [MarkdownCardComponent,
+            CodeBlockComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: MarkdownCardModule, imports: [CommonModule,
+            LocaleModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: MarkdownCardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MarkdownCardComponent,
+                        CodeBlockComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        TranslatePipe,
+                        LocaleModule,
+                    ],
+                    exports: [
+                        MarkdownCardComponent,
+                        CodeBlockComponent
+                    ],
+                    providers: [],
+                    bootstrap: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components-common/Base/foundation.mjs

@@ -52,6 +52,9 @@ class BaseFoundation {
     setCache(key, value) {
         return key && this._adapter.setCache(key, value);
     }
+    nextTick(cb) {
+        return this._adapter.nextTick(cb);
+    }
     _isInProps(key) {
         const props = this.getProps();
         return key in props;
@@ -60,4 +63,4 @@ class BaseFoundation {
     destroy() { }
 }
 export default BaseFoundation;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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