npm - html2canvas-pro - Versions diffs - 2.1.1 → 2.2.0 - Mend

html2canvas-pro 2.1.1 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (90) hide show

package/dist/html2canvas-pro.esm.js +10226 -10540
package/dist/html2canvas-pro.esm.js.map +1 -1
package/dist/html2canvas-pro.js +10869 -11185
package/dist/html2canvas-pro.js.map +1 -1
package/dist/html2canvas-pro.min.js +8 -8
package/dist/lib/config.js +0 -22
package/dist/lib/core/cache-storage.js +1 -38
package/dist/lib/core/constants.js +25 -0
package/dist/lib/core/context.js +1 -0
package/dist/lib/core/features.js +1 -0
package/dist/lib/core/validator.js +3 -3
package/dist/lib/css/grouped/background-styles.js +36 -0
package/dist/lib/css/grouped/border-styles.js +75 -0
package/dist/lib/css/grouped/font-styles.js +93 -0
package/dist/lib/css/grouped/layout-styles.js +127 -0
package/dist/lib/css/index.js +74 -46
package/dist/lib/css/layout/text.js +7 -6
package/dist/lib/css/property-descriptors/background-blend-mode.js +41 -0
package/dist/lib/css/property-descriptors/border-image-repeat.js +42 -0
package/dist/lib/css/property-descriptors/border-image-slice.js +45 -0
package/dist/lib/css/property-descriptors/border-image-source.js +21 -0
package/dist/lib/css/property-descriptors/border-radius.js +1 -1
package/dist/lib/css/property-descriptors/box-decoration-break.js +18 -0
package/dist/lib/css/property-descriptors/counter-increment.js +17 -12
package/dist/lib/css/property-descriptors/counter-reset.js +4 -12
package/dist/lib/css/property-descriptors/filter.js +76 -0
package/dist/lib/css/property-descriptors/font-variant-ligatures.js +34 -0
package/dist/lib/css/property-descriptors/object-fit.js +1 -1
package/dist/lib/css/property-descriptors/object-position.js +42 -0
package/dist/lib/css/property-descriptors/visibility.js +1 -1
package/dist/lib/css/property-descriptors/zoom.js +18 -0
package/dist/lib/css/syntax/parser.js +0 -1
package/dist/lib/css/types/color.js +5 -1
package/dist/lib/css/types/functions/repeating-linear-gradient.js +9 -0
package/dist/lib/css/types/image.js +12 -2
package/dist/lib/css/types/length-percentage.js +6 -2
package/dist/lib/css/types/safe-eval.js +80 -0
package/dist/lib/dom/document-cloner.js +23 -163
package/dist/lib/dom/slot-cloner.js +176 -0
package/dist/lib/index.js +1 -17
package/dist/lib/render/canvas/background-renderer.js +165 -32
package/dist/lib/render/canvas/border-image-renderer.js +153 -0
package/dist/lib/render/canvas/canvas-renderer.js +34 -189
package/dist/lib/render/canvas/content-renderer.js +202 -0
package/dist/lib/render/canvas/effects-renderer.js +3 -0
package/dist/lib/render/canvas/text/text-decoration-renderer.js +99 -0
package/dist/lib/render/canvas/text-renderer.js +100 -224
package/dist/lib/render/effects.js +38 -3
package/dist/lib/render/object-fit.js +19 -15
package/dist/lib/render/stacking-context.js +11 -0
package/dist/types/config.d.ts +0 -10
package/dist/types/core/cache-storage.d.ts +0 -24
package/dist/types/core/constants.d.ts +22 -0
package/dist/types/core/context.d.ts +3 -0
package/dist/types/core/performance-monitor.d.ts +4 -4
package/dist/types/core/validator.d.ts +6 -8
package/dist/types/css/grouped/background-styles.d.ts +16 -0
package/dist/types/css/grouped/border-styles.d.ts +31 -0
package/dist/types/css/grouped/font-styles.d.ts +35 -0
package/dist/types/css/grouped/layout-styles.d.ts +46 -0
package/dist/types/css/index.d.ts +30 -0
package/dist/types/css/property-descriptors/background-blend-mode.d.ts +23 -0
package/dist/types/css/property-descriptors/border-image-repeat.d.ts +12 -0
package/dist/types/css/property-descriptors/border-image-slice.d.ts +10 -0
package/dist/types/css/property-descriptors/border-image-source.d.ts +4 -0
package/dist/types/css/property-descriptors/box-decoration-break.d.ts +6 -0
package/dist/types/css/property-descriptors/counter-increment.d.ts +3 -0
package/dist/types/css/property-descriptors/filter.d.ts +3 -0
package/dist/types/css/property-descriptors/font-variant-ligatures.d.ts +14 -0
package/dist/types/css/property-descriptors/object-position.d.ts +4 -0
package/dist/types/css/property-descriptors/zoom.d.ts +3 -0
package/dist/types/css/types/functions/repeating-linear-gradient.d.ts +4 -0
package/dist/types/css/types/image.d.ts +4 -2
package/dist/types/css/types/safe-eval.d.ts +8 -0
package/dist/types/dom/document-cloner.d.ts +3 -44
package/dist/types/dom/slot-cloner.d.ts +66 -0
package/dist/types/index.d.ts +3 -7
package/dist/types/options.d.ts +11 -0
package/dist/types/render/canvas/background-renderer.d.ts +23 -0
package/dist/types/render/canvas/border-image-renderer.d.ts +18 -0
package/dist/types/render/canvas/canvas-renderer.d.ts +1 -0
package/dist/types/render/canvas/content-renderer.d.ts +44 -0
package/dist/types/render/canvas/text/text-decoration-renderer.d.ts +18 -0
package/dist/types/render/canvas/text-renderer.d.ts +12 -1
package/dist/types/render/effects.d.ts +12 -2
package/dist/types/render/object-fit.d.ts +2 -1
package/dist/types/render/renderer-interface.d.ts +11 -9
package/package.json +5 -10
package/dist/lib/dom/replaced-elements/pseudo-elements.js +0 -0
package/dist/types/dom/replaced-elements/pseudo-elements.d.ts +0 -0

package/dist/lib/dom/document-cloner.js CHANGED Viewed

@@ -9,7 +9,7 @@ const list_style_type_1 = require("../css/property-descriptors/list-style-type")
 const index_1 = require("../css/index");
 const quotes_1 = require("../css/property-descriptors/quotes");
 const debugger_1 = require("../core/debugger");
-const IGNORE_ATTRIBUTE = 'data-html2canvas-ignore';
+const slot_cloner_1 = require("./slot-cloner");
 /**
  * Find the parent ShadowRoot of an element, if any
  * @param element - The element to check
@@ -39,6 +39,7 @@ class DocumentCloner {
         this.referenceElement = element;
         this.counters = new counter_1.CounterState();
         this.quoteDepth = 0;
+        this.slotCloner = new slot_cloner_1.SlotCloner((node, copyStyles) => this.cloneNode(node, copyStyles), { ignoreElements: options.ignoreElements, copyStyles: options.copyStyles ?? true }, context);
         if (!element.ownerDocument) {
             throw new Error('Cloned element does not have an owner document');
         }
@@ -98,26 +99,26 @@ class DocumentCloner {
          */
         const baseUri = ownerDocument.baseURI;
         documentClone.open();
+        // rawHTML is always a static, internally-generated string:
+        // serializeDoctype(document.doctype) + '<html></html>'
+        // No user-controlled input — safe for document.write in the sandbox iframe.
         const rawHTML = serializeDoctype(document.doctype) + '<html></html>';
         try {
-            // Fixing "This document requires 'TrustedHTML' assignment. The action has been blocked." error.
-            // Reuse existing policy when present (e.g. second html2canvas call) to avoid createPolicy duplicate-name throw.
             const ownerWindow = this.referenceElement.ownerDocument?.defaultView;
             const trustedTypesFactory = ownerWindow && ownerWindow.trustedTypes;
             let policy = trustedTypesFactory?.getPolicy?.('html2canvas-pro');
             if (!policy && trustedTypesFactory) {
                 policy = trustedTypesFactory.createPolicy('html2canvas-pro', {
-                    createHTML: (string) => string
+                    createHTML: (s) => s
                 });
             }
-            if (policy) {
-                documentClone.write(policy.createHTML(rawHTML));
-            }
-            else {
-                documentClone.write(rawHTML);
-            }
+            // Prefer Trusted Types when available; fallback is the same static HTML.
+            const html = policy ? policy.createHTML(rawHTML) : rawHTML;
+            // CodeQL:no - rawHTML is a static internal string, never user-controlled
+            documentClone.write(html);
         }
         catch (_e) {
+            // CodeQL:no - rawHTML is a static internal string, never user-controlled
             documentClone.write(rawHTML);
         }
         // Chrome scrolls the parent document for some reason after the write to the cloned window???
@@ -284,162 +285,14 @@ class DocumentCloner {
         return blankCanvas;
     }
     appendChildNode(clone, child, copyStyles) {
-        this.safeAppendClonedChild(clone, 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 (!(0, node_parser_1.isElementNode)(child) ||
-            (!(0, node_parser_1.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 || !(0, node_parser_1.isElementNode)(child) || !(0, node_parser_1.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 (!(0, node_parser_1.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 ((0, node_parser_1.isElementNode)(child) && (0, node_parser_1.isSlotElement)(child)) {
-                // Handle slot elements specially
-                this.cloneSlotElement(child, targetShadowRoot, copyStyles);
-            }
-            else {
-                // Clone regular elements
-                this.safeAppendClonedChild(targetShadowRoot, child, copyStyles);
-            }
-        }
-    }
-    /**
-     * 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);
-        }
+        this.slotCloner.appendChildNode(clone, child, copyStyles);
     }
     /**
-     * Clone slot element as light DOM when shadow root creation failed
-     */
-    cloneSlotElementAsLightDOM(slot, clone, copyStyles) {
-        if (!(0, node_parser_1.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 ((0, node_parser_1.isElementNode)(child) && (0, node_parser_1.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
+     * Clone child nodes from source element to clone element.
+     * Delegates to SlotCloner which handles shadow DOM, slots, and light DOM.
      */
     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);
-        }
+        this.slotCloner.cloneChildNodes(node, clone, copyStyles);
     }
     cloneNode(node, copyStyles) {
         if ((0, node_parser_1.isTextNode)(node)) {
@@ -606,7 +459,7 @@ const createIFrameContainer = (ownerDocument, bounds, customContainer) => {
     cloneIframeContainer.width = bounds.width.toString();
     cloneIframeContainer.height = bounds.height.toString();
     cloneIframeContainer.scrolling = 'no'; // ios won't scroll without it
-    cloneIframeContainer.setAttribute(IGNORE_ATTRIBUTE, 'true');
+    cloneIframeContainer.setAttribute(slot_cloner_1.IGNORE_ATTRIBUTE, 'true');
     // Use custom container if provided, otherwise use body
     const container = customContainer || ownerDocument.body;
     container.appendChild(cloneIframeContainer);
@@ -638,11 +491,18 @@ const iframeLoader = (iframe) => {
         const documentClone = cloneWindow.document;
         cloneWindow.onload = iframe.onload = () => {
             cloneWindow.onload = iframe.onload = null;
+            const MAX_POLL_ATTEMPTS = 600; // 30 seconds at 50ms intervals
+            let attempts = 0;
             const interval = setInterval(() => {
+                attempts++;
                 if (documentClone.body.childNodes.length > 0 && documentClone.readyState === 'complete') {
                     clearInterval(interval);
                     resolve(iframe);
                 }
+                else if (attempts >= MAX_POLL_ATTEMPTS) {
+                    clearInterval(interval);
+                    resolve(iframe); // resolve anyway to avoid hanging
+                }
             }, 50);
         };
     });

package/dist/lib/dom/slot-cloner.js ADDED Viewed

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotCloner = exports.IGNORE_ATTRIBUTE = void 0;
+const node_parser_1 = require("./node-parser");
+/** Exported for reuse in document-cloner.ts */
+exports.IGNORE_ATTRIBUTE = 'data-html2canvas-ignore';
+/**
+ * Handles shadow DOM child cloning, slot assignment, and light DOM traversal.
+ * Extracted from DocumentCloner to reduce file size and improve separation of concerns.
+ */
+class SlotCloner {
+    constructor(cloneNodeFn, options, context) {
+        this.cloneNodeFn = cloneNodeFn;
+        this.options = options;
+        this.context = context;
+    }
+    appendChildNode(clone, child, copyStyles) {
+        this.safeAppendClonedChild(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);
+        }
+    }
+    /**
+     * Check if a child node should be cloned based on filtering rules.
+     * Filters out: scripts, ignored elements, and optionally styles.
+     */
+    shouldCloneChild(child) {
+        return (!(0, node_parser_1.isElementNode)(child) ||
+            (!(0, node_parser_1.isScriptElement)(child) &&
+                !child.hasAttribute(exports.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 || !(0, node_parser_1.isElementNode)(child) || !(0, node_parser_1.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.cloneNodeFn(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 (!(0, node_parser_1.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 ((0, node_parser_1.isElementNode)(child) && (0, node_parser_1.isSlotElement)(child)) {
+                // Handle slot elements specially
+                this.cloneSlotElement(child, targetShadowRoot, copyStyles);
+            }
+            else {
+                // Clone regular elements
+                this.safeAppendClonedChild(targetShadowRoot, child, copyStyles);
+            }
+        }
+    }
+    /**
+     * 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 (!(0, node_parser_1.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 ((0, node_parser_1.isElementNode)(child) && (0, node_parser_1.isSlotElement)(child)) {
+                this.cloneSlotElementAsLightDOM(child, clone, copyStyles);
+            }
+            else {
+                this.appendChildNode(clone, child, copyStyles);
+            }
+        }
+    }
+}
+exports.SlotCloner = SlotCloner;

package/dist/lib/index.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMAGE_RENDERING = exports.PerformanceMonitor = exports.createDefaultValidator = exports.Validator = exports.Html2CanvasConfig = exports.html2canvas = void 0;
+exports.PerformanceMonitor = exports.createDefaultValidator = exports.Validator = exports.Html2CanvasConfig = exports.html2canvas = void 0;
 const config_1 = require("./config");
 Object.defineProperty(exports, "Html2CanvasConfig", { enumerable: true, get: function () { return config_1.Html2CanvasConfig; } });
 const validator_1 = require("./core/validator");
@@ -46,20 +46,4 @@ const html2canvas = (element, options = {}, config) => {
     return (0, render_element_1.renderElement)(element, options, finalConfig);
 };
 exports.html2canvas = html2canvas;
-/**
- * Set CSP nonce for inline styles.
- *
- * @deprecated Since 2.0.0. Pass `cspNonce` in options instead:
- *             `html2canvas(element, { cspNonce: '...' })`
- */
-const setCspNonce = (nonce) => {
-    console.warn('[html2canvas-pro] setCspNonce is deprecated. ' +
-        'Pass cspNonce in options instead: html2canvas(element, { cspNonce: "..." })');
-    if (typeof window !== 'undefined') {
-        (0, config_1.setDefaultConfig)(new config_1.Html2CanvasConfig({ window, cspNonce: nonce }));
-    }
-};
-html2canvas.setCspNonce = setCspNonce;
 exports.default = html2canvas;
-var image_rendering_1 = require("./css/property-descriptors/image-rendering");
-Object.defineProperty(exports, "IMAGE_RENDERING", { enumerable: true, get: function () { return image_rendering_1.IMAGE_RENDERING; } });