html2canvas-pro 1.6.6 → 1.6.7

package/dist/html2canvas-pro.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
  */
@@ -6388,20 +6388,161 @@
                 }
             }
         }
-        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);