html2canvas-pro 1.6.6 → 1.6.7

package/dist/html2canvas-pro.esm.js

@@ -1,5 +1,5 @@
 /*!
- * html2canvas-pro 1.6.6 <https://yorickshan.github.io/html2canvas-pro/>
+ * html2canvas-pro 1.6.7 <https://yorickshan.github.io/html2canvas-pro/>
  * Copyright (c) 2024-present yorickshan and html2canvas-pro contributors
  * Released under MIT License
  */
@@ -6382,20 +6382,161 @@ class DocumentCloner {
             }
         }
     }
-    cloneChildNodes(node, clone, copyStyles) {
-        // Clone shadow DOM content if it exists
-        if (node.shadowRoot && clone.shadowRoot) {
-            for (let child = node.shadowRoot.firstChild; child; child = child.nextSibling) {
-                // Clone all shadow DOM children including <slot> elements
-                // The browser will automatically handle slot assignment
-                clone.shadowRoot.appendChild(this.cloneNode(child, copyStyles));
+    /**
+     * Check if a child node should be cloned based on filtering rules
+     * Filters out: scripts, ignored elements, and optionally styles
+     */
+    shouldCloneChild(child) {
+        return (!isElementNode(child) ||
+            (!isScriptElement(child) &&
+                !child.hasAttribute(IGNORE_ATTRIBUTE) &&
+                (typeof this.options.ignoreElements !== 'function' || !this.options.ignoreElements(child))));
+    }
+    /**
+     * Check if a style element should be cloned based on copyStyles option
+     */
+    shouldCloneStyleElement(child) {
+        return !this.options.copyStyles || !isElementNode(child) || !isStyleElement(child);
+    }
+    /**
+     * Safely append a cloned child to a target, applying all filtering rules
+     */
+    safeAppendClonedChild(target, child, copyStyles) {
+        if (this.shouldCloneChild(child) && this.shouldCloneStyleElement(child)) {
+            target.appendChild(this.cloneNode(child, copyStyles));
+        }
+    }
+    /**
+     * Clone assigned nodes from a slot element to the target
+     */
+    cloneAssignedNodes(assignedNodes, target, copyStyles) {
+        assignedNodes.forEach((node) => {
+            this.safeAppendClonedChild(target, node, copyStyles);
+        });
+    }
+    /**
+     * Clone fallback content from a slot element when no nodes are assigned
+     */
+    cloneSlotFallbackContent(slot, target, copyStyles) {
+        for (let child = slot.firstChild; child; child = child.nextSibling) {
+            this.safeAppendClonedChild(target, child, copyStyles);
+        }
+    }
+    /**
+     * Handle cloning of a slot element, including assigned nodes or fallback content
+     */
+    cloneSlotElement(slot, targetShadowRoot, copyStyles) {
+        if (!isSlotElement(slot)) {
+            return;
+        }
+        const slotElement = slot;
+        // Defensive check: ensure assignedNodes method exists
+        if (typeof slotElement.assignedNodes !== 'function') {
+            this.context.logger.warn('HTMLSlotElement.assignedNodes is not available', slot);
+            this.cloneSlotFallbackContent(slot, targetShadowRoot, copyStyles);
+            return;
+        }
+        const assignedNodes = slotElement.assignedNodes();
+        // Defensive check: ensure assignedNodes returns an array
+        if (!assignedNodes || !Array.isArray(assignedNodes)) {
+            this.context.logger.warn('assignedNodes() did not return a valid array', slot);
+            this.cloneSlotFallbackContent(slot, targetShadowRoot, copyStyles);
+            return;
+        }
+        if (assignedNodes.length > 0) {
+            // Clone assigned nodes
+            this.cloneAssignedNodes(assignedNodes, targetShadowRoot, copyStyles);
+        }
+        else {
+            // Clone fallback content
+            this.cloneSlotFallbackContent(slot, targetShadowRoot, copyStyles);
+        }
+    }
+    /**
+     * Clone shadow DOM children to the target shadow root
+     */
+    cloneShadowDOMChildren(shadowRoot, targetShadowRoot, copyStyles) {
+        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {
+            if (isElementNode(child) && isSlotElement(child)) {
+                // Handle slot elements specially
+                this.cloneSlotElement(child, targetShadowRoot, copyStyles);
+            }
+            else {
+                // Clone regular elements
+                this.safeAppendClonedChild(targetShadowRoot, child, copyStyles);
             }
         }
-        // Clone light DOM content (always, even if shadow DOM exists)
+    }
+    /**
+     * Clone light DOM children to the target element
+     */
+    cloneLightDOMChildren(node, clone, copyStyles) {
         for (let child = node.firstChild; child; child = child.nextSibling) {
             this.appendChildNode(clone, child, copyStyles);
         }
     }
+    /**
+     * Clone slot element as light DOM when shadow root creation failed
+     */
+    cloneSlotElementAsLightDOM(slot, clone, copyStyles) {
+        if (!isSlotElement(slot)) {
+            return;
+        }
+        const slotElement = slot;
+        if (typeof slotElement.assignedNodes !== 'function') {
+            // Fallback: clone slot's children
+            for (let child = slot.firstChild; child; child = child.nextSibling) {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+            return;
+        }
+        const assignedNodes = slotElement.assignedNodes();
+        if (assignedNodes && Array.isArray(assignedNodes) && assignedNodes.length > 0) {
+            // Clone assigned nodes as light DOM
+            assignedNodes.forEach((node) => this.appendChildNode(clone, node, copyStyles));
+        }
+        else {
+            // Clone fallback content as light DOM
+            for (let child = slot.firstChild; child; child = child.nextSibling) {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+        }
+    }
+    /**
+     * Clone shadow DOM content as light DOM when shadow root creation failed
+     * This is a fallback mechanism to ensure content is not lost
+     */
+    cloneShadowDOMAsLightDOM(shadowRoot, clone, copyStyles) {
+        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {
+            if (isElementNode(child) && isSlotElement(child)) {
+                this.cloneSlotElementAsLightDOM(child, clone, copyStyles);
+            }
+            else {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+        }
+    }
+    /**
+     * Clone child nodes from source element to clone element
+     * Handles shadow DOM, slots, and light DOM appropriately
+     */
+    cloneChildNodes(node, clone, copyStyles) {
+        if (node.shadowRoot && clone.shadowRoot) {
+            // Both original and clone have shadow roots - clone shadow DOM content
+            this.cloneShadowDOMChildren(node.shadowRoot, clone.shadowRoot, copyStyles);
+            // Also clone light DOM (slot content sources)
+            this.cloneLightDOMChildren(node, clone, copyStyles);
+        }
+        else if (node.shadowRoot && !clone.shadowRoot) {
+            // Original has shadow root but clone doesn't (creation failed)
+            // Fallback: clone shadow DOM content as light DOM to preserve content
+            this.cloneShadowDOMAsLightDOM(node.shadowRoot, clone, copyStyles);
+        }
+        else {
+            // No shadow DOM - just clone light DOM children
+            this.cloneLightDOMChildren(node, clone, copyStyles);
+        }
+    }
     cloneNode(node, copyStyles) {
         if (isTextNode(node)) {
             return document.createTextNode(node.data);