officeparser 7.7.0 → 7.8.0

package/dist/parsers/HtmlParser.js

@@ -558,6 +558,32 @@ const parseHtml = async (buffer, config) => {
                 }
                 return kids;
             };
+            // Gated generic-iframe embed (HtmlGenerator's `gatedEmbeds` shape): an inert
+            // click-to-load placeholder that never auto-loads its src. Read it back to the same
+            // `embed` node unconditionally - capturing metadata is safe (the src is scheme-checked
+            // again on any re-emit); it is the trusted, already-gated counterpart to a raw <iframe>.
+            if (tagName === 'div' && node.attributes?.['data-embed-gated'] !== undefined) {
+                const gatedSrc = decodeEntities(node.attributes?.['data-embed-src'] || '');
+                if (!gatedSrc)
+                    return null;
+                const gatedAlignAttr = node.attributes?.['data-embed-align'];
+                const gatedAlign = ['left', 'center', 'right'].includes(gatedAlignAttr) ? gatedAlignAttr : undefined;
+                const gatedNode = {
+                    type: 'embed',
+                    text: gatedSrc,
+                    metadata: {
+                        embedType: 'iframe',
+                        url: gatedSrc,
+                        width: node.attributes?.['data-embed-width'],
+                        height: node.attributes?.['data-embed-height'],
+                        align: gatedAlign,
+                        label: node.attributes?.['data-embed-label']
+                    }
+                };
+                if (config.includeRawContent)
+                    gatedNode.rawContent = '<div data-embed-gated>...</div>';
+                return gatedNode;
+            }
             // YouTube embeds: attribute-driven editors render
             // <div data-youtube-video="ID" data-width="…" data-align="…">…<iframe…></div>.
             // Recognise both the wrapper div and a bare iframe so externally-authored HTML
@@ -578,7 +604,8 @@ const parseHtml = async (buffer, config) => {
                         videoId,
                         url: embedUrl,
                         width,
-                        align: embedAlign
+                        align: embedAlign,
+                        label: node.attributes?.['data-embed-label']
                     }
                 };
                 if (config.includeRawContent)
@@ -593,7 +620,15 @@ const parseHtml = async (buffer, config) => {
                     const embedNode = {
                         type: 'embed',
                         text: embedUrl,
-                        metadata: { embedType: 'youtube', videoId: ytMatch[1], url: embedUrl }
+                        // Carry the iframe's own width/height so a YouTube iframe's dimensions are not
+                        // dropped (metadata is unified across embedTypes; align has no source here).
+                        metadata: {
+                            embedType: 'youtube',
+                            videoId: ytMatch[1],
+                            url: embedUrl,
+                            width: node.attributes?.width,
+                            height: node.attributes?.height
+                        }
                     };
                     if (config.includeRawContent)
                         embedNode.rawContent = '<iframe>...</iframe>';

package/dist/parsers/MarkdownParser.js

@@ -262,6 +262,37 @@ const parseMarkdown = async (buffer, config) => {
         }
         return result;
     };
+    // Attribute list for an embed leaf directive `{id=... src=... width=... height=... align=...}`.
+    // Superset of parseAttributeList (adds id/src/height); space-separated `k=v` tokens.
+    const parseEmbedDirectiveAttrs = (attrStr) => {
+        const result = {};
+        for (const token of attrStr.trim().split(/\s+/).filter(Boolean)) {
+            const kv = token.match(/^([a-zA-Z-]+)=(.+)$/);
+            if (!kv)
+                continue;
+            const [, key, val] = kv;
+            if (key === 'id')
+                result.id = val;
+            else if (key === 'src')
+                result.src = val;
+            else if (key === 'width')
+                result.width = val;
+            else if (key === 'height')
+                result.height = val;
+            else if (key === 'align' && ['left', 'center', 'right'].includes(val))
+                result.align = val;
+        }
+        return result;
+    };
+    // Extracts a YouTube video id from any of its URL shapes (watch?v=, youtu.be/, /embed/,
+    // img.youtube.com/vi/). Returns undefined for a non-YouTube URL. Used only by the opt-in
+    // folk-form import (embedFolkForms).
+    const extractYoutubeId = (url) => {
+        if (!url || !/(?:youtu\.be|youtube(?:-nocookie)?\.com)/.test(url))
+            return undefined;
+        const m = url.match(/(?:youtu\.be\/|\/embed\/|[?&]v=|\/vi\/)([A-Za-z0-9_-]+)/);
+        return m ? m[1] : undefined;
+    };
     const parseInline = (text, currentFormatting = {}) => {
         const nodes = [];
         const plainText = (t) => ({ type: 'text', text: t, formatting: Object.keys(currentFormatting).length > 0 ? { ...currentFormatting } : undefined });
@@ -697,6 +728,63 @@ const parseMarkdown = async (buffer, config) => {
             alignment = (alignMatch[1] || alignMatch[2]).toLowerCase();
             block = alignMatch[3];
         }
+        // Embed leaf directive (remark-directive family): `::youtube[Label]{id=... width=... align=...}`
+        // or `::embed[Label]{src=... width=... height=... align=...}`. Only these two names are
+        // recognised; any other `::name` stays literal text (no catch-all). `::youtube` renders from
+        // a validated id via a fixed template, so it is unconditional; `::embed` carries an arbitrary
+        // src, so it is gated behind `preserveIframes` (the trust input) exactly like a raw <iframe>,
+        // and stays literal text otherwise. New input only; nothing that parsed before changes.
+        const embedDirectiveMatch = block.match(/^::(youtube|embed)(?:\[([^\]]*)\])?\{([^}]*)\}$/);
+        if (embedDirectiveMatch) {
+            const kind = embedDirectiveMatch[1];
+            const label = (embedDirectiveMatch[2] || '').trim() || undefined;
+            const attrs = parseEmbedDirectiveAttrs(embedDirectiveMatch[3]);
+            if (kind === 'youtube' && attrs.id) {
+                const embedUrl = `https://www.youtube.com/watch?v=${attrs.id}`;
+                content.push({
+                    type: 'embed',
+                    text: embedUrl,
+                    metadata: { embedType: 'youtube', videoId: attrs.id, url: embedUrl, width: attrs.width, align: attrs.align, label }
+                });
+                continue;
+            }
+            if (kind === 'embed' && attrs.src && (0, sanitize_js_1.iframeAllowed)(attrs.src, config.htmlParserConfig?.preserveIframes)) {
+                content.push({
+                    type: 'embed',
+                    text: attrs.src,
+                    metadata: { embedType: 'iframe', url: attrs.src, width: attrs.width, height: attrs.height, align: attrs.align, label }
+                });
+                continue;
+            }
+            // Recognised name but not a usable/allowed directive: fall through so the line becomes
+            // ordinary text rather than being dropped.
+        }
+        // Ambiguous "folk" embed forms, imported only under the opt-in (embedFolkForms), since
+        // auto-upgrading an image/link to an embed is a heuristic that could mangle a genuine image
+        // link. Both become a safe youtube embed (rendered from the validated id). A standalone line
+        // only; anything not matching falls through to ordinary image/link parsing.
+        if (config.htmlParserConfig?.embedFolkForms) {
+            // Clickable thumbnail: [![alt](thumb)](watch), youtube when either URL is a youtube link.
+            const thumbMatch = block.match(/^\[!\[([^\]]*)\]\(([^)\s]+)\)\]\(([^)\s]+)\)$/);
+            if (thumbMatch) {
+                const fid = extractYoutubeId(thumbMatch[2]) || extractYoutubeId(thumbMatch[3]);
+                if (fid) {
+                    const embedUrl = `https://www.youtube.com/watch?v=${fid}`;
+                    content.push({ type: 'embed', text: embedUrl, metadata: { embedType: 'youtube', videoId: fid, url: embedUrl, label: thumbMatch[1].trim() || undefined } });
+                    continue;
+                }
+            }
+            // Obsidian-style: a standalone image whose URL is a youtube link.
+            const obsMatch = block.match(/^!\[([^\]]*)\]\(([^)\s]+)\)$/);
+            if (obsMatch) {
+                const fid = extractYoutubeId(obsMatch[2]);
+                if (fid) {
+                    const embedUrl = `https://www.youtube.com/watch?v=${fid}`;
+                    content.push({ type: 'embed', text: embedUrl, metadata: { embedType: 'youtube', videoId: fid, url: embedUrl, label: obsMatch[1].trim() || undefined } });
+                    continue;
+                }
+            }
+        }
         // YouTube embed fallback: MarkdownGenerator's 'embed' case emits a single-line
         // <div data-youtube-video="ID" data-width="…" data-align="…"></div> when fallbackToHtml
         // is on; recognise it here so a saved-then-reopened .md keeps the video.
@@ -706,6 +794,7 @@ const parseMarkdown = async (buffer, config) => {
             const attrsStr = youtubeMatch[2];
             const widthMatch = attrsStr.match(/data-width="([^"]*)"/i);
             const youtubeAlignMatch = attrsStr.match(/data-align="([^"]*)"/i);
+            const youtubeLabelMatch = attrsStr.match(/data-embed-label="([^"]*)"/i);
             const embedAlign = youtubeAlignMatch && ['left', 'center', 'right'].includes(youtubeAlignMatch[1]) ? youtubeAlignMatch[1] : undefined;
             const embedUrl = videoId ? `https://www.youtube.com/watch?v=${videoId}` : undefined;
             content.push({
@@ -718,7 +807,8 @@ const parseMarkdown = async (buffer, config) => {
                     videoId,
                     url: embedUrl,
                     width: widthMatch?.[1],
-                    align: embedAlign
+                    align: embedAlign,
+                    label: youtubeLabelMatch?.[1]
                 }
             });
             continue;
@@ -737,9 +827,29 @@ const parseMarkdown = async (buffer, config) => {
                 .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"')
                 .replace(/&#39;/g, '\'').replace(/&amp;/g, '&');
             const src = decodeAttr(attrsStr.match(/\bsrc="([^"]*)"/i)?.[1]);
+            const width = attrsStr.match(/\bwidth="([^"]*)"/i)?.[1];
+            const height = attrsStr.match(/\bheight="([^"]*)"/i)?.[1];
+            // A YouTube iframe is recognised the same way the HTML parser does it (host + id
+            // capture), BEFORE and INDEPENDENT of the preserveIframes gate, so the same iframe
+            // yields the same 'youtube' embed whichever parser sees it. Only a generic (non-YouTube)
+            // iframe is gated behind preserveIframes and kept as an 'iframe' embed.
+            const ytMatch = src && /youtube(?:-nocookie)?\.com/.test(src) ? src.match(/(?:embed\/|v=)([^&?/\s]+)/) : null;
+            if (ytMatch) {
+                const embedUrl = `https://www.youtube.com/watch?v=${ytMatch[1]}`;
+                content.push({
+                    type: 'embed',
+                    text: embedUrl,
+                    metadata: {
+                        embedType: 'youtube',
+                        videoId: ytMatch[1],
+                        url: embedUrl,
+                        width: width !== undefined ? decodeAttr(width) : undefined,
+                        height: height !== undefined ? decodeAttr(height) : undefined
+                    }
+                });
+                continue;
+            }
             if (src && (0, sanitize_js_1.iframeAllowed)(src, config.htmlParserConfig?.preserveIframes)) {
-                const width = attrsStr.match(/\bwidth="([^"]*)"/i)?.[1];
-                const height = attrsStr.match(/\bheight="([^"]*)"/i)?.[1];
                 content.push({
                     type: 'embed',
                     text: src,