@ohos-ports/html2canvas-pro 0.0.0-stage → 2.3.2-beta.0

package/dist/lib/render/stacking-context.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStackingContexts = exports.buildClipPathEffect = exports.resolveAxisRadius = exports.hasOverflowClip = exports.ElementPaint = exports.StackingContext = void 0;
+const bitwise_1 = require("../core/bitwise");
+const bound_curves_1 = require("./bound-curves");
+const effects_1 = require("./effects");
+const path_1 = require("./path");
+const ol_element_container_1 = require("../dom/elements/ol-element-container");
+const li_element_container_1 = require("../dom/elements/li-element-container");
+const counter_1 = require("../css/types/functions/counter");
+const length_percentage_1 = require("../css/types/length-percentage");
+const mix_blend_mode_1 = require("../css/property-descriptors/mix-blend-mode");
+class StackingContext {
+    constructor(container) {
+        this.element = container;
+        this.inlineLevel = [];
+        this.nonInlineLevel = [];
+        this.negativeZIndex = [];
+        this.zeroOrAutoZIndexOrTransformedOrOpacity = [];
+        this.positiveZIndex = [];
+        this.nonPositionedFloats = [];
+        this.nonPositionedInlineLevel = [];
+    }
+}
+exports.StackingContext = StackingContext;
+class ElementPaint {
+    constructor(container, parent) {
+        this.container = container;
+        this.parent = parent;
+        this.effects = [];
+        this.curves = new bound_curves_1.BoundCurves(this.container);
+        if (this.container.styles.opacity < 1) {
+            this.effects.push(new effects_1.OpacityEffect(this.container.styles.opacity));
+        }
+        if (this.container.styles.rotate !== null) {
+            const origin = this.container.styles.transformOrigin;
+            const offsetX = this.container.bounds.left + (0, length_percentage_1.getAbsoluteValue)(origin[0], this.container.bounds.width);
+            const offsetY = this.container.bounds.top + (0, length_percentage_1.getAbsoluteValue)(origin[1], this.container.bounds.height);
+            // Apply rotate property if present
+            const angle = this.container.styles.rotate;
+            const rad = (angle * Math.PI) / 180;
+            const cos = Math.cos(rad);
+            const sin = Math.sin(rad);
+            const rotateMatrix = [cos, sin, -sin, cos, 0, 0];
+            this.effects.push(new effects_1.TransformEffect(offsetX, offsetY, rotateMatrix));
+        }
+        if (this.container.styles.transform !== null) {
+            const origin = this.container.styles.transformOrigin;
+            const offsetX = this.container.bounds.left + (0, length_percentage_1.getAbsoluteValue)(origin[0], this.container.bounds.width);
+            const offsetY = this.container.bounds.top + (0, length_percentage_1.getAbsoluteValue)(origin[1], this.container.bounds.height);
+            const matrix = this.container.styles.transform;
+            this.effects.push(new effects_1.TransformEffect(offsetX, offsetY, matrix));
+        }
+        if ((0, exports.hasOverflowClip)(this.container.styles)) {
+            const borderBox = (0, bound_curves_1.calculateBorderBoxPath)(this.curves);
+            const paddingBox = (0, bound_curves_1.calculatePaddingBoxPath)(this.curves);
+            if ((0, path_1.equalPath)(borderBox, paddingBox)) {
+                this.effects.push(new effects_1.ClipEffect(borderBox, 2 /* EffectTarget.BACKGROUND_BORDERS */ | 4 /* EffectTarget.CONTENT */));
+            }
+            else {
+                this.effects.push(new effects_1.ClipEffect(borderBox, 2 /* EffectTarget.BACKGROUND_BORDERS */));
+                this.effects.push(new effects_1.ClipEffect(paddingBox, 4 /* EffectTarget.CONTENT */));
+            }
+        }
+        if (this.container.styles.clipPath.type !== 0 /* CLIP_PATH_TYPE.NONE */) {
+            const clipPathEffect = (0, exports.buildClipPathEffect)(this.container.styles.clipPath, this.container.bounds);
+            if (clipPathEffect) {
+                this.effects.push(clipPathEffect);
+            }
+        }
+        if (this.container.styles.mixBlendMode !== mix_blend_mode_1.MIX_BLEND_MODE.NORMAL) {
+            this.effects.push(new effects_1.BlendEffect(this.container.styles.mixBlendMode));
+        }
+        if (this.container.styles.filter !== null) {
+            this.effects.push(new effects_1.FilterEffect(this.container.styles.filter));
+        }
+        if (this.container.styles.zoom !== 1) {
+            const origin = this.container.styles.transformOrigin;
+            const offsetX = this.container.bounds.left + (0, length_percentage_1.getAbsoluteValue)(origin[0], this.container.bounds.width);
+            const offsetY = this.container.bounds.top + (0, length_percentage_1.getAbsoluteValue)(origin[1], this.container.bounds.height);
+            const z = this.container.styles.zoom;
+            const zoomMatrix = [z, 0, 0, z, 0, 0];
+            this.effects.push(new effects_1.TransformEffect(offsetX, offsetY, zoomMatrix));
+        }
+    }
+    getEffects(target) {
+        let inFlow = [2 /* POSITION.ABSOLUTE */, 3 /* POSITION.FIXED */].indexOf(this.container.styles.position) === -1;
+        let parent = this.parent;
+        const effects = this.effects.slice(0);
+        while (parent) {
+            const croplessEffects = parent.effects.filter((effect) => !(0, effects_1.isClipEffect)(effect));
+            if (inFlow || parent.container.styles.position !== 0 /* POSITION.STATIC */ || !parent.parent) {
+                inFlow = [2 /* POSITION.ABSOLUTE */, 3 /* POSITION.FIXED */].indexOf(parent.container.styles.position) === -1;
+                if ((0, exports.hasOverflowClip)(parent.container.styles)) {
+                    const borderBox = (0, bound_curves_1.calculateBorderBoxPath)(parent.curves);
+                    const paddingBox = (0, bound_curves_1.calculatePaddingBoxPath)(parent.curves);
+                    if (!(0, path_1.equalPath)(borderBox, paddingBox)) {
+                        effects.unshift(new effects_1.ClipEffect(paddingBox, 2 /* EffectTarget.BACKGROUND_BORDERS */ | 4 /* EffectTarget.CONTENT */));
+                    }
+                }
+                effects.unshift(...croplessEffects);
+            }
+            else {
+                effects.unshift(...croplessEffects);
+            }
+            parent = parent.parent;
+        }
+        return effects.filter((effect) => (0, bitwise_1.contains)(effect.target, target));
+    }
+}
+exports.ElementPaint = ElementPaint;
+/** @internal – exported for testing only. */
+const hasOverflowClip = (styles) => styles.overflowX !== 0 /* OVERFLOW.VISIBLE */ || styles.overflowY !== 0 /* OVERFLOW.VISIBLE */;
+exports.hasOverflowClip = hasOverflowClip;
+/**
+ * Resolve a `closest-side` or `farthest-side` shape-radius keyword to pixels
+ * for a single axis. Used by both `circle()` (per-axis) and `ellipse()`.
+ *
+ * @param r       - The ShapeRadius (keyword or length-percentage).
+ * @param center  - Absolute center coordinate on this axis (cx or cy).
+ * @param start   - Absolute start of the reference box on this axis.
+ * @param end     - Absolute end of the reference box on this axis.
+ * @param dimRef  - Reference dimension for resolving a length-percentage value.
+ * @internal – exported for testing only.
+ */
+const resolveAxisRadius = (r, center, start, end, dimRef) => {
+    if (r === 'closest-side')
+        return Math.min(center - start, end - center);
+    if (r === 'farthest-side')
+        return Math.max(center - start, end - center);
+    return (0, length_percentage_1.getAbsoluteValue)(r, dimRef);
+};
+exports.resolveAxisRadius = resolveAxisRadius;
+/**
+ * Convert a parsed ClipPathValue + element bounds into a ClipPathEffect whose
+ * `applyClip` callback draws the clip shape directly onto the canvas context.
+ *
+ * All coordinates are computed in page-absolute space at construction time so
+ * the callback itself is allocation-free and executes synchronously.
+ * @internal – exported for testing only.
+ */
+const buildClipPathEffect = (clipPath, bounds) => {
+    const { left: bLeft, top: bTop, width: bWidth, height: bHeight } = bounds;
+    switch (clipPath.type) {
+        case 1 /* CLIP_PATH_TYPE.INSET */: {
+            const iLeft = (0, length_percentage_1.getAbsoluteValue)(clipPath.left, bWidth);
+            const iTop = (0, length_percentage_1.getAbsoluteValue)(clipPath.top, bHeight);
+            const x = bLeft + iLeft;
+            const y = bTop + iTop;
+            // Clamp to zero: per CSS spec, overlapping insets produce an empty shape.
+            const w = Math.max(0, bWidth - iLeft - (0, length_percentage_1.getAbsoluteValue)(clipPath.right, bWidth));
+            const h = Math.max(0, bHeight - iTop - (0, length_percentage_1.getAbsoluteValue)(clipPath.bottom, bHeight));
+            return new effects_1.ClipPathEffect((ctx) => {
+                ctx.beginPath();
+                ctx.rect(x, y, w, h);
+                ctx.clip();
+            });
+        }
+        case 2 /* CLIP_PATH_TYPE.CIRCLE */: {
+            const cx = bLeft + (0, length_percentage_1.getAbsoluteValue)(clipPath.cx, bWidth);
+            const cy = bTop + (0, length_percentage_1.getAbsoluteValue)(clipPath.cy, bHeight);
+            let r;
+            if (clipPath.radius === 'closest-side') {
+                r = Math.min(cx - bLeft, cy - bTop, bLeft + bWidth - cx, bTop + bHeight - cy);
+            }
+            else if (clipPath.radius === 'farthest-side') {
+                r = Math.max(cx - bLeft, cy - bTop, bLeft + bWidth - cx, bTop + bHeight - cy);
+            }
+            else {
+                // Per CSS spec, percentage is relative to sqrt(w² + h²) / sqrt(2).
+                r = (0, length_percentage_1.getAbsoluteValue)(clipPath.radius, Math.sqrt(bWidth * bWidth + bHeight * bHeight) / Math.SQRT2);
+            }
+            return new effects_1.ClipPathEffect((ctx) => {
+                ctx.beginPath();
+                ctx.arc(cx, cy, Math.max(0, r), 0, Math.PI * 2);
+                ctx.clip();
+            });
+        }
+        case 3 /* CLIP_PATH_TYPE.ELLIPSE */: {
+            const cx = bLeft + (0, length_percentage_1.getAbsoluteValue)(clipPath.cx, bWidth);
+            const cy = bTop + (0, length_percentage_1.getAbsoluteValue)(clipPath.cy, bHeight);
+            const rx = (0, exports.resolveAxisRadius)(clipPath.rx, cx, bLeft, bLeft + bWidth, bWidth);
+            const ry = (0, exports.resolveAxisRadius)(clipPath.ry, cy, bTop, bTop + bHeight, bHeight);
+            return new effects_1.ClipPathEffect((ctx) => {
+                ctx.beginPath();
+                ctx.ellipse(cx, cy, Math.max(0, rx), Math.max(0, ry), 0, 0, Math.PI * 2);
+                ctx.clip();
+            });
+        }
+        case 4 /* CLIP_PATH_TYPE.POLYGON */: {
+            // Pre-compute all vertices in page-absolute coordinates.
+            const absPoints = clipPath.points.map(([px, py]) => [bLeft + (0, length_percentage_1.getAbsoluteValue)(px, bWidth), bTop + (0, length_percentage_1.getAbsoluteValue)(py, bHeight)]);
+            return new effects_1.ClipPathEffect((ctx) => {
+                ctx.beginPath();
+                if (absPoints.length > 0) {
+                    ctx.moveTo(absPoints[0][0], absPoints[0][1]);
+                    for (let i = 1; i < absPoints.length; i++) {
+                        ctx.lineTo(absPoints[i][0], absPoints[i][1]);
+                    }
+                    ctx.closePath();
+                }
+                // Calling clip() with an empty path (zero points) is intentional:
+                // it clips the entire region to nothing, which is the correct
+                // behaviour for a degenerate polygon() per the CSS spec.
+                ctx.clip();
+            });
+        }
+        case 5 /* CLIP_PATH_TYPE.PATH */: {
+            // path() coordinates are in the element's local space (0,0 = element top-left).
+            // We temporarily translate the canvas origin to the element's position, clip
+            // with the Path2D, then restore only the transform matrix (not the clipping
+            // region) via setTransform so the clip persists for the enclosing
+            // ctx.save() / ctx.restore() pair managed by EffectsRenderer.
+            //
+            // When the element also has a CSS transform, that transform was already applied
+            // by a preceding TransformEffect, so the path coordinates end up correctly in
+            // the element's transformed local space — matching browser behaviour.
+            const { d } = clipPath;
+            let cachedPath = null;
+            return new effects_1.ClipPathEffect((ctx) => {
+                try {
+                    if (!cachedPath) {
+                        cachedPath = new Path2D(d);
+                    }
+                    const savedTransform = ctx.getTransform();
+                    ctx.translate(bLeft, bTop);
+                    ctx.clip(cachedPath);
+                    ctx.setTransform(savedTransform);
+                }
+                catch (_e) {
+                    // Path2D or getTransform/setTransform not supported in this environment.
+                }
+            });
+        }
+        case 0 /* CLIP_PATH_TYPE.NONE */:
+            return null;
+        default: {
+            // Exhaustiveness guard: if a new CLIP_PATH_TYPE is added in the future
+            // without a corresponding case above, TypeScript will raise a compile-time
+            // error here rather than silently falling through.
+            const _exhaustive = clipPath;
+            void _exhaustive;
+            return null;
+        }
+    }
+};
+exports.buildClipPathEffect = buildClipPathEffect;
+const parseStackTree = (parent, stackingContext, realStackingContext, listItems) => {
+    parent.container.elements.forEach((child) => {
+        const treatAsRealStackingContext = child.createsRealStackingContext;
+        const createsStackingContext = child.createsStackingContext;
+        const paintContainer = new ElementPaint(child, parent);
+        if ((0, bitwise_1.contains)(child.styles.display, 2048 /* DISPLAY.LIST_ITEM */)) {
+            listItems.push(paintContainer);
+        }
+        const listOwnerItems = child.isListOwner ? [] : listItems;
+        if (treatAsRealStackingContext || createsStackingContext) {
+            const parentStack = treatAsRealStackingContext || child.styles.isPositioned() ? realStackingContext : stackingContext;
+            const stack = new StackingContext(paintContainer);
+            if (child.styles.isPositioned() || child.styles.opacity < 1 || child.styles.isTransformed()) {
+                const order = child.styles.zIndex.order;
+                if (order < 0) {
+                    let index = 0;
+                    parentStack.negativeZIndex.some((current, i) => {
+                        if (order > current.element.container.styles.zIndex.order) {
+                            index = i;
+                            return false;
+                        }
+                        else if (index > 0) {
+                            return true;
+                        }
+                        return false;
+                    });
+                    parentStack.negativeZIndex.splice(index, 0, stack);
+                }
+                else if (order > 0) {
+                    let index = 0;
+                    parentStack.positiveZIndex.some((current, i) => {
+                        if (order >= current.element.container.styles.zIndex.order) {
+                            index = i + 1;
+                            return false;
+                        }
+                        else if (index > 0) {
+                            return true;
+                        }
+                        return false;
+                    });
+                    parentStack.positiveZIndex.splice(index, 0, stack);
+                }
+                else {
+                    parentStack.zeroOrAutoZIndexOrTransformedOrOpacity.push(stack);
+                }
+            }
+            else {
+                if (child.styles.isFloating()) {
+                    parentStack.nonPositionedFloats.push(stack);
+                }
+                else {
+                    parentStack.nonPositionedInlineLevel.push(stack);
+                }
+            }
+            parseStackTree(paintContainer, stack, treatAsRealStackingContext ? stack : realStackingContext, listOwnerItems);
+        }
+        else {
+            if (child.styles.isInlineLevel()) {
+                stackingContext.inlineLevel.push(paintContainer);
+            }
+            else {
+                stackingContext.nonInlineLevel.push(paintContainer);
+            }
+            parseStackTree(paintContainer, stackingContext, realStackingContext, listOwnerItems);
+        }
+        if (child.isListOwner) {
+            processListItems(child, listOwnerItems);
+        }
+    });
+};
+const processListItems = (owner, elements) => {
+    let numbering = owner instanceof ol_element_container_1.OLElementContainer ? owner.start : 1;
+    const reversed = owner instanceof ol_element_container_1.OLElementContainer ? owner.reversed : false;
+    for (let i = 0; i < elements.length; i++) {
+        const item = elements[i];
+        if (item.container instanceof li_element_container_1.LIElementContainer &&
+            typeof item.container.value === 'number' &&
+            item.container.value !== 0) {
+            numbering = item.container.value;
+        }
+        item.listValue = (0, counter_1.createCounterText)(numbering, item.container.styles.listStyleType, true);
+        numbering += reversed ? -1 : 1;
+    }
+};
+const parseStackingContexts = (container) => {
+    const paintContainer = new ElementPaint(container, null);
+    const root = new StackingContext(paintContainer);
+    const listItems = [];
+    parseStackTree(paintContainer, root, root, listItems);
+    processListItems(paintContainer.container, listItems);
+    return root;
+};
+exports.parseStackingContexts = parseStackingContexts;

package/dist/lib/render/vector.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVector = exports.Vector = void 0;
+class Vector {
+    constructor(x, y) {
+        this.type = 0 /* PathType.VECTOR */;
+        this.x = x;
+        this.y = y;
+    }
+    add(deltaX, deltaY) {
+        return new Vector(this.x + deltaX, this.y + deltaY);
+    }
+}
+exports.Vector = Vector;
+const isVector = (path) => path.type === 0 /* PathType.VECTOR */;
+exports.isVector = isVector;

package/dist/types/config.d.ts

@@ -0,0 +1,44 @@
+import { Cache } from './core/cache-storage';
+/**
+ * Configuration options for Html2Canvas
+ *
+ * This class manages global configuration without using module-level static variables.
+ * Each html2canvas invocation can have its own configuration instance.
+ */
+export interface ConfigOptions {
+    /**
+     * Window object to use for DOM operations
+     */
+    window?: Window;
+    /**
+     * CSP nonce for inline styles
+     * See: https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP
+     */
+    cspNonce?: string;
+    /**
+     * Cache instance to reuse across multiple calls
+     * Useful for avoiding redundant image loads
+     */
+    cache?: Cache;
+}
+/**
+ * Html2Canvas Configuration
+ *
+ * Manages configuration state for html2canvas rendering.
+ * Eliminates the need for global static variables.
+ */
+export declare class Html2CanvasConfig {
+    readonly window: Window;
+    readonly cspNonce?: string;
+    readonly cache?: Cache;
+    constructor(options?: ConfigOptions);
+    /**
+     * Create configuration from an element
+     * Extracts window from element's owner document
+     */
+    static fromElement(element: HTMLElement, options?: Partial<ConfigOptions>): Html2CanvasConfig;
+    /**
+     * Clone configuration with override options
+     */
+    clone(options?: Partial<ConfigOptions>): Html2CanvasConfig;
+}

package/dist/types/core/abort-helper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AbortSignal helper utilities.
+ */
+/**
+ * Throw a DOMException if the given AbortSignal is already aborted.
+ * Used at checkpoints throughout the rendering pipeline to support
+ * cancellable renders.
+ *
+ * @param signal - The AbortSignal to check. If undefined or not aborted, this is a no-op.
+ * @throws {DOMException} With name 'AbortError' if the signal has been aborted.
+ */
+export declare const throwIfAborted: (signal?: AbortSignal) => void;

package/dist/types/core/background-parser.d.ts

@@ -0,0 +1,16 @@
+import { type Color } from '../css/types/color';
+import type { Context } from './context';
+/**
+ * Resolve the background colour for the rendered canvas, following CSS
+ * background propagation rules:
+ *
+ * 1. If the target element is `<html>`, inherit the first opaque ancestor
+ *    (doc → body → fallback).
+ * 2. Otherwise use the user-supplied backgroundColor, or opaque white.
+ *
+ * @param context               - Current rendering context.
+ * @param element               - The root element being rendered.
+ * @param backgroundColorOverride - User-supplied override (string | null).
+ * @returns A resolved colour value suitable for filling the canvas.
+ */
+export declare const parseBackgroundColor: (context: Context, element: HTMLElement, backgroundColorOverride?: string | null) => Color;

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

@@ -0,0 +1 @@
+export declare const contains: (bit: number, value: number) => boolean;

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

@@ -0,0 +1,68 @@
+import { Context } from './context';
+export interface ResourceOptions {
+    imageTimeout: number;
+    useCORS: boolean;
+    allowTaint: boolean;
+    proxy?: string;
+    customIsSameOrigin?: (this: void, src: string, oldFn: (src: string) => boolean) => boolean | Promise<boolean>;
+    maxCacheSize?: number;
+}
+export declare class Cache {
+    private readonly context;
+    private readonly _options;
+    private readonly _cache;
+    private readonly maxSize;
+    private readonly _pendingOperations;
+    /** When true, addImage() collects URLs without starting loads. */
+    private _deferMode;
+    /** URLs collected during defer mode, pending batch preload. */
+    private _collectedUrls;
+    constructor(context: Context, _options: ResourceOptions);
+    /**
+     * Enter defer mode: subsequent addImage() calls only collect URLs.
+     * Call preloadAll() to exit defer mode and batch-load all URLs.
+     */
+    startDefer(): void;
+    /**
+     * Exit defer mode and load all collected URLs in parallel, respecting
+     * 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.
+     *
+     * @param concurrency - Max concurrent image loads (1–100, default 10).
+     */
+    preloadAll(concurrency?: number): Promise<void>;
+    addImage(src: string): Promise<void>;
+    /**
+     * Shared helper: enqueues loading for a single URL with pending-operation
+     * deduplication and error swallowing. Used by both addImage() (normal mode)
+     * and preloadAll() (batch mode).
+     */
+    private _addImageWithPending;
+    private _addImageInternal;
+    private withTimeout;
+    match(src: string): Promise<HTMLImageElement | HTMLCanvasElement | undefined> | undefined;
+    /**
+     * Set a value in cache with LRU eviction (O(1) via Map insertion order).
+     * Map preserves insertion order; delete+set on access moves items to the end.
+     * The first key in Map.keys() is always the least recently used.
+     */
+    private set;
+    /**
+     * Get cache size
+     */
+    size(): number;
+    /**
+     * Get max cache size
+     */
+    getMaxSize(): number;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    private loadImage;
+    private has;
+    keys(): Promise<string[]>;
+    private proxy;
+}

package/dist/types/core/config-assembler.d.ts

@@ -0,0 +1,28 @@
+import type { Options } from '../options';
+import type { Html2CanvasConfig } from '../config';
+import type { ResourceOptions } from './cache-storage';
+import type { ContextOptions } from './context';
+import type { CloneConfigurations } from '../dom/document-cloner';
+import type { RenderConfigurations } from '../render/canvas/canvas-renderer';
+/**
+ * Coerce known numeric options from string (or other) values to actual numbers.
+ * Mutates the opts object in place — this is intentionally a normalisation
+ * (not pure) step that runs once at the beginning of renderElement.
+ */
+export declare const coerceNumberOptions: (opts: Partial<Options>) => void;
+/** Assemble resource loading options from user-provided Options. */
+export declare const assembleResourceOptions: (opts: Partial<Options>) => ResourceOptions;
+/** Assemble context (logging + cache) options, extending resource options. */
+export declare const assembleContextOptions: (opts: Partial<Options>, config: Html2CanvasConfig, resourceOptions: ResourceOptions) => ContextOptions;
+/** Assemble window / viewport options. */
+export interface AssembledWindowOptions {
+    windowWidth: number;
+    windowHeight: number;
+    scrollX: number;
+    scrollY: number;
+}
+export declare const assembleWindowOptions: (opts: Partial<Options>, defaultView: Window) => AssembledWindowOptions;
+/** Assemble DOM cloning options. */
+export declare const assembleCloneOptions: (opts: Partial<Options>, config: Html2CanvasConfig, foreignObjectRendering: boolean) => CloneConfigurations;
+/** Assemble canvas rendering options. */
+export declare const assembleRenderOptions: (opts: Partial<Options>, backgroundColor: number | null, left: number, top: number, width: number, height: number, devicePixelRatio: number) => RenderConfigurations;

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

@@ -0,0 +1,22 @@
+/**
+ * Shared numeric constants used across html2canvas-pro.
+ * Centralising magic numbers for maintainability.
+ */
+/** Maximum entries in the CSS parse cache per descriptor (LRU). */
+export declare const PARSE_CACHE_MAX_PER_DESCRIPTOR = 200;
+/** Maximum cached background-image patterns per render session (LRU). */
+export declare const PATTERN_CACHE_MAX = 50;
+/** Maximum size of the image-resource cache (entries). */
+export declare const DEFAULT_IMAGE_CACHE_SIZE = 100;
+/** Maximum allowed image-resource cache size. */
+export declare const MAX_IMAGE_CACHE_SIZE = 10000;
+/** Default image-load timeout in milliseconds. */
+export declare const DEFAULT_IMAGE_TIMEOUT_MS = 15000;
+/** Z-axis mask offset used during box-shadow rendering. */
+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;
+/** 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. */
+export declare const RESOURCE_KEY_LOG_LENGTH = 256;

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

@@ -0,0 +1,22 @@
+import { Logger } from './logger';
+import { Cache, ResourceOptions } from './cache-storage';
+import { Bounds } from '../css/layout/bounds';
+import { OriginChecker } from './origin-checker';
+import { Html2CanvasConfig } from '../config';
+export type ContextOptions = {
+    logging: boolean;
+    cache?: Cache;
+    /** Called when a resource fails to load. */
+    onError?: (error: Error) => void;
+} & ResourceOptions;
+export declare class Context {
+    windowBounds: Bounds;
+    private readonly instanceName;
+    readonly logger: Logger;
+    readonly cache: Cache;
+    readonly originChecker: OriginChecker;
+    readonly config: Html2CanvasConfig;
+    readonly onError?: (error: Error) => void;
+    private static instanceCount;
+    constructor(options: ContextOptions, windowBounds: Bounds, config: Html2CanvasConfig);
+}

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

@@ -0,0 +1,8 @@
+export declare const enum DebuggerType {
+    NONE = 0,
+    ALL = 1,
+    CLONE = 2,
+    PARSE = 3,
+    RENDER = 4
+}
+export declare const isDebugging: (element: Element, type: Omit<DebuggerType, DebuggerType.NONE>) => boolean;

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

@@ -0,0 +1,12 @@
+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/logger.d.ts

@@ -0,0 +1,18 @@
+export interface LoggerOptions {
+    id: string;
+    enabled: boolean;
+}
+export declare class Logger {
+    static instances: {
+        [key: string]: Logger;
+    };
+    private readonly id;
+    private readonly enabled;
+    private readonly start;
+    constructor({ id, enabled }: LoggerOptions);
+    debug(...args: unknown[]): void;
+    getTime(): number;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}

package/dist/types/core/lru-map.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Generic LRU (Least-Recently-Used) wrapper over a native `Map`.
+ *
+ * Both the CSS parse cache and the background pattern cache implement the
+ * same LRU eviction pattern using Map's insertion-order guarantee.  This
+ * tiny utility centralises that logic so it can be reused without
+ * duplication.
+ *
+ * Usage:
+ * ```ts
+ * const cache = new LRUMap<string, CanvasPattern>(50);
+ * const entry = cache.get(key); // promotes if found, returns undefined otherwise
+ * cache.set(key, value);         // evicts oldest entry when at capacity
+ * ```
+ */
+export declare class LRUMap<K, V> {
+    private readonly maxSize;
+    private readonly _map;
+    constructor(maxSize: number);
+    /**
+     * Get a value by key.
+     * On cache hit the entry is promoted to the end of the Map (most-recently-used).
+     * Returns `undefined` on miss.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Insert or update a key-value pair.
+     * If the key already exists it is moved to MRU position.  If the map is
+     * at capacity the least-recently-used entry (oldest insertion order) is
+     * evicted before inserting.
+     */
+    set(key: K, value: V): void;
+    /** Current number of entries. */
+    get size(): number;
+    /** Remove all entries. */
+    clear(): void;
+}