payload-wordpress-migrator 0.0.22

package/dist/utils/lexical/htmlToLexicalConverter.js

@@ -0,0 +1,999 @@
+import { BLOCK_ELEMENT_MAP, INLINE_FORMAT_MAP, TEXT_FORMAT_BOLD, TEXT_FORMAT_ITALIC, TEXT_FORMAT_UNDERLINE, TEXT_FORMAT_STRIKETHROUGH } from './constants.js';
+import { SimpleHTMLParser } from './htmlParser.js';
+
+class EnhancedHtmlToLexicalConverter {
+    cleanWhitespaceOnlyParagraphs(children) {
+        return children.filter((child)=>{
+            if (child.type === 'list') {
+                const list = child;
+                return list.children && list.children.length > 0;
+            }
+            if (child.type !== 'paragraph') {
+                return true;
+            }
+            const paragraph = child;
+            if (!paragraph.children || paragraph.children.length === 0) {
+                return false;
+            }
+            if (paragraph.children.length === 1 && paragraph.children[0].type === 'text') {
+                const textNode = paragraph.children[0];
+                return textNode.text.trim().length > 0;
+            }
+            return true;
+        });
+    }
+    convertBlockElement(element) {
+        const tagName = element.tagName.toLowerCase();
+        const lexicalType = BLOCK_ELEMENT_MAP[tagName];
+        switch(lexicalType){
+            case 'heading':
+                return this.convertHeading(element);
+            case 'list':
+                return this.convertList(element);
+            case 'listitem':
+                return this.convertListItem(element);
+            case 'quote':
+                return this.convertQuote(element);
+            default:
+                return this.convertParagraph(element);
+        }
+    }
+    convertChildren(children, isRoot = false, parentType) {
+        const result = [];
+        let currentParagraph = null;
+        for (const child of children){
+            if (typeof child === 'string') {
+                const normalizedText = this.normalizeTextWhitespace(child);
+                if (normalizedText) {
+                    if (isRoot) {
+                        if (!currentParagraph) {
+                            currentParagraph = this.createParagraph();
+                            result.push(currentParagraph);
+                        }
+                        const textNode = this.createTextNode(normalizedText, this.getCurrentFormat());
+                        currentParagraph.children.push(textNode);
+                    } else {
+                        const textNode = this.createTextNode(normalizedText, this.getCurrentFormat());
+                        result.push(textNode);
+                    }
+                }
+            } else {
+                const convertedNodes = this.convertElement(child, parentType);
+                for (const node of convertedNodes){
+                    if (this.isBlockElement(node)) {
+                        if (parentType === 'paragraph') {
+                            console.warn(`Preventing block element ${node.type} inside paragraph, converting to text`);
+                            if (currentParagraph && node.type === 'text') {
+                                currentParagraph.children.push(node);
+                            }
+                            continue;
+                        }
+                        if (node.type === 'block') {
+                            if (!node.fields || !node.fields.blockType) {
+                                console.error('Invalid block structure, skipping:', node);
+                                continue;
+                            }
+                        }
+                        currentParagraph = null;
+                        result.push(node);
+                    } else {
+                        if (isRoot) {
+                            if (!currentParagraph) {
+                                currentParagraph = this.createParagraph();
+                                result.push(currentParagraph);
+                            }
+                            currentParagraph.children.push(node);
+                        } else {
+                            result.push(node);
+                        }
+                    }
+                }
+            }
+        }
+        return result.filter((node)=>node !== null);
+    }
+    convertElement(element, parentType) {
+        const tagName = element.tagName.toLowerCase();
+        if (tagName === 'div') {
+            const className = element.attributes.class || '';
+            if (className.includes('wp-block-image')) {
+                const images = this.extractImagesFromElement(element);
+                if (images.length > 0) {
+                    const caption = this.extractFigcaption(element);
+                    const mediaBlock = this.convertImageWithCaption(images[0], caption);
+                    return [
+                        mediaBlock
+                    ];
+                }
+            }
+            if (className.includes('wp-block-column')) {
+                const images = this.extractImagesFromElement(element);
+                if (images.length > 0) {
+                    const hasImageBlock = this.findElementByTagName(element, 'div')?.attributes.class?.includes('wp-block-image');
+                    if (!hasImageBlock) {
+                        const caption = this.extractFigcaption(element);
+                        const mediaBlock = this.convertImageWithCaption(images[0], caption);
+                        return [
+                            mediaBlock
+                        ];
+                    }
+                }
+            }
+            if (className.includes('wp-block-embed')) {
+                const iframeBlock = this.convertWordPressEmbedBlock(element);
+                if (iframeBlock) {
+                    return [
+                        iframeBlock
+                    ];
+                }
+            }
+            if (className.includes('wp-block-wpsp-faq') && !className.includes('wp-block-wpsp-faq-child')) {
+                const accordionBlock = this.convertSchemaProFaq(element);
+                if (accordionBlock) {
+                    return [
+                        accordionBlock
+                    ];
+                }
+            }
+        }
+        if (tagName === 'div' && element.attributes.class?.includes('wp-block-image')) {
+            return this.convertWordPressImageBlock(element);
+        }
+        if (BLOCK_ELEMENT_MAP[tagName]) {
+            return [
+                this.convertBlockElement(element)
+            ];
+        }
+        if (INLINE_FORMAT_MAP[tagName]) {
+            return this.convertInlineFormatting(element);
+        }
+        switch(tagName){
+            case 'a':
+                return [
+                    this.convertLink(element)
+                ];
+            case 'br':
+                return [
+                    this.createLineBreak()
+                ];
+            case 'figure':
+                return this.convertFigure(element);
+            case 'hr':
+                return [
+                    this.createHorizontalRule()
+                ];
+            case 'iframe':
+                return [
+                    this.convertIframe(element)
+                ];
+            case 'img':
+                return [
+                    this.convertImage(element)
+                ];
+            case 'picture':
+                return this.convertPicture(element);
+            case 'span':
+                return this.convertSpan(element, parentType);
+            default:
+                return this.convertChildren(element.children, false, parentType);
+        }
+    }
+    convertFigure(element) {
+        const iframe = this.findElementByTagName(element, 'iframe');
+        if (iframe) {
+            return [
+                this.convertIframe(iframe)
+            ];
+        }
+        const images = this.extractImagesFromElement(element);
+        if (images.length > 0) {
+            const caption = this.extractFigcaption(element);
+            const mediaBlock = this.convertImageWithCaption(images[0], caption);
+            return [
+                mediaBlock
+            ];
+        }
+        return this.convertChildren(element.children, false, 'figure');
+    }
+    convertHeading(element) {
+        const children = this.convertChildren(element.children, false, 'heading');
+        return {
+            type: 'heading',
+            children: children.length > 0 ? children : [
+                this.createTextNode('', 0)
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            tag: element.tagName,
+            version: 1
+        };
+    }
+    convertIframe(element) {
+        const src = element.attributes.src || '';
+        const title = element.attributes.title || '';
+        const heightAttr = element.attributes.height || '';
+        const loadingAttr = element.attributes.loading || 'lazy';
+        let height = null;
+        if (heightAttr) {
+            const parsedHeight = parseInt(heightAttr, 10);
+            if (!isNaN(parsedHeight) && parsedHeight > 0) {
+                height = parsedHeight;
+            }
+        }
+        const normalizedUrl = this.normalizeEmbedUrl(src);
+        return {
+            type: 'block',
+            fields: {
+                id: this.generateBlockId(),
+                blockName: title || 'Embedded Content',
+                blockType: 'iframeBlock',
+                height,
+                loading: loadingAttr === 'eager' ? 'eager' : 'lazy',
+                title: title || null,
+                url: normalizedUrl
+            },
+            version: 2
+        };
+    }
+    convertImage(element) {
+        const src = element.attributes.src || '';
+        const alt = element.attributes.alt || '';
+        const title = element.attributes.title || '';
+        return {
+            type: 'block',
+            fields: {
+                id: this.generateBlockId(),
+                blockName: title || alt || 'Migrated Image',
+                blockType: 'mediaBlock',
+                media: null,
+                __migrationMeta: {
+                    alt,
+                    needsMediaImport: true,
+                    originalSrc: src,
+                    title
+                }
+            },
+            version: 2
+        };
+    }
+    convertImageWithCaption(imgElement, caption) {
+        const src = imgElement.attributes.src;
+        const alt = imgElement.attributes.alt || '';
+        const title = imgElement.attributes.title || '';
+        if (!src) {
+            console.warn('Image element missing src attribute');
+            return null;
+        }
+        const blockId = Math.random().toString(36).substring(2, 11);
+        const blockName = alt || title || 'Media Block';
+        const validCaption = caption || null;
+        const mediaBlock = {
+            type: 'block',
+            fields: {
+                id: blockId,
+                blockName,
+                blockType: 'mediaBlock',
+                media: null,
+                __migrationMeta: {
+                    alt,
+                    caption: validCaption,
+                    needsMediaImport: true,
+                    originalSrc: src,
+                    title
+                }
+            },
+            version: 2
+        };
+        if (!mediaBlock.type || !mediaBlock.fields || !mediaBlock.fields.blockType) {
+            console.error('Invalid MediaBlock structure created:', mediaBlock);
+            return null;
+        }
+        return mediaBlock;
+    }
+    convertInlineFormatting(element) {
+        const formatBit = INLINE_FORMAT_MAP[element.tagName.toLowerCase()];
+        this.formatStack.push(formatBit);
+        const result = [];
+        for (const child of element.children){
+            if (typeof child === 'string') {
+                if (child.trim()) {
+                    const textNode = this.createTextNode(child, this.getCurrentFormat());
+                    result.push(textNode);
+                }
+            } else {
+                const convertedNodes = this.convertElement(child);
+                result.push(...convertedNodes);
+            }
+        }
+        this.formatStack.pop();
+        return result;
+    }
+    convertLink(element) {
+        const href = element.attributes.href || '';
+        element.attributes.title || '';
+        const target = element.attributes.target || '';
+        element.attributes.rel || '';
+        let cleanUrl = href.trim();
+        if (!cleanUrl || cleanUrl === '#' || cleanUrl.startsWith('javascript:') || cleanUrl.length < 3) {
+            console.warn(`Converting invalid link to text: "${href}"`);
+            const children = this.convertChildren(element.children, false, 'text');
+            return children.length > 0 ? children[0] : this.createTextNode(href || 'link', 0);
+        }
+        if (!cleanUrl.startsWith('http://') && !cleanUrl.startsWith('https://') && !cleanUrl.startsWith('/') && !cleanUrl.startsWith('#') && !cleanUrl.startsWith('mailto:') && !cleanUrl.startsWith('tel:')) {
+            cleanUrl = 'https://' + cleanUrl;
+        }
+        try {
+            if (cleanUrl.startsWith('http://') || cleanUrl.startsWith('https://')) {
+                new URL(cleanUrl);
+            }
+        } catch (_error) {
+            console.warn(`Converting malformed URL to text: "${cleanUrl}"`);
+            const children = this.convertChildren(element.children, false, 'text');
+            return children.length > 0 ? children[0] : this.createTextNode(cleanUrl, 0);
+        }
+        const children = this.convertChildren(element.children, false, 'link');
+        return {
+            type: 'link',
+            children: children.length > 0 ? children : [
+                this.createTextNode(cleanUrl, 0)
+            ],
+            direction: 'ltr',
+            fields: {
+                linkType: 'custom',
+                newTab: target === '_blank',
+                url: cleanUrl
+            },
+            format: '',
+            indent: 0,
+            version: 1
+        };
+    }
+    convertList(element) {
+        const listType = element.tagName === 'ol' ? 'number' : 'bullet';
+        const children = this.convertChildren(element.children, false, 'list');
+        return {
+            type: 'list',
+            children: children.length > 0 ? children : [],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            listType,
+            start: element.attributes.start ? parseInt(element.attributes.start) : 1,
+            tag: element.tagName,
+            version: 1
+        };
+    }
+    convertListItem(element) {
+        const children = this.convertChildren(element.children, false, 'listitem');
+        return {
+            type: 'listitem',
+            children: children.length > 0 ? children : [
+                this.createTextNode('', 0)
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            value: 1,
+            version: 1
+        };
+    }
+    convertParagraph(element) {
+        const children = this.convertChildren(element.children, false, 'paragraph');
+        return {
+            type: 'paragraph',
+            children: children.length > 0 ? children : [
+                this.createTextNode('', 0)
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        };
+    }
+    convertPicture(element) {
+        const images = this.extractImagesFromElement(element);
+        if (images.length > 0) {
+            const bestSrc = this.getBestPictureSource(element) || images[0].attributes.src;
+            const enhancedImage = {
+                ...images[0],
+                attributes: {
+                    ...images[0].attributes,
+                    src: bestSrc
+                }
+            };
+            const parentFigure = this.findParentElement(element, 'figure');
+            const caption = parentFigure ? this.extractFigcaption(parentFigure) : null;
+            return [
+                this.convertImageWithCaption(enhancedImage, caption)
+            ];
+        }
+        return [];
+    }
+    convertQuote(element) {
+        const children = this.convertChildren(element.children, true, 'quote');
+        return {
+            type: 'quote',
+            children: children.length > 0 ? children : [
+                this.createEmptyParagraph()
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        };
+    }
+    // Schema Pro FAQ plugin renders FAQ items as nested divs with class-based structure:
+    //   .wp-block-wpsp-faq-child > .wpsp-question (question text)
+    //                             > .wpsp-faq-content (answer HTML)
+    // We map these to PayloadCMS accordion blocks so the content remains structured
+    // rather than being flattened into plain paragraphs.
+    convertSchemaProFaq(element) {
+        const faqItems = this.findAllElementsByClassName(element, 'wp-block-wpsp-faq-child');
+        if (faqItems.length === 0) {
+            return null;
+        }
+        const accordionItems = [];
+        for (const faqItem of faqItems){
+            const questionSpan = this.findElementByClassName(faqItem, 'wpsp-question');
+            const question = questionSpan ? this.extractTextFromElement(questionSpan) : '';
+            const answerDiv = this.findElementByClassName(faqItem, 'wpsp-faq-content');
+            let answerContent = null;
+            if (answerDiv) {
+                const answerChildren = this.convertChildren(answerDiv.children, true, 'accordion-content');
+                answerContent = {
+                    root: {
+                        type: 'root',
+                        children: answerChildren.length > 0 ? answerChildren : [
+                            this.createEmptyParagraph()
+                        ],
+                        direction: 'ltr',
+                        format: '',
+                        indent: 0,
+                        version: 1
+                    }
+                };
+            }
+            if (question) {
+                accordionItems.push({
+                    content: answerContent || {
+                        root: {
+                            type: 'root',
+                            children: [
+                                this.createEmptyParagraph()
+                            ],
+                            direction: 'ltr',
+                            format: '',
+                            indent: 0,
+                            version: 1
+                        }
+                    },
+                    title: question
+                });
+            }
+        }
+        if (accordionItems.length === 0) {
+            return null;
+        }
+        const accordionBlock = {
+            type: 'block',
+            fields: {
+                id: this.generateBlockId(),
+                accordionItems: accordionItems.map((item)=>({
+                        id: this.generateBlockId(),
+                        content: item.content,
+                        title: item.title
+                    })),
+                allowMultiple: false,
+                blockName: 'FAQ Accordion',
+                blockType: 'accordion',
+                bottomPadding: 'medium',
+                defaultOpen: 'none',
+                description: null,
+                displayMode: 'simple',
+                heading: null,
+                theme: 'light',
+                topPadding: 'medium'
+            },
+            version: 2
+        };
+        return accordionBlock;
+    }
+    convertSpan(element, parentType) {
+        const style = element.attributes.style || '';
+        let additionalFormat = 0;
+        if (style.includes('font-weight: bold') || style.includes('font-weight:bold')) {
+            additionalFormat |= TEXT_FORMAT_BOLD;
+        }
+        if (style.includes('font-style: italic') || style.includes('font-style:italic')) {
+            additionalFormat |= TEXT_FORMAT_ITALIC;
+        }
+        if (style.includes('text-decoration: underline') || style.includes('text-decoration:underline')) {
+            additionalFormat |= TEXT_FORMAT_UNDERLINE;
+        }
+        if (style.includes('text-decoration: line-through') || style.includes('text-decoration:line-through')) {
+            additionalFormat |= TEXT_FORMAT_STRIKETHROUGH;
+        }
+        if (additionalFormat > 0) {
+            this.formatStack.push(additionalFormat);
+            const children = this.convertChildren(element.children, false, parentType);
+            this.formatStack.pop();
+            return children;
+        }
+        return this.convertChildren(element.children, false, parentType);
+    }
+    convertWordPressEmbedBlock(element) {
+        const iframe = this.findElementByTagName(element, 'iframe');
+        if (iframe) {
+            return this.convertIframe(iframe);
+        }
+        const embedWrapper = this.findElementByTagName(element, 'div');
+        if (embedWrapper?.attributes.class?.includes('wp-block-embed__wrapper')) {
+            const wrapperIframe = this.findElementByTagName(embedWrapper, 'iframe');
+            if (wrapperIframe) {
+                return this.convertIframe(wrapperIframe);
+            }
+            const video = this.findElementByTagName(embedWrapper, 'video');
+            if (video?.attributes.src) {
+                return {
+                    type: 'block',
+                    fields: {
+                        id: this.generateBlockId(),
+                        blockName: 'Video Embed',
+                        blockType: 'iframeBlock',
+                        height: null,
+                        loading: 'lazy',
+                        title: null,
+                        url: video.attributes.src
+                    },
+                    version: 2
+                };
+            }
+        }
+        const blockquote = this.findElementByTagName(element, 'blockquote');
+        if (blockquote) {
+            const link = this.findElementByTagName(blockquote, 'a');
+            if (link?.attributes.href) {
+                const href = link.attributes.href;
+                if (href.includes('twitter.com') || href.includes('x.com')) {
+                    return {
+                        type: 'block',
+                        fields: {
+                            id: this.generateBlockId(),
+                            blockName: 'Twitter Embed',
+                            blockType: 'iframeBlock',
+                            height: 400,
+                            loading: 'lazy',
+                            title: 'Twitter Post',
+                            url: href
+                        },
+                        version: 2
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    convertWordPressImageBlock(element) {
+        const images = this.extractImagesFromElement(element);
+        if (images.length > 0) {
+            const caption = this.extractFigcaption(element);
+            const mediaBlock = this.convertImageWithCaption(images[0], caption);
+            return [
+                mediaBlock
+            ];
+        }
+        return [
+            this.convertBlockElement(element)
+        ];
+    }
+    extractTextFromElement(element) {
+        let text = '';
+        for (const child of element.children){
+            if (typeof child === 'string') {
+                text += child;
+            } else {
+                text += this.extractTextFromElement(child);
+            }
+        }
+        return text.trim();
+    }
+    createEmptyParagraph() {
+        return {
+            type: 'paragraph',
+            children: [
+                this.createTextNode('', 0)
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        };
+    }
+    findAllElementsByClassName(element, className) {
+        const results = [];
+        const search = (el)=>{
+            if (el.attributes.class?.includes(className)) {
+                results.push(el);
+            }
+            for (const child of el.children){
+                if (typeof child !== 'string') {
+                    search(child);
+                }
+            }
+        };
+        search(element);
+        return results;
+    }
+    findElementByClassName(element, className) {
+        if (element.attributes.class?.includes(className)) {
+            return element;
+        }
+        for (const child of element.children){
+            if (typeof child !== 'string') {
+                const found = this.findElementByClassName(child, className);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+    createEmptyRoot() {
+        return {
+            root: {
+                type: 'root',
+                children: [
+                    this.createEmptyParagraph()
+                ],
+                direction: 'ltr',
+                format: '',
+                indent: 0,
+                version: 1
+            }
+        };
+    }
+    createHorizontalRule() {
+        return {
+            type: 'horizontalrule',
+            version: 1
+        };
+    }
+    createLineBreak() {
+        return {
+            type: 'linebreak',
+            version: 1
+        };
+    }
+    createParagraph() {
+        return {
+            type: 'paragraph',
+            children: [],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        };
+    }
+    createTextNode(text, format) {
+        return {
+            type: 'text',
+            detail: 0,
+            format,
+            mode: 'normal',
+            style: '',
+            text,
+            version: 1
+        };
+    }
+    extractFigcaption(element) {
+        const figcaption = this.findElementByTagName(element, 'figcaption');
+        if (figcaption) {
+            const captionChildren = this.convertChildren(figcaption.children, false, 'figcaption');
+            if (captionChildren.length > 0) {
+                const captionData = {
+                    root: {
+                        type: 'root',
+                        children: captionChildren.length > 0 ? captionChildren : [
+                            this.createEmptyParagraph()
+                        ],
+                        direction: 'ltr',
+                        format: '',
+                        indent: 0,
+                        version: 1
+                    }
+                };
+                return captionData;
+            }
+        }
+        return null;
+    }
+    extractFilename(url) {
+        try {
+            const urlParts = new URL(url);
+            const pathParts = urlParts.pathname.split('/');
+            return pathParts[pathParts.length - 1] || 'image';
+        } catch  {
+            return 'image';
+        }
+    }
+    extractImagesFromElement(element) {
+        const images = [];
+        if (element.tagName.toLowerCase() === 'img') {
+            images.push(element);
+        }
+        if (element.children) {
+            for (const child of element.children){
+                if (typeof child === 'object' && child.tagName) {
+                    const childImages = this.extractImagesFromElement(child);
+                    images.push(...childImages);
+                }
+            }
+        }
+        return images;
+    }
+    extractTextFromChildren(children) {
+        let text = '';
+        for (const child of children){
+            if (child.type === 'text') {
+                text += child.text + ' ';
+            } else if (child.children && Array.isArray(child.children)) {
+                text += this.extractTextFromChildren(child.children) + ' ';
+            }
+        }
+        return text.trim();
+    }
+    extractTextFromNode(node) {
+        if (node.type === 'text') {
+            return node.text || '';
+        }
+        if (node.children && Array.isArray(node.children)) {
+            return node.children.map((child)=>this.extractTextFromNode(child)).join('');
+        }
+        return '';
+    }
+    fallbackConversion(htmlContent) {
+        const text = htmlContent.replace(/<[^>]*>/g, '').trim() || '';
+        return {
+            root: {
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                type: 'text',
+                                detail: 0,
+                                format: 0,
+                                mode: 'normal',
+                                style: '',
+                                text,
+                                version: 1
+                            }
+                        ],
+                        direction: 'ltr',
+                        format: '',
+                        indent: 0,
+                        version: 1
+                    }
+                ],
+                direction: 'ltr',
+                format: '',
+                indent: 0,
+                version: 1
+            }
+        };
+    }
+    findElementByTagName(element, tagName) {
+        if (element.tagName.toLowerCase() === tagName.toLowerCase()) {
+            return element;
+        }
+        if (element.children) {
+            for (const child of element.children){
+                if (typeof child === 'object' && child.tagName) {
+                    const found = this.findElementByTagName(child, tagName);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    findElementsByTagName(element, tagName) {
+        const results = [];
+        if (element.tagName.toLowerCase() === tagName.toLowerCase()) {
+            results.push(element);
+        }
+        if (element.children) {
+            for (const child of element.children){
+                if (typeof child === 'object' && child.tagName) {
+                    results.push(...this.findElementsByTagName(child, tagName));
+                }
+            }
+        }
+        return results;
+    }
+    findParentElement(element, tagName) {
+        return null;
+    }
+    generateBlockId() {
+        return Math.random().toString(36).substr(2, 9);
+    }
+    getBestPictureSource(element) {
+        const sources = this.findElementsByTagName(element, 'source');
+        for (const source of sources){
+            if (source.attributes.type === 'image/webp' && source.attributes.srcset) {
+                const srcset = source.attributes.srcset;
+                const firstUrl = srcset.split(',')[0].trim().split(' ')[0];
+                return firstUrl;
+            }
+        }
+        for (const source of sources){
+            if (source.attributes.srcset) {
+                const srcset = source.attributes.srcset;
+                const firstUrl = srcset.split(',')[0].trim().split(' ')[0];
+                return firstUrl;
+            }
+        }
+        return null;
+    }
+    normalizeTextWhitespace(text) {
+        if (!text) {
+            return '';
+        }
+        const hasLeadingSpace = /^\s/.test(text);
+        const hasTrailingSpace = /\s$/.test(text);
+        const normalized = text.replace(/\s+/g, ' ').trim();
+        if (!normalized && (hasLeadingSpace || hasTrailingSpace)) {
+            return ' ';
+        }
+        if (!normalized) {
+            return '';
+        }
+        let result = normalized;
+        if (hasLeadingSpace) {
+            result = ' ' + result;
+        }
+        if (hasTrailingSpace) {
+            result = result + ' ';
+        }
+        return result;
+    }
+    getCurrentFormat() {
+        return this.formatStack.reduce((format, bit)=>format | bit, 0);
+    }
+    getMimeTypeFromUrl(url) {
+        const extension = url.split('.').pop()?.toLowerCase();
+        const mimeTypes = {
+            gif: 'image/gif',
+            jpeg: 'image/jpeg',
+            jpg: 'image/jpeg',
+            png: 'image/png',
+            svg: 'image/svg+xml',
+            webp: 'image/webp'
+        };
+        return mimeTypes[extension || ''] || 'image/jpeg';
+    }
+    isBlockElement(node) {
+        if (!node || typeof node !== 'object') {
+            return false;
+        }
+        const blockTypes = [
+            'paragraph',
+            'heading',
+            'quote',
+            'list',
+            'listitem',
+            'horizontalrule',
+            'block'
+        ];
+        return blockTypes.includes(node.type);
+    }
+    isValidLexicalNode(node) {
+        if (!node || typeof node !== 'object') {
+            return false;
+        }
+        if (!node.type || typeof node.type !== 'string') {
+            return false;
+        }
+        if (node.type === 'text') {
+            return typeof node.text === 'string' && typeof node.format === 'number' && typeof node.version === 'number';
+        }
+        if ([
+            'heading',
+            'link',
+            'list',
+            'listitem',
+            'paragraph',
+            'quote'
+        ].includes(node.type)) {
+            return Array.isArray(node.children) && typeof node.version === 'number';
+        }
+        return typeof node.version === 'number';
+    }
+    normalizeEmbedUrl(url) {
+        if (!url) {
+            return url;
+        }
+        try {
+            const urlObj = new URL(url);
+            if (urlObj.hostname === 'www.youtube.com' || urlObj.hostname === 'youtube.com') {
+                const videoId = urlObj.searchParams.get('v');
+                if (videoId) {
+                    return `https://www.youtube.com/embed/${videoId}`;
+                }
+            }
+            if (urlObj.hostname === 'youtu.be') {
+                const videoId = urlObj.pathname.slice(1);
+                if (videoId) {
+                    return `https://www.youtube.com/embed/${videoId}`;
+                }
+            }
+            if (urlObj.hostname === 'vimeo.com' || urlObj.hostname === 'www.vimeo.com') {
+                const videoId = urlObj.pathname.split('/').pop();
+                if (videoId && /^\d+$/.test(videoId)) {
+                    return `https://player.vimeo.com/video/${videoId}`;
+                }
+            }
+        } catch  {
+        // Invalid URL, return as-is
+        }
+        return url;
+    }
+    sanitizeHtmlContent(htmlContent) {
+        try {
+            return htmlContent.replace(/<script[^>]*>.*?<\/script>/gis, '').replace(/<style[^>]*>.*?<\/style>/gis, '').replace(/<!--[\s\S]*?-->/g, '').replace(/<(h[1-6])([^>]*)>\s*<(strong|b)>([^<]*)<\/\3>\s*<\/\1>/gi, '<$1$2>$4</$1>').replace(/<(h[1-6])([^>]*)>\s*<(strong|b)[^>]*>([^<]*)<\/\3>\s*<\/\1>/gi, '<$1$2>$4</$1>').replace(/<br(?:\s[^>]*)?\/?>/gi, '<br />').replace(/<hr(?:\s[^>]*)?\/?>/gi, '<hr />').replace(/<img([^>]*?)(?:\s?\/)?>(?!\s*<\/img>)/gi, '<img$1 />').replace(/\s+(?:id|style)=""\s*/g, ' ').replace(/\s+/g, ' ').trim();
+        } catch (error) {
+            console.warn('HTML sanitization failed, using original content:', error);
+            return htmlContent;
+        }
+    }
+    convertHtmlToLexical(htmlContent) {
+        try {
+            if (!htmlContent || htmlContent.trim() === '') {
+                return this.createEmptyRoot();
+            }
+            const sanitizedContent = this.sanitizeHtmlContent(htmlContent);
+            const parser = new SimpleHTMLParser(sanitizedContent);
+            const parsedHtml = parser.parse();
+            const children = this.convertChildren(parsedHtml.children, true);
+            const validChildren = children.filter((child)=>{
+                if (!child) {
+                    console.warn('Filtering out null/undefined child');
+                    return false;
+                }
+                if (child.type === 'block' && (!child.fields || !child.fields.blockType)) {
+                    console.warn('Filtering out invalid block with missing fields');
+                    return false;
+                }
+                return true;
+            });
+            const result = {
+                root: {
+                    type: 'root',
+                    children: validChildren,
+                    direction: 'ltr',
+                    format: '',
+                    indent: 0,
+                    version: 1
+                }
+            };
+            return result;
+        } catch (error) {
+            console.warn('HTML to Lexical conversion failed, falling back to simple conversion:', error);
+            console.warn('Problematic content preview:', htmlContent?.substring(0, 200) || 'N/A');
+            return this.fallbackConversion(htmlContent);
+        }
+    }
+    constructor(){
+        this.formatStack = [];
+    }
+}
+const enhancedHtmlToLexicalConverter = new EnhancedHtmlToLexicalConverter();
+const convertHtmlToLexical = (htmlContent)=>{
+    return enhancedHtmlToLexicalConverter.convertHtmlToLexical(htmlContent);
+};
+
+export { EnhancedHtmlToLexicalConverter, convertHtmlToLexical, enhancedHtmlToLexicalConverter };
+//# sourceMappingURL=htmlToLexicalConverter.js.map