@gravity-ui/markdown-editor 14.4.0 → 14.5.0

package/build/cjs/bundle/sticky/sticky.css

@@ -15,7 +15,7 @@
   position: absolute;
   inset: var(--g-md-toolbar-sticky-inset, -4px);
   content: "";
-  border: 1px solid var(--g-color-line-generic-solid);
+  border: var(--g-md-toolbar-sticky-border, 1px solid var(--g-color-line-generic-solid));
   border-radius: 4px;
   background-color: var(--g-color-base-background);
 }

package/build/cjs/bundle/types.d.ts

@@ -109,6 +109,8 @@ export declare type MarkdownEditorMarkupConfig = {
     keymaps?: CreateCodemirrorParams['keymaps'];
     /** Overrides the default placeholder content. */
     placeholder?: CreateCodemirrorParams['placeholder'];
+    /** Enable HTML parsing when pasting content. */
+    parseHtmlOnPaste?: boolean;
     /**
      * Additional language data for markdown language in codemirror.
      * Can be used to configure additional autocompletions and others.

package/build/cjs/extensions/behavior/Clipboard/utils.d.ts

@@ -3,6 +3,7 @@ export declare enum DataTransferType {
     Text = "text/plain",
     Html = "text/html",
     Yfm = "text/yfm",
+    Rtf = "text/rtf",
     UriList = "text/uri-list",
     VSCodeData = "vscode-editor-data",
     Files = "Files"

package/build/cjs/extensions/behavior/Clipboard/utils.js

@@ -7,6 +7,7 @@ var DataTransferType;
     DataTransferType["Text"] = "text/plain";
     DataTransferType["Html"] = "text/html";
     DataTransferType["Yfm"] = "text/yfm";
+    DataTransferType["Rtf"] = "text/rtf";
     DataTransferType["UriList"] = "text/uri-list";
     DataTransferType["VSCodeData"] = "vscode-editor-data";
     DataTransferType["Files"] = "Files";

package/build/cjs/extensions/markdown/CodeBlock/handle-paste.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePaste = void 0;
-const utils_1 = require("../../behavior/Clipboard/utils");
+const clipboard_1 = require("../../../utils/clipboard");
 const const_1 = require("./const");
 const handlePaste = (view, e) => {
     if (!e.clipboardData || view.state.selection.$from.parent.type.spec.code)
@@ -19,28 +19,16 @@ const handlePaste = (view, e) => {
 exports.handlePaste = handlePaste;
 function getCodeData(data) {
     var _a;
-    if (data.getData(utils_1.DataTransferType.Text)) {
+    if (data.getData(clipboard_1.DataTransferType.Text)) {
         let editor = 'unknown';
         let mode;
-        if (isVSCode(data)) {
+        if ((0, clipboard_1.isVSCode)(data)) {
             editor = 'vscode';
-            mode = (_a = tryCatch(() => JSON.parse(data.getData(utils_1.DataTransferType.VSCodeData)))) === null || _a === void 0 ? void 0 : _a.mode;
+            mode = (_a = (0, clipboard_1.tryParseVSCodeData)(data)) === null || _a === void 0 ? void 0 : _a.mode;
         }
         else
             return null;
-        return { editor, mode, value: data.getData(utils_1.DataTransferType.Text) };
+        return { editor, mode, value: data.getData(clipboard_1.DataTransferType.Text) };
     }
     return null;
 }
-function isVSCode(data) {
-    return data.types.includes(utils_1.DataTransferType.VSCodeData);
-}
-function tryCatch(fn) {
-    try {
-        return fn();
-    }
-    catch (e) {
-        console.error(e);
-    }
-    return undefined;
-}

package/build/cjs/extensions/yfm/YfmFile/YfmFileSpecs/const.d.ts

@@ -1,5 +1,17 @@
+import { FileHtmlAttr } from '@diplodoc/file-extension';
 import type { AttributeSpec } from 'prosemirror-model';
 export declare const yfmFileNodeName = "yfm_file";
+export declare const YfmFileAttr: {
+    readonly Markup: "data-markup";
+    readonly Name: FileHtmlAttr.Download;
+    readonly Link: FileHtmlAttr.Href;
+    readonly ReferrerPolicy: FileHtmlAttr.ReferrerPolicy;
+    readonly Rel: FileHtmlAttr.Rel;
+    readonly Target: FileHtmlAttr.Target;
+    readonly Type: FileHtmlAttr.Type;
+    readonly Lang: FileHtmlAttr.HrefLang;
+};
+export declare const YFM_FILE_DIRECTIVE_ATTRS: readonly string[];
 export declare const KNOWN_ATTRS: readonly string[];
 export declare const REQUIRED_ATTRS: string[];
 export declare const fileNodeAttrsSpec: Record<string, AttributeSpec>;

package/build/cjs/extensions/yfm/YfmFile/YfmFileSpecs/const.js

@@ -1,8 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LINK_TO_FILE_ATTRS_MAP = exports.fileNodeAttrsSpec = exports.REQUIRED_ATTRS = exports.KNOWN_ATTRS = exports.yfmFileNodeName = void 0;
+exports.LINK_TO_FILE_ATTRS_MAP = exports.fileNodeAttrsSpec = exports.REQUIRED_ATTRS = exports.KNOWN_ATTRS = exports.YFM_FILE_DIRECTIVE_ATTRS = exports.YfmFileAttr = exports.yfmFileNodeName = void 0;
 const file_extension_1 = require("@diplodoc/file-extension");
 exports.yfmFileNodeName = file_extension_1.FILE_TOKEN;
+exports.YfmFileAttr = {
+    Markup: 'data-markup',
+    Name: file_extension_1.FileHtmlAttr.Download,
+    Link: file_extension_1.FileHtmlAttr.Href,
+    ReferrerPolicy: file_extension_1.FileHtmlAttr.ReferrerPolicy,
+    Rel: file_extension_1.FileHtmlAttr.Rel,
+    Target: file_extension_1.FileHtmlAttr.Target,
+    Type: file_extension_1.FileHtmlAttr.Type,
+    Lang: file_extension_1.FileHtmlAttr.HrefLang,
+};
+exports.YFM_FILE_DIRECTIVE_ATTRS = [
+    exports.YfmFileAttr.ReferrerPolicy,
+    exports.YfmFileAttr.Rel,
+    exports.YfmFileAttr.Target,
+    exports.YfmFileAttr.Type,
+    exports.YfmFileAttr.Lang,
+];
 exports.KNOWN_ATTRS = file_extension_1.FILE_KNOWN_ATTRS.map((attrName) => {
     if (attrName in file_extension_1.FILE_TO_LINK_ATTRS_MAP)
         return file_extension_1.FILE_TO_LINK_ATTRS_MAP[attrName];
@@ -13,7 +30,9 @@ exports.REQUIRED_ATTRS = file_extension_1.FILE_REQUIRED_ATTRS.map((attrName) =>
         return file_extension_1.FILE_TO_LINK_ATTRS_MAP[attrName];
     return attrName;
 });
-exports.fileNodeAttrsSpec = {};
+exports.fileNodeAttrsSpec = {
+    [exports.YfmFileAttr.Markup]: { default: null },
+};
 for (const attrName of exports.KNOWN_ATTRS) {
     const attrSpec = (exports.fileNodeAttrsSpec[attrName] = {});
     if (!exports.REQUIRED_ATTRS.includes(attrName)) {

package/build/cjs/extensions/yfm/YfmFile/YfmFileSpecs/index.d.ts

@@ -1,4 +1,11 @@
 import type { Extension } from '../../../../core';
-export { yfmFileNodeName } from './const';
+export { yfmFileNodeName, YfmFileAttr } from './const';
 export declare const fileType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+declare global {
+    namespace MarkdownEditor {
+        interface DirectiveSyntaxAdditionalSupportedExtensions {
+            yfmFile: true;
+        }
+    }
+}
 export declare const YfmFileSpecs: Extension;

package/build/cjs/extensions/yfm/YfmFile/YfmFileSpecs/index.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.YfmFileSpecs = exports.fileType = exports.yfmFileNodeName = void 0;
+exports.YfmFileSpecs = exports.fileType = exports.YfmFileAttr = exports.yfmFileNodeName = void 0;
 const file_extension_1 = require("@diplodoc/file-extension");
 const schema_1 = require("../../../../utils/schema");
 const const_1 = require("./const");
 var const_2 = require("./const");
 Object.defineProperty(exports, "yfmFileNodeName", { enumerable: true, get: function () { return const_2.yfmFileNodeName; } });
+Object.defineProperty(exports, "YfmFileAttr", { enumerable: true, get: function () { return const_2.YfmFileAttr; } });
 exports.fileType = (0, schema_1.nodeTypeFactory)(const_1.yfmFileNodeName);
 const YfmFileSpecs = (builder) => {
-    builder.configureMd((md) => md.use((0, file_extension_1.transform)({ bundle: false })));
+    const directiveContext = builder.context.get('directiveSyntax');
+    builder.configureMd((md) => md.use((0, file_extension_1.transform)({
+        bundle: false,
+        directiveSyntax: directiveContext === null || directiveContext === void 0 ? void 0 : directiveContext.mdPluginValueFor('yfmFile'),
+    })));
     builder.addNode(const_1.yfmFileNodeName, () => ({
         spec: {
             group: 'inline',
@@ -52,15 +57,20 @@ const YfmFileSpecs = (builder) => {
                 name: const_1.yfmFileNodeName,
                 type: 'node',
                 getAttrs: (tok) => {
-                    var _a;
-                    return Object.fromEntries((_a = tok.attrs) !== null && _a !== void 0 ? _a : []);
+                    const attrs = Object.fromEntries(tok.attrs || []);
+                    attrs[const_1.YfmFileAttr.Markup] = tok.markup;
+                    return attrs;
                 },
             },
         },
         toMd: (state, node) => {
+            if (directiveContext === null || directiveContext === void 0 ? void 0 : directiveContext.shouldSerializeToDirective('yfmFile', node.attrs[const_1.YfmFileAttr.Markup])) {
+                state.write(serializeToDirective(node));
+                return;
+            }
             const attrsStr = Object.entries(node.attrs)
                 .reduce((arr, [key, value]) => {
-                if (value) {
+                if (key !== const_1.YfmFileAttr.Markup && value) {
                     if (key in const_1.LINK_TO_FILE_ATTRS_MAP) {
                         key = const_1.LINK_TO_FILE_ATTRS_MAP[key];
                     }
@@ -74,3 +84,17 @@ const YfmFileSpecs = (builder) => {
     }));
 };
 exports.YfmFileSpecs = YfmFileSpecs;
+function serializeToDirective(node) {
+    const filename = node.attrs[const_1.YfmFileAttr.Name] || '';
+    const filelink = node.attrs[const_1.YfmFileAttr.Link] || '';
+    let fileMarkup = `:file[${filename}](${filelink})`;
+    const attrs = const_1.YFM_FILE_DIRECTIVE_ATTRS.reduce((acc, key) => {
+        const value = node.attrs[key];
+        if (value)
+            acc.push(`${key}="${value}"`);
+        return acc;
+    }, []);
+    if (attrs.length)
+        fileMarkup += `{${attrs.join(' ')}}`;
+    return fileMarkup;
+}

package/build/cjs/markup/codemirror/create.d.ts

@@ -20,6 +20,7 @@ export declare type CreateCodemirrorParams = {
     onScroll: (event: Event) => void;
     reactRenderer: ReactRenderStorage;
     uploadHandler?: FileUploadHandler;
+    parseHtmlOnPaste?: boolean;
     parseInsertedUrlAsImage?: ParseInsertedUrlAsImage;
     needImageDimensions?: boolean;
     enableNewImageSizeCalculation?: boolean;

package/build/cjs/markup/codemirror/create.js

@@ -6,19 +6,20 @@ const commands_1 = require("@codemirror/commands");
 const language_1 = require("@codemirror/language");
 const view_1 = require("@codemirror/view");
 const action_names_1 = require("../../bundle/config/action-names");
-const utils_1 = require("../../extensions/behavior/Clipboard/utils");
 const logger_1 = require("../../logger");
 const shortcuts_1 = require("../../shortcuts");
+const clipboard_1 = require("../../utils/clipboard");
 const commands_2 = require("../commands");
 const directive_facet_1 = require("./directive-facet");
 const files_upload_facet_1 = require("./files-upload-facet");
 const gravity_1 = require("./gravity");
+const converters_1 = require("./html-to-markdown/converters");
 const pairing_chars_1 = require("./pairing-chars");
 const react_facet_1 = require("./react-facet");
 const plugin_1 = require("./search-plugin/plugin");
 const yfm_1 = require("./yfm");
 function createCodemirror(params) {
-    const { doc, reactRenderer, onCancel, onScroll, onSubmit, onChange, onDocChange, disabledExtensions = {}, keymaps = [], receiver, yfmLangOptions, extensions: extraExtensions, placeholder: placeholderContent, autocompletion: autocompletionConfig, parseInsertedUrlAsImage, directiveSyntax, } = params;
+    const { doc, reactRenderer, onCancel, onScroll, onSubmit, onChange, onDocChange, disabledExtensions = {}, keymaps = [], receiver, yfmLangOptions, extensions: extraExtensions, placeholder: placeholderContent, autocompletion: autocompletionConfig, parseHtmlOnPaste, parseInsertedUrlAsImage, directiveSyntax, } = params;
     const extensions = [gravity_1.gravityTheme, (0, view_1.placeholder)(placeholderContent)];
     if (!disabledExtensions.history) {
         extensions.push((0, commands_1.history)());
@@ -70,8 +71,44 @@ function createCodemirror(params) {
         },
         paste(event, editor) {
             var _a;
-            if (event.clipboardData && parseInsertedUrlAsImage) {
-                const { imageUrl, title } = parseInsertedUrlAsImage((_a = event.clipboardData.getData(utils_1.DataTransferType.Text)) !== null && _a !== void 0 ? _a : '') || {};
+            if (!event.clipboardData)
+                return;
+            // if clipboard contains YFM content - avoid any meddling with pasted content
+            // since text/yfm will contain valid markdown
+            const yfmContent = event.clipboardData.getData(clipboard_1.DataTransferType.Yfm);
+            if (yfmContent) {
+                event.preventDefault();
+                editor.dispatch(editor.state.replaceSelection(yfmContent));
+                return;
+            }
+            // checking if a copy buffer content is suitable for convertion
+            const shouldSkipHtml = (0, clipboard_1.shouldSkipHtmlConversion)(event.clipboardData);
+            // if we have text/html inside copy/paste buffer
+            const htmlContent = event.clipboardData.getData(clipboard_1.DataTransferType.Html);
+            // if we pasting markdown from VsCode we need skip html transformation
+            if (htmlContent && parseHtmlOnPaste && !shouldSkipHtml) {
+                let parsedMarkdownMarkup;
+                try {
+                    const parser = new DOMParser();
+                    const htmlDoc = parser.parseFromString(htmlContent, 'text/html');
+                    const converter = new converters_1.MarkdownConverter();
+                    parsedMarkdownMarkup = converter.processNode(htmlDoc.body).trim();
+                }
+                catch (e) {
+                    // The code is pretty new and there might be random issues we haven't caught yet,
+                    // especially with invalid HTML or weird DOM parsing errors.
+                    // If something goes wrong, I just want to fall back to the "default pasting"
+                    // rather than break the entire experience for the user.
+                    logger_1.logger.error(e);
+                }
+                if (parsedMarkdownMarkup !== undefined) {
+                    event.preventDefault();
+                    editor.dispatch(editor.state.replaceSelection(parsedMarkdownMarkup));
+                    return;
+                }
+            }
+            if (parseInsertedUrlAsImage) {
+                const { imageUrl, title } = parseInsertedUrlAsImage((_a = event.clipboardData.getData(clipboard_1.DataTransferType.Text)) !== null && _a !== void 0 ? _a : '') || {};
                 if (!imageUrl) {
                     return;
                 }

package/build/cjs/markup/codemirror/html-to-markdown/converters.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Interface defining methods for visiting different types of HTML nodes.
+ * Each method corresponds to a specific HTML element type and returns its Markdown representation.
+ */
+export interface HTMLNodeVisitor {
+    /** Converts a text node to Markdown */
+    visitText(node: Text): string;
+    /** Converts an anchor element to Markdown link syntax */
+    visitLink(node: HTMLAnchorElement): string;
+    /** Converts a header element to Markdown heading syntax */
+    visitHeader(node: HTMLElement, level: number): string;
+    /** Converts a paragraph element to Markdown */
+    visitParagraph(node: HTMLElement): string;
+    /** Converts formatting elements (bold, italic, etc.) to Markdown */
+    visitFormatting(node: HTMLElement): string;
+    /** Converts code elements to Markdown inline code syntax */
+    visitCode(node: HTMLElement): string;
+    /** Handles generic HTML elements with no specific Markdown conversion */
+    visitGeneric(node: HTMLElement): string;
+    /** Converts an HTML div element to Markdown format, adding a single newline */
+    visitDiv(node: HTMLElement): string;
+    /** Converts an HTML br element to a newline in Markdown */
+    visitBr(): string;
+    /** Converts a table row element to Markdown */
+    visitTableRow(node: HTMLTableRowElement): string;
+    /** Converts an HTML table element to Markdown table format */
+    visitTable(node: HTMLTableElement): string;
+    /** Convert img tag to Markdown image format */
+    visitImage(node: HTMLImageElement): string;
+}
+/**
+ * Main converter class that implements the visitor interface to convert HTML to Markdown.
+ * Uses the Chain of Responsibility pattern for handling different node types.
+ */
+export declare class MarkdownConverter implements HTMLNodeVisitor {
+    private handler;
+    constructor();
+    /**
+     * Converts a text node to Markdown, escaping special characters.
+     */
+    visitText(node: Text): string;
+    /**
+     * Converts an HTML anchor element to Markdown link syntax.
+     */
+    visitLink(node: HTMLAnchorElement): string;
+    /**
+     * Converts an HTML heading element to Markdown heading syntax.
+     */
+    visitHeader(node: HTMLElement, level: number): string;
+    /**
+     * Converts an HTML paragraph to Markdown format.
+     */
+    visitParagraph(node: HTMLElement): string;
+    /**
+     * Applies Markdown formatting (bold, italic, etc.) to text content.
+     */
+    visitFormatting(node: HTMLElement): string;
+    /**
+     * Converts HTML code elements to Markdown inline code syntax.
+     */
+    visitCode(node: HTMLElement): string;
+    /**
+     * Handles generic HTML elements by processing their children.
+     */
+    visitGeneric(node: HTMLElement): string;
+    /**
+     * Converts an HTML div element to Markdown format, adding a single newline.
+     */
+    visitDiv(node: HTMLElement): string;
+    /**
+     * Converts an HTML br element to a newline in Markdown.
+     */
+    visitBr(): string;
+    /**
+     * Converts an HTML table row element to Markdown table row format.
+     */
+    visitTableRow(node: HTMLTableRowElement): string;
+    /**
+     * Converts an HTML table element to Markdown table format.
+     */
+    visitTable(node: HTMLTableElement): string;
+    /**
+     * Converts img tag to Markdown image format
+     */
+    visitImage(node: HTMLImageElement): string;
+    /**
+     * Processes a single node using the handler chain.
+     */
+    processNode(node: Node): string;
+    /**
+     * Creates and links together handlers in a specific order implementing the Chain of Responsibility pattern.
+     * @returns The first handler in the chain
+     */
+    private setupHandlerChain;
+    /**
+     * Recursively collects and processes text content from a node and its children.
+     */
+    private collectTextContent;
+    /**
+     * Collects raw text content from code elements.
+     */
+    private collectCodeContent;
+    /**
+     * Processes all child nodes of a given node.
+     */
+    private processChildren;
+    /**
+     * Gets the first handler in the chain.
+     */
+    private getHandler;
+}

package/build/cjs/markup/codemirror/html-to-markdown/converters.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownConverter = void 0;
+const handlers_1 = require("./handlers");
+const helpers_1 = require("./helpers");
+/**
+ * Main converter class that implements the visitor interface to convert HTML to Markdown.
+ * Uses the Chain of Responsibility pattern for handling different node types.
+ */
+class MarkdownConverter {
+    constructor() {
+        // Set up the chain of responsibility for handling different node types
+        this.handler = this.setupHandlerChain();
+    }
+    /**
+     * Converts a text node to Markdown, escaping special characters.
+     */
+    visitText(node) {
+        return (node.textContent || '').replace(/\n+/g, '').replace(/([<>])/g, '\\$1');
+    }
+    /**
+     * Converts an HTML anchor element to Markdown link syntax.
+     */
+    visitLink(node) {
+        var _a;
+        const linkText = this.collectTextContent(node);
+        const url = node.href || '';
+        // Handle links with formatted content vs plain text differently
+        const formattedText = node.childNodes.length === 1 && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.nodeType) === Node.TEXT_NODE
+            ? (0, helpers_1.applyFormatting)(linkText, node) // Plain text link
+            : Array.from(node.childNodes)
+                .map((child) => {
+                if (child.nodeType === Node.ELEMENT_NODE) {
+                    return (0, helpers_1.applyFormatting)(child.textContent || '', child);
+                }
+                return child.textContent || '';
+            })
+                .join(''); // Apply formatting for each formatted child node
+        return `[${formattedText}](${url} "${linkText.replace(/"/g, '\\"')}")`;
+    }
+    /**
+     * Converts an HTML heading element to Markdown heading syntax.
+     */
+    visitHeader(node, level) {
+        const headerContent = this.collectTextContent(node);
+        return '#'.repeat(level) + ' ' + headerContent + '\n';
+    }
+    /**
+     * Converts an HTML paragraph to Markdown format.
+     */
+    visitParagraph(node) {
+        const content = this.processChildren(node);
+        return content.trim() + '\n\n';
+    }
+    /**
+     * Applies Markdown formatting (bold, italic, etc.) to text content.
+     */
+    visitFormatting(node) {
+        var _a;
+        if (node.childNodes.length === 1 && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.nodeType) === Node.TEXT_NODE) {
+            const text = this.collectTextContent(node);
+            return (0, helpers_1.applyFormatting)(text, node);
+        }
+        return (0, helpers_1.applyFormatting)(this.visitGeneric(node), node);
+    }
+    /**
+     * Converts HTML code elements to Markdown inline code syntax.
+     */
+    visitCode(node) {
+        const codeContent = this.collectCodeContent(node);
+        if (codeContent.includes('\n')) {
+            return '```\n' + codeContent + '\n```\n';
+        }
+        else if (codeContent.includes('`')) {
+            return '`` ' + codeContent + ' ``';
+        }
+        else {
+            return `\`${codeContent}\``;
+        }
+    }
+    /**
+     * Handles generic HTML elements by processing their children.
+     */
+    visitGeneric(node) {
+        return this.processChildren(node);
+    }
+    /**
+     * Converts an HTML div element to Markdown format, adding a single newline.
+     */
+    visitDiv(node) {
+        const content = this.processChildren(node);
+        return content + '\n'; // Add a single newline for <div>
+    }
+    /**
+     * Converts an HTML br element to a newline in Markdown.
+     */
+    visitBr() {
+        return '\n'; // Single newline for <br>
+    }
+    /**
+     * Converts an HTML table row element to Markdown table row format.
+     */
+    visitTableRow(node) {
+        const cells = Array.from(node.children).map((cell) => {
+            return this.visitGeneric(cell).trim() || '';
+        });
+        return '||\n' + cells.join('\n|\n') + '\n||';
+    }
+    /**
+     * Converts an HTML table element to Markdown table format.
+     */
+    visitTable(node) {
+        const rows = [];
+        const tableRows = Array.from(node.querySelectorAll('tr'));
+        tableRows.forEach((row) => {
+            rows.push(this.visitTableRow(row));
+        });
+        return '\n\n#|\n' + rows.join('\n') + '\n|#\n\n';
+    }
+    /**
+     * Converts img tag to Markdown image format
+     */
+    visitImage(node) {
+        const imgElement = node;
+        const altText = imgElement.alt || '';
+        const src = imgElement.src || '';
+        return `![${altText}](${src})`;
+    }
+    /**
+     * Processes a single node using the handler chain.
+     */
+    processNode(node) {
+        const result = this.getHandler().handle(node, this);
+        return result;
+    }
+    /**
+     * Creates and links together handlers in a specific order implementing the Chain of Responsibility pattern.
+     * @returns The first handler in the chain
+     */
+    setupHandlerChain() {
+        // Create handlers for each type of node
+        const textHandler = new handlers_1.TextNodeHandler();
+        const linkHandler = new handlers_1.LinkHandler();
+        const headerHandler = new handlers_1.HeaderHandler();
+        const paragraphHandler = new handlers_1.ParagraphHandler();
+        const formattingHandler = new handlers_1.FormattingHandler();
+        const codeHandler = new handlers_1.CodeHandler();
+        const genericHandler = new handlers_1.GenericHandler();
+        const orderedListHandler = new handlers_1.OrderedListHandler();
+        const unorderedListHandler = new handlers_1.UnorderedListHandler();
+        const divHandler = new handlers_1.DivHandler();
+        const brHandler = new handlers_1.BrHandler();
+        const tableRowHandler = new handlers_1.TableRowHandler();
+        const tableHandler = new handlers_1.TableHandler();
+        const imageHandler = new handlers_1.ImageHandler(); // New handler for <img>
+        // Chain handlers together in priority order
+        textHandler
+            .setNext(linkHandler)
+            .setNext(headerHandler)
+            .setNext(paragraphHandler)
+            .setNext(divHandler)
+            .setNext(brHandler)
+            .setNext(orderedListHandler)
+            .setNext(unorderedListHandler)
+            .setNext(formattingHandler)
+            .setNext(codeHandler)
+            .setNext(imageHandler) // Add image handler
+            .setNext(tableHandler)
+            .setNext(tableRowHandler)
+            .setNext(genericHandler);
+        return textHandler;
+    }
+    /**
+     * Recursively collects and processes text content from a node and its children.
+     */
+    collectTextContent(node) {
+        // handle seo elements (hide it's content)
+        if (node.className === 'visually-hidden') {
+            return '';
+        }
+        if (node.nodeType === Node.TEXT_NODE) {
+            return this.visitText(node);
+        }
+        return Array.from(node.childNodes)
+            .map((child) => this.collectTextContent(child))
+            .join('');
+    }
+    /**
+     * Collects raw text content from code elements.
+     */
+    collectCodeContent(node) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            return node.textContent || '';
+        }
+        return Array.from(node.childNodes)
+            .map((child) => this.collectCodeContent(child))
+            .join('');
+    }
+    /**
+     * Processes all child nodes of a given node.
+     */
+    processChildren(node) {
+        return Array.from(node.childNodes)
+            .map((child) => this.processNode(child))
+            .join('');
+    }
+    /**
+     * Gets the first handler in the chain.
+     */
+    getHandler() {
+        return this.handler;
+    }
+}
+exports.MarkdownConverter = MarkdownConverter;