html2canvas-pro 2.5.1 → 2.5.2

package/dist/types/core/cache-storage.d.ts

@@ -46,14 +46,18 @@ export declare class Cache {
      * an optional concurrency cap to avoid overwhelming the browser's network
      * stack (default: 10 concurrent loads).
      * After this call returns, all images are either loaded (cache hit) or
-     * failed (logged). Subsequent cache.match() calls return immediately.
+     * failed (logged and reported via onError). Subsequent cache.match()
+     * calls return immediately.
      *
      * @param concurrency - Max concurrent image loads (1–100, default 10).
      * @param onProgress - Invoked once before loading and after each settled
      *   batch with (settledCount, totalCount), enabling coarse progress UI.
      *   Not invoked when there is nothing to load.
+     * @param signal - Checked before each batch; aborting rejects the whole
+     *   preload with an AbortError instead of waiting for the remaining
+     *   batches to finish.
      */
-    preloadAll(concurrency?: number, onProgress?: (loaded: number, total: number) => void): Promise<void>;
+    preloadAll(concurrency?: number, onProgress?: (loaded: number, total: number) => void, signal?: AbortSignal): Promise<void>;
     addImage(src: string): Promise<void>;
     /**
      * Shared helper: enqueues loading for a single URL with pending-operation

package/dist/types/core/constants.d.ts

@@ -16,6 +16,17 @@ export declare const DEFAULT_IMAGE_TIMEOUT_MS = 15000;
 export declare const SHADOW_MASK_OFFSET = 10000;
 /** Polling interval (ms) when waiting for the cloned iframe to become ready. */
 export declare const IFRAME_READY_POLL_MS = 50;
+/**
+ * Total time (ms) to wait for the cloned iframe document to become ready
+ * after its load event. A missed deadline resolves with a warning (the
+ * capture continues with a possibly incomplete document).
+ */
+export declare const CLONE_READY_TIMEOUT_MS = 30000;
+/**
+ * Hard ceiling (ms) for the cloned iframe's load event itself. If the event
+ * never fires, the mount is rejected instead of hanging forever.
+ */
+export declare const IFRAME_LOAD_WATCHDOG_MS = 60000;
 /** Deferred resolution delay (ms) for inline XML images that may fail to parse. */
 export declare const INLINE_IMAGE_RESOLVE_DELAY_MS = 500;
 /** Maximum characters logged for image/resource keys. */

package/dist/types/core/context.d.ts

@@ -10,17 +10,25 @@ export type ContextOptions = {
     onError?: (error: Error) => void;
 } & ResourceOptions;
 export declare class Context {
+    private static instanceCount;
     private readonly instanceName;
     readonly logger: Logger;
     readonly cache: Cache;
     readonly originChecker: OriginChecker;
     readonly config: Html2CanvasConfig;
     readonly onError?: (error: Error) => void;
-    private static instanceCount;
     private _windowBounds;
     constructor(options: ContextOptions, windowBounds: Bounds, config: Html2CanvasConfig);
     /** Viewport bounds in page coordinates; added to client rects during bounds parsing. */
     get windowBounds(): Bounds;
+    /**
+     * Document used to allocate offscreen resources (offscreen canvases,
+     * images, measurement elements). Prefers the configured window's document
+     * so resources live in the captured realm; falls back to the global
+     * document, which keeps mock environments without a window document
+     * working.
+     */
+    get resourceDocument(): Document;
     /**
      * Compensate window bounds for a page scroll that the browser performed
      * underneath us. Used by the document cloner: WebKit's scroll anchoring can

package/dist/types/core/features.d.ts

@@ -1,12 +1,16 @@
+/**
+ * Runtime feature detection.
+ *
+ * Only checks that still gate real behaviour are kept: range-bounds
+ * measurement (iOS 13 quirk), SVG drawing and CORS image support.
+ * Dead probes (IE-era CORS XHR / XHR response-type checks) were removed —
+ * every supported browser exposes `crossOrigin`, `responseType` and
+ * `withCredentials`; Intl.Segmenter is used unconditionally.
+ */
 export declare const createForeignObjectSVG: (width: number, height: number, x: number, y: number, node: Node) => SVGForeignObjectElement;
 export declare const loadSerializedSVG: (svg: Node) => Promise<HTMLImageElement>;
 export declare const FEATURES: {
     readonly SUPPORT_RANGE_BOUNDS: boolean;
-    readonly SUPPORT_WORD_BREAKING: boolean;
     readonly SUPPORT_SVG_DRAWING: boolean;
-    readonly SUPPORT_FOREIGNOBJECT_DRAWING: Promise<boolean>;
     readonly SUPPORT_CORS_IMAGES: boolean;
-    readonly SUPPORT_RESPONSE_TYPE: boolean;
-    readonly SUPPORT_CORS_XHR: boolean;
-    readonly SUPPORT_NATIVE_TEXT_SEGMENTATION: boolean;
 };

package/dist/types/core/origin-checker.d.ts

@@ -2,19 +2,22 @@
  * Origin Checker
  *
  * Provides origin checking functionality without global static state.
- * Each instance maintains its own anchor element and origin reference.
+ * Each instance maintains its own base URI and origin reference.
  *
  * Replaces the static methods in CacheStorage with instance-based approach.
  */
 export declare class OriginChecker {
-    private readonly link;
+    private readonly baseUri;
     private readonly origin;
     constructor(window: Window);
     /**
      * Get the origin (protocol + hostname + port) of a URL
      *
-     * @param url - URL to parse
-     * @returns Origin string (e.g., "https://example.com:8080")
+     * @param url - URL to parse; relative URLs resolve against the context
+     *              window's location, as the anchor element used to
+     * @returns Origin string (e.g. "https://example.com:8080"), or an empty
+     *          string for unparseable URLs — which never matches and is
+     *          therefore treated as cross-origin
      */
     getOrigin(url: string): string;
     /**

package/dist/types/core/validator.d.ts

@@ -11,8 +11,6 @@ export interface ValidationResult {
     valid: boolean;
     error?: string;
     sanitized?: unknown;
-    /** Indicates if runtime validation is recommended (e.g. for proxy URLs against DNS rebinding) */
-    requiresRuntimeCheck?: boolean;
 }
 /**
  * Validator configuration

package/dist/types/css/grouped/background-styles.d.ts

@@ -1,6 +1,10 @@
 import type { CSSParsedDeclaration } from '../index';
 /**
  * Read-only grouped accessor for background-related CSS properties.
+ *
+ * Convenience accessors only — the render pipeline reads the top-level
+ * parsed fields directly. Some underlying properties are parsed but not
+ * rendered; see docs/features.md "Known unsupported CSS features".
  */
 export declare class BackgroundStyles {
     private readonly styles;

package/dist/types/css/grouped/border-styles.d.ts

@@ -2,6 +2,10 @@ import type { CSSParsedDeclaration } from '../index';
 /**
  * Read-only grouped accessor for border-related CSS properties.
  *
+ * Convenience accessors only — the render pipeline reads the top-level
+ * parsed fields directly. Some underlying properties are parsed but not
+ * rendered; see docs/features.md "Known unsupported CSS features".
+ *
  * Provides structured access: `styles.border.topColor` as an alternative
  * to the flat `styles.borderTopColor`. Both forms remain valid.
  */

package/dist/types/css/grouped/font-styles.d.ts

@@ -1,6 +1,10 @@
 import type { CSSParsedDeclaration } from '../index';
 /**
  * Read-only grouped accessor for font/text-related CSS properties.
+ *
+ * Convenience accessors only — the render pipeline reads the top-level
+ * parsed fields directly. Some underlying properties are parsed but not
+ * rendered; see docs/features.md "Known unsupported CSS features".
  */
 export declare class FontStyles {
     private readonly styles;

package/dist/types/css/grouped/layout-styles.d.ts

@@ -1,6 +1,10 @@
 import type { CSSParsedDeclaration } from '../index';
 /**
  * Read-only grouped accessor for layout/display/positioning CSS properties.
+ *
+ * Convenience accessors only — the render pipeline reads the top-level
+ * parsed fields directly. Some underlying properties are parsed but not
+ * rendered; see docs/features.md "Known unsupported CSS features".
  */
 export declare class LayoutStyles {
     private readonly styles;

package/dist/types/css/index.d.ts

@@ -57,6 +57,8 @@ import { textAlign } from './property-descriptors/text-align';
 import { transform } from './property-descriptors/transform';
 import { transformOrigin } from './property-descriptors/transform-origin';
 import { rotate } from './property-descriptors/rotate';
+import { translate } from './property-descriptors/translate';
+import { scale } from './property-descriptors/scale';
 import { LengthPercentage } from './types/length-percentage';
 import { webkitTextStrokeWidth } from './property-descriptors/webkit-text-stroke-width';
 import { objectFit } from './property-descriptors/object-fit';
@@ -146,6 +148,8 @@ export declare class CSSParsedDeclaration {
     transform: ReturnType<typeof transform.parse>;
     transformOrigin: ReturnType<typeof transformOrigin.parse>;
     rotate: ReturnType<typeof rotate.parse>;
+    translate: ReturnType<typeof translate.parse>;
+    scale: ReturnType<typeof scale.parse>;
     visibility: ReturnType<typeof visibility.parse>;
     webkitTextStrokeColor: Color;
     webkitTextStrokeWidth: ReturnType<typeof webkitTextStrokeWidth.parse>;

package/dist/types/css/property-descriptor.d.ts

@@ -13,9 +13,17 @@ export interface IPropertyDescriptor {
     type: PropertyDescriptorParsingType;
     initialValue: string;
     prefix: boolean;
-    /** When true, the parse result is never stored in parseCache.
-     *  Set this for descriptors whose parse() has side effects (e.g.,
-     *  calling context.cache.addImage) that must run on every render pass. */
+    /**
+     * When true, the parse result is never stored in parseCache.
+     * Set this for descriptors whose parse() has side effects (e.g.,
+     * calling context.cache.addImage) that must run on every render pass.
+     *
+     * parse() purity contract: for every descriptor without skipCache, parse()
+     * MUST be a pure function of (raw computed string) — its result is
+     * memoised in a process-wide cache shared across renders and contexts.
+     * Any new side effect (resource loading, context capture) requires
+     * skipCache: true, or the effect silently stops running.
+     */
     skipCache?: boolean;
 }
 export interface IPropertyIdentValueDescriptor<T> extends IPropertyDescriptor {

package/dist/types/css/property-descriptors/scale.d.ts

@@ -0,0 +1,9 @@
+import { IPropertyListDescriptor } from '../property-descriptor';
+/**
+ * CSS Transforms Level 2 independent `scale` property.
+ * Computed values: `none`, `<number>` (both axes), `<number> <number>` (x y).
+ * Unlike a missing value in `transform: scale()`, a single value scales both
+ * axes; y defaults to x per the individual-property grammar.
+ */
+export type ScaleValue = [number, number] | null;
+export declare const scale: IPropertyListDescriptor<ScaleValue>;

package/dist/types/css/property-descriptors/translate.d.ts

@@ -0,0 +1,10 @@
+import { IPropertyListDescriptor } from '../property-descriptor';
+import { LengthPercentage } from '../types/length-percentage';
+/**
+ * CSS Transforms Level 2 independent `translate` property.
+ * Computed values: `none`, `<length-percentage>`, `<length-percentage> <length-percentage>`
+ * (a third z length may appear in computed values and is ignored — 2D renderer).
+ * Percentages are resolved against the element bounds at paint time.
+ */
+export type TranslateValue = [LengthPercentage, LengthPercentage] | null;
+export declare const translate: IPropertyListDescriptor<TranslateValue>;

package/dist/types/css/syntax/tokenizer.d.ts

@@ -10,6 +10,14 @@ export declare class Tokenizer {
     static get(): Tokenizer;
     static release(tokenizer: Tokenizer): void;
     private _value;
+    /**
+     * Read cursor into `_value`. Consumption advances the cursor instead of
+     * shifting the array — `Array.shift()` per code point makes tokenising a
+     * long value O(n²) (a 200 KB inline data-URI background alone would cost
+     * billions of operations, and background-image values are never parse-
+     * cached). `write()` compacts already-consumed prefix bytes.
+     */
+    private _cursor;
     constructor();
     private _reset;
     write(chunk: string): void;

package/dist/types/css/types/color-utilities.d.ts

@@ -33,6 +33,27 @@ export declare const d65toD50: (xyz: [number, number, number]) => [number, numbe
  */
 export declare const d50toD65: (xyz: [number, number, number]) => [number, number, number];
 export declare const hue2rgb: (t1: number, t2: number, hue: number) => number;
+export declare const hsl2rgb: ([h, s, l]: [number, number, number]) => [number, number, number];
+/**
+ * Convert lch to OKLab
+ *
+ * @param l
+ * @param c
+ * @param h
+ */
+export declare const lch2lab: ([l, c, h]: [number, number, number]) => [number, number, number];
+/**
+ * Convert OKLab to XYZ relative to D65
+ *
+ * @param lab
+ */
+export declare const oklab2xyz: (lab: [number, number, number]) => [number, number, number];
+/**
+ * Convert Lab to D50-adapted XYZ
+ *
+ * @param lab
+ */
+export declare const lab2xyz: (lab: [number, number, number]) => [number, number, number];
 /**
  * Convert RGB to XYZ
  *

package/dist/types/css/types/functions/color-mix.d.ts

@@ -0,0 +1,17 @@
+import { Color } from '../color';
+import { Context } from '../../../core/context';
+import { CSSValue } from '../../syntax/parser';
+import { RGB3 } from '../color-math';
+type HueMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing';
+/** Inverse of color-utilities' lab2xyz: D65 XYZ → CIE Lab (0..100 scale). */
+export declare const xyzD65ToLab: (xyz: RGB3) => RGB3;
+/** D65 XYZ → OKLab via the inverted forward matrices. */
+export declare const xyzD65ToOklab: (xyz: RGB3) => RGB3;
+/**
+ * Interpolate a hue angle in degrees per css-color-4 §12.4. `weight1` and
+ * `weight2` are the (normalized) mix weights; the hue travels from h1 towards
+ * h2 by the shared fraction. Exported for unit tests.
+ */
+export declare const interpolateHue: (h1: number, h2: number, weight1: number, weight2: number, method?: HueMethod) => number;
+export declare const colorMix: (context: Context, args: CSSValue[]) => Color;
+export {};

package/dist/types/dom/adopted-styles.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Constructable stylesheet cloning (adoptedStyleSheets).
+ *
+ * `adoptedStyleSheets` on a Document or ShadowRoot is the standard way Lit,
+ * React and other frameworks inject component styles, but the sheets are not
+ * part of the node tree — cloneNode never carries them. A shadow root that
+ * relies on adopted sheets (and whose computed styles are not inlined per
+ * element, i.e. copyStyles is false) would otherwise lose those rules in the
+ * clone. The rules are re-materialised as a regular <style> element, which
+ * also cascades last like the spec treats adopted sheets.
+ */
+/**
+ * Serialize the CSS rules of the given sheets into one stylesheet string.
+ * Sheets that cannot be read (e.g. detached) are skipped rather than failing
+ * the render.
+ */
+export declare const serializeStyleSheetRules: (sheets: readonly CSSStyleSheet[]) => string;
+/**
+ * Build a <style> element carrying the rules of the given adopted sheets, or
+ * null when there is nothing to clone. `styleDocument` must be the document
+ * the clone lives in.
+ */
+export declare const createAdoptedStylesElement: (styleDocument: Document, sheets: readonly CSSStyleSheet[], nonce?: string) => HTMLStyleElement | null;

package/dist/types/dom/document-cloner.d.ts

@@ -18,6 +18,8 @@ export type CloneConfigurations = CloneOptions & {
     inlineImages: boolean;
     copyStyles: boolean;
     cspNonce?: string;
+    /** Aborting rejects the iframe mount instead of waiting out readiness windows. */
+    signal?: AbortSignal;
 };
 export declare class DocumentCloner {
     private readonly context;
@@ -30,6 +32,16 @@ export declare class DocumentCloner {
     private readonly pseudoContents;
     private readonly slotCloner;
     constructor(context: Context, element: HTMLElement, options: CloneConfigurations);
+    /**
+     * Re-materialise the source document's constructable stylesheets
+     * (document.adoptedStyleSheets) as a <style> at the end of the clone's
+     * <head>: cloneNode never carries them, and they cascade after all author
+     * sheets, which appending last approximates.
+     *
+     * Skipped when computed styles are inlined per element (copyStyles), like
+     * the other stylesheet-cloning paths.
+     */
+    private appendDocumentAdoptedStyles;
     toIFrame(ownerDocument: Document, windowSize: Bounds): Promise<HTMLIFrameElement>;
     createElementClone<T extends HTMLElement | SVGElement>(node: T): HTMLElement | SVGElement;
     createCustomElementClone(originalNode: HTMLElement, clonedNode: HTMLElement): HTMLElement;

package/dist/types/dom/dom-normalizer.d.ts

@@ -11,6 +11,8 @@ export interface OriginalStyles {
     animationDuration?: string;
     transform?: string;
     rotate?: string;
+    translate?: string;
+    scale?: string;
 }
 /**
  * Normalize element styles for accurate rendering

package/dist/types/dom/elements/li-element-container.d.ts

@@ -1,6 +1,6 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare class LIElementContainer extends ElementContainer {
     readonly value: number;
-    constructor(context: Context, element: HTMLLIElement);
+    constructor(context: Context, element: HTMLLIElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/elements/ol-element-container.d.ts

@@ -1,7 +1,7 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare class OLElementContainer extends ElementContainer {
     readonly start: number;
     readonly reversed: boolean;
-    constructor(context: Context, element: HTMLOListElement);
+    constructor(context: Context, element: HTMLOListElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/elements/select-element-container.d.ts

@@ -1,6 +1,6 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare class SelectElementContainer extends ElementContainer {
     readonly value: string;
-    constructor(context: Context, element: HTMLSelectElement);
+    constructor(context: Context, element: HTMLSelectElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/elements/textarea-element-container.d.ts

@@ -1,6 +1,6 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare class TextareaElementContainer extends ElementContainer {
     readonly value: string;
-    constructor(context: Context, element: HTMLTextAreaElement);
+    constructor(context: Context, element: HTMLTextAreaElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/iframe-mount.d.ts

@@ -22,7 +22,23 @@ export interface CloneMountOptions {
     onclone?: (document: Document, element: HTMLElement) => void;
     /** Mount the iframe inside a shadow root instead of <body>. */
     container?: HTMLElement | ShadowRoot;
+    /**
+     * Aborting rejects the mount (iframe poll, font/image waits) with an
+     * AbortError instead of waiting out the readiness windows.
+     */
+    signal?: AbortSignal;
 }
+type TrustedTypePolicyLike = {
+    createHTML: (s: string) => string;
+};
+/**
+ * Resolve the Trusted Types policy used for writing the clone document.
+ * Returns null when Trusted Types are unavailable or the policy could not be
+ * created — document.write is not a Trusted Types sink, so the plain string
+ * stays functional in both cases.
+ * @internal – exported for testing only.
+ */
+export declare const resolveTrustedTypesPolicy: (ownerWindow: Window | null) => TrustedTypePolicyLike | null;
 export declare const createIFrameContainer: (ownerDocument: Document, bounds: Bounds, customContainer?: HTMLElement | ShadowRoot) => HTMLIFrameElement;
 /**
  * Serialise a document type declaration to an HTML string.
@@ -35,3 +51,4 @@ export declare const serializeDoctype: (doctype?: DocumentType | null) => string
  */
 export declare const addBase: (targetELement: HTMLElement, baseUri: string) => void;
 export declare const mountCloneInIFrame: (context: Context, ownerDocument: Document, windowSize: Bounds, mount: CloneMountOptions) => Promise<HTMLIFrameElement>;
+export {};

package/dist/types/dom/node-parser.d.ts

@@ -1,3 +1,3 @@
-import { ElementContainer } from './element-container';
+import { ElementContainer, ElementContainerOptions } from './element-container';
 import { Context } from '../core/context';
-export declare const parseTree: (context: Context, element: HTMLElement) => ElementContainer;
+export declare const parseTree: (context: Context, element: HTMLElement, options?: ElementContainerOptions) => ElementContainer;

package/dist/types/dom/replaced-elements/canvas-element-container.d.ts

@@ -1,8 +1,8 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare class CanvasElementContainer extends ElementContainer {
     canvas: HTMLCanvasElement;
     intrinsicWidth: number;
     intrinsicHeight: number;
-    constructor(context: Context, canvas: HTMLCanvasElement);
+    constructor(context: Context, canvas: HTMLCanvasElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/replaced-elements/iframe-element-container.d.ts

@@ -1,4 +1,4 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { type Color } from '../../css/types/color';
 import { Context } from '../../core/context';
 type ParseTreeFunction = (context: Context, node: HTMLElement) => ElementContainer;
@@ -9,6 +9,6 @@ export declare class IFrameElementContainer extends ElementContainer {
     tree?: ElementContainer;
     backgroundColor: Color;
     private parseTreeFn?;
-    constructor(context: Context, iframe: HTMLIFrameElement, parseTreeFn?: ParseTreeFunction);
+    constructor(context: Context, iframe: HTMLIFrameElement, parseTreeFn?: ParseTreeFunction, options?: ElementContainerOptions);
 }
 export {};

package/dist/types/dom/replaced-elements/image-element-container.d.ts

@@ -1,8 +1,8 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare class ImageElementContainer extends ElementContainer {
     src: string;
     intrinsicWidth: number;
     intrinsicHeight: number;
-    constructor(context: Context, img: HTMLImageElement);
+    constructor(context: Context, img: HTMLImageElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/replaced-elements/input-element-container.d.ts

@@ -1,4 +1,4 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare const CHECKBOX = "checkbox";
 export declare const RADIO = "radio";
@@ -10,5 +10,5 @@ export declare class InputElementContainer extends ElementContainer {
     readonly checked: boolean;
     readonly value: string;
     readonly isPlaceholder: boolean;
-    constructor(context: Context, input: HTMLInputElement);
+    constructor(context: Context, input: HTMLInputElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/replaced-elements/svg-element-container.d.ts

@@ -1,9 +1,9 @@
-import { ElementContainer } from '../element-container';
+import { ElementContainer, ElementContainerOptions } from '../element-container';
 import { Context } from '../../core/context';
 export declare const serializeWithoutBoxOffsets: (serializer: XMLSerializer, img: SVGSVGElement) => string;
 export declare class SVGElementContainer extends ElementContainer {
     svg: string;
     intrinsicWidth: number;
     intrinsicHeight: number;
-    constructor(context: Context, img: SVGSVGElement);
+    constructor(context: Context, img: SVGSVGElement, options?: ElementContainerOptions);
 }

package/dist/types/dom/slot-cloner.d.ts

@@ -3,6 +3,8 @@ import { Context } from '../core/context';
 export interface SlotClonerOptions {
     ignoreElements?: (element: Element) => boolean;
     copyStyles: boolean;
+    /** CSP nonce applied to synthesized <style> elements (adopted sheets). */
+    cspNonce?: string;
 }
 /** Exported for reuse in document-cloner.ts */
 export declare const IGNORE_ATTRIBUTE = "data-html2canvas-ignore";
@@ -63,4 +65,12 @@ export declare class SlotCloner {
      * This is a fallback mechanism to ensure content is not lost.
      */
     private cloneShadowDOMAsLightDOM;
+    /**
+     * Re-materialise the shadow root's constructable stylesheets (adoptedStyleSheets)
+     * as a <style> element in the clone — cloneNode never carries them.
+     *
+     * Skipped when computed styles are inlined per element (copyStyles), mirroring
+     * how <style> elements inside shadow roots are dropped in that mode.
+     */
+    private appendAdoptedStyleSheets;
 }

package/dist/types/options.d.ts

@@ -7,6 +7,19 @@ import { Validator } from './core/validator';
  *
  * Combines clone, window, render, and context configuration into a single
  * options object. All properties are optional.
+ *
+ * The full surface is composed from these interfaces (each documented where
+ * it is declared):
+ * - {@link CloneOptions} — `ignoreElements`, `onclone`, `allowTaint`,
+ *   `iframeContainer` (src/dom/document-cloner.ts)
+ * - {@link WindowOptions} — `scrollX`, `scrollY`, `windowWidth`,
+ *   `windowHeight` (src/dom/document-cloner.ts)
+ * - {@link RenderOptions} — `scale`, `canvas`, `x`, `y`, `width`, `height`
+ *   (src/render/canvas/canvas-renderer.ts)
+ * - {@link ContextOptions} — `logging`, `cache`, `onError`, plus the
+ *   `ResourceOptions` it extends: `imageTimeout`, `useCORS`, `proxy`,
+ *   `customIsSameOrigin`, `maxCacheSize` (src/core/context.ts and
+ *   src/core/cache-storage.ts)
  */
 export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOptions & {
     /** Background color for the resulting canvas. Use `null` for transparent. */
@@ -15,6 +28,14 @@ export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOpti
     foreignObjectRendering: boolean;
     /** Whether to remove the cloned iframe after rendering. @default true */
     removeContainer?: boolean;
+    /**
+     * Normalize the cloned DOM before parsing: disable CSS animations and
+     * replace active transforms with identity values so element bounds are
+     * measured in layout space. Set to `false` to keep animation/transform
+     * state intact during capture.
+     * @default true
+     */
+    normalizeDom?: boolean;
     /** CSP nonce for inline style elements. */
     cspNonce?: string;
     /** Custom input validator. */
@@ -51,6 +72,9 @@ export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOpti
     /**
      * Called when a resource fails to load (image, font, iframe, etc.).
      * The render continues — this is a notification hook, not an abort.
+     * Image/proxy load failures are reported exactly once, by the
+     * resource cache at load time; iframe content failures are reported
+     * by the iframe container.
      */
     onError?: (error: Error) => void;
     /**

package/dist/types/render/canvas/border-image-renderer.d.ts

@@ -64,4 +64,11 @@ export declare class BorderImageRenderer {
     renderBorderImage(bounds: Bounds, image: HTMLImageElement, slice: BorderImageSlice, repeat: BorderImageRepeat, borderTopWidth: number, borderRightWidth: number, borderBottomWidth: number, borderLeftWidth: number, outset?: BorderImageSides): void;
     private drawRegion;
     private drawRepeatedEdge;
+    /**
+     * Draw the center region of the border image, tiling each axis per its
+     * border-image-repeat keyword (stretch spans the whole axis, repeat
+     * tiles at source size with the overflow cropped, round scales the tile
+     * to divide the axis evenly).
+     */
+    private drawCenterRegion;
 }

package/dist/types/render/canvas/canvas-renderer.d.ts

@@ -71,7 +71,6 @@ export declare class CanvasRenderer {
     renderReplacedElement(container: ReplacedElementContainer, curves: BoundCurves, image: HTMLImageElement | HTMLCanvasElement): void;
     renderNodeContent(paint: ElementPaint): Promise<void>;
     renderStackContent(stack: StackingContext): Promise<void>;
-    mask(paths: Path[]): void;
     path(paths: Path[]): void;
     formatPath(paths: Path[]): void;
     private renderSurfaceBoxShadow;
@@ -91,8 +90,8 @@ export declare class CanvasRenderer {
     private rasterizeGradientSource;
     /**
      * Filter the already-painted content beneath the element's border box and
-     * paint the result back, approximating CSS backdrop-filter for the
-     * blur/drop-shadow subset supported by parseSimpleFilter.
+     * paint the result back, approximating CSS backdrop-filter for the chain
+     * subset the filter surface backends support.
      */
     private renderBackdropFilter;
     render(element: ElementContainer): Promise<HTMLCanvasElement>;