html2canvas-pro 1.6.7 → 2.0.1

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

@@ -7,6 +7,7 @@ import { backgroundSize } from './property-descriptors/background-size';
 import { borderBottomLeftRadius, borderBottomRightRadius, borderTopLeftRadius, borderTopRightRadius } from './property-descriptors/border-radius';
 import { borderBottomStyle, borderLeftStyle, borderRightStyle, borderTopStyle } from './property-descriptors/border-style';
 import { borderBottomWidth, borderLeftWidth, borderRightWidth, borderTopWidth } from './property-descriptors/border-width';
+import { ClipPathValue } from './property-descriptors/clip-path';
 import { direction } from './property-descriptors/direction';
 import { display } from './property-descriptors/display';
 import { float } from './property-descriptors/float';
@@ -51,6 +52,7 @@ import { webkitLineClamp } from './property-descriptors/webkit-line-clamp';
 import { Context } from '../core/context';
 import { objectFit } from './property-descriptors/object-fit';
 import { textOverflow } from './property-descriptors/text-overflow';
+import { imageRendering } from './property-descriptors/image-rendering';
 export declare class CSSParsedDeclaration {
     animationDuration: ReturnType<typeof duration.parse>;
     backgroundClip: ReturnType<typeof backgroundClip.parse>;
@@ -77,6 +79,7 @@ export declare class CSSParsedDeclaration {
     borderBottomWidth: ReturnType<typeof borderBottomWidth.parse>;
     borderLeftWidth: ReturnType<typeof borderLeftWidth.parse>;
     boxShadow: ReturnType<typeof boxShadow.parse>;
+    clipPath: ClipPathValue;
     color: Color;
     direction: ReturnType<typeof direction.parse>;
     display: ReturnType<typeof display.parse>;
@@ -125,6 +128,7 @@ export declare class CSSParsedDeclaration {
     wordBreak: ReturnType<typeof wordBreak.parse>;
     zIndex: ReturnType<typeof zIndex.parse>;
     objectFit: ReturnType<typeof objectFit.parse>;
+    imageRendering: ReturnType<typeof imageRendering.parse>;
     constructor(context: Context, declaration: CSSStyleDeclaration);
     isVisible(): boolean;
     isTransparent(): boolean;

package/dist/types/css/property-descriptors/__tests__/clip-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/css/property-descriptors/__tests__/image-rendering-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/css/property-descriptors/__tests__/image-rendering-performance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/css/property-descriptors/__tests__/image-rendering.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/css/property-descriptors/clip-path.d.ts

@@ -0,0 +1,62 @@
+import { IPropertyValueDescriptor } from '../IPropertyDescriptor';
+import { LengthPercentage } from '../types/length-percentage';
+export declare const enum CLIP_PATH_TYPE {
+    NONE = 0,
+    INSET = 1,
+    CIRCLE = 2,
+    ELLIPSE = 3,
+    POLYGON = 4,
+    PATH = 5
+}
+/** Radius keyword or length-percentage for circle/ellipse. */
+export type ShapeRadius = LengthPercentage | 'closest-side' | 'farthest-side';
+export interface NoneClipPath {
+    type: CLIP_PATH_TYPE.NONE;
+}
+/**
+ * inset(top right bottom left [ round <border-radius> ]?)
+ * Amounts to cut from each side of the reference box.
+ */
+export interface InsetClipPath {
+    type: CLIP_PATH_TYPE.INSET;
+    top: LengthPercentage;
+    right: LengthPercentage;
+    bottom: LengthPercentage;
+    left: LengthPercentage;
+}
+/**
+ * circle( [ <shape-radius> ]? [ at <position> ]? )
+ */
+export interface CircleClipPath {
+    type: CLIP_PATH_TYPE.CIRCLE;
+    radius: ShapeRadius;
+    cx: LengthPercentage;
+    cy: LengthPercentage;
+}
+/**
+ * ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )
+ */
+export interface EllipseClipPath {
+    type: CLIP_PATH_TYPE.ELLIPSE;
+    rx: ShapeRadius;
+    ry: ShapeRadius;
+    cx: LengthPercentage;
+    cy: LengthPercentage;
+}
+/**
+ * polygon( [ <fill-rule>, ]? [ <length-percentage> <length-percentage> ]# )
+ */
+export interface PolygonClipPath {
+    type: CLIP_PATH_TYPE.POLYGON;
+    points: [LengthPercentage, LengthPercentage][];
+}
+/**
+ * path( [ <fill-rule>, ]? <string> )
+ * The string contains SVG path data in the element's local coordinate space.
+ */
+export interface PathClipPath {
+    type: CLIP_PATH_TYPE.PATH;
+    d: string;
+}
+export type ClipPathValue = NoneClipPath | InsetClipPath | CircleClipPath | EllipseClipPath | PolygonClipPath | PathClipPath;
+export declare const clipPath: IPropertyValueDescriptor<ClipPathValue>;

package/dist/types/css/property-descriptors/image-rendering.d.ts

@@ -0,0 +1,8 @@
+import { IPropertyIdentValueDescriptor } from '../IPropertyDescriptor';
+export declare enum IMAGE_RENDERING {
+    AUTO = 0,
+    CRISP_EDGES = 1,
+    PIXELATED = 2,
+    SMOOTH = 3
+}
+export declare const imageRendering: IPropertyIdentValueDescriptor<IMAGE_RENDERING>;

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

@@ -0,0 +1,12 @@
+/**
+ * Color mathematics utilities
+ * Extracted to break circular dependency between srgb.ts and color-utilities.ts
+ */
+/**
+ * Clamp a value between min and max
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+/**
+ * Multiply two 3x3 matrices
+ */
+export declare const multiplyMatrices: (A: number[], B: number[]) => [number, number, number];

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

@@ -1,13 +1,13 @@
 import { Context } from '../../core/context';
 import { CSSValue } from '../syntax/parser';
+import { clamp, multiplyMatrices } from './color-math';
 type Color = number;
 export declare const isTransparent: (color: Color) => boolean;
 export declare const asString: (color: Color) => string;
 export declare const pack: (r: number, g: number, b: number, a: number) => Color;
 export declare const getTokenColorValue: (token: CSSValue, i: number) => number;
 export declare const isRelativeTransform: (tokens: CSSValue[]) => boolean;
-export declare const clamp: (value: number, min: number, max: number) => number;
-export declare const multiplyMatrices: (A: number[], B: number[]) => [number, number, number];
+export { clamp, multiplyMatrices };
 export declare const packSrgb: (args: number[]) => number;
 export declare const packSrgbLinear: ([r, g, b, a]: [number, number, number, number]) => number;
 export declare const packXYZ: (args: number[]) => number;
@@ -105,4 +105,3 @@ export declare const convertXyz: (args: number[]) => number;
  * @param args
  */
 export declare const convertXyz50: (args: number[]) => number;
-export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/types/dom/__tests__/element-container.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,62 @@
+/**
+ * DOM Normalizer
+ * Handles DOM side effects that need to happen before rendering
+ * Extracted from ElementContainer to follow SRP
+ */
+import { CSSParsedDeclaration } from '../css';
+/**
+ * Stored original styles for restoration
+ */
+export interface OriginalStyles {
+    animationDuration?: string;
+    transform?: string;
+    rotate?: string;
+}
+/**
+ * Normalize element styles for accurate rendering
+ * This includes disabling animations and neutralizing transforms.
+ */
+export declare class DOMNormalizer {
+    /**
+     * Normalize a single element and return original styles.
+     *
+     * ## Why we replace transforms with an identity value instead of "none"
+     *
+     * `getBoundingClientRect()` returns visual (post-transform) coordinates, so we
+     * must neutralize any active transform before measuring element bounds.
+     *
+     * The naive approach of setting `transform: none` (or `rotate: none`) has a
+     * critical side-effect: per **CSS Transforms Level 2**, an element whose
+     * `transform` is non-none automatically becomes the **containing block** for
+     * all of its `position: absolute` *and* `position: fixed` descendants.
+     * Setting it to `none` destroys that role, causing children to resolve their
+     * percentage dimensions and offsets against an unintended ancestor — which
+     * produces completely wrong bounds.
+     *
+     * Solution: instead of removing the transform, we replace it with a visually
+     * inert identity value:
+     *
+     * - `transform: scale(0.5)` → `transform: translate(0, 0)`
+     *   - `translate(0, 0)` is an identity transform (no visual change, no layout shift).
+     *   - `getBoundingClientRect()` returns the same layout-space coordinates as
+     *     if there were no transform at all.
+     *   - Because the value is still non-none, the element **remains a containing
+     *     block** for both `position: absolute` and `position: fixed` descendants.
+     *
+     * - `rotate: 45deg` → `rotate: 0deg`
+     *   - `0deg` is the identity rotation; `0deg ≠ none`, so the same containing-
+     *     block guarantee holds.
+     *
+     * @param element - Element to normalize
+     * @param styles - Parsed CSS styles
+     * @returns Original styles map for restoration
+     */
+    static normalizeElement(element: Element, styles: CSSParsedDeclaration): OriginalStyles;
+    /**
+     * Restore element styles after rendering.
+     *
+     * @param element - Element to restore
+     * @param originalStyles - Original styles to restore
+     */
+    static restoreElement(element: Element, originalStyles: OriginalStyles): void;
+}

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

@@ -8,6 +8,13 @@ export declare const enum FLAGS {
     IS_LIST_OWNER = 8,
     DEBUG_RENDER = 16
 }
+export interface ElementContainerOptions {
+    /**
+     * Whether to normalize DOM (disable animations, reset transforms)
+     * Default: true for backward compatibility
+     */
+    normalizeDom?: boolean;
+}
 export declare class ElementContainer {
     protected readonly context: Context;
     readonly styles: CSSParsedDeclaration;
@@ -15,5 +22,17 @@ export declare class ElementContainer {
     readonly elements: ElementContainer[];
     bounds: Bounds;
     flags: number;
-    constructor(context: Context, element: Element);
+    private originalStyles?;
+    private originalElement?;
+    constructor(context: Context, element: Element, options?: ElementContainerOptions);
+    /**
+     * Restore original element styles (if normalized)
+     * Call this after rendering is complete to clean up DOM state
+     */
+    restore(): void;
+    /**
+     * Recursively restore all elements in the tree
+     * Call this on the root container after rendering is complete
+     */
+    restoreTree(): void;
 }

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

@@ -1,12 +1,8 @@
 import { ElementContainer } from './element-container';
 import { Context } from '../core/context';
+import { isElementNode, isTextNode, isSVGElementNode, isHTMLElementNode, isLIElement, isOLElement, isCustomElement } from './node-type-guards';
+export { isElementNode, isTextNode, isSVGElementNode, isHTMLElementNode, isLIElement, isOLElement, isCustomElement };
 export declare const parseTree: (context: Context, element: HTMLElement) => ElementContainer;
-export declare const isTextNode: (node: Node) => node is Text;
-export declare const isElementNode: (node: Node) => node is Element;
-export declare const isHTMLElementNode: (node: Node) => node is HTMLElement;
-export declare const isSVGElementNode: (element: Element) => element is SVGElement;
-export declare const isLIElement: (node: Element) => node is HTMLLIElement;
-export declare const isOLElement: (node: Element) => node is HTMLOListElement;
 export declare const isInputElement: (node: Element) => node is HTMLInputElement;
 export declare const isHTMLElement: (node: Element) => node is HTMLHtmlElement;
 export declare const isSVGElement: (node: Element) => node is SVGSVGElement;
@@ -20,4 +16,3 @@ export declare const isScriptElement: (node: Element) => node is HTMLScriptEleme
 export declare const isTextareaElement: (node: Element) => node is HTMLTextAreaElement;
 export declare const isSelectElement: (node: Element) => node is HTMLSelectElement;
 export declare const isSlotElement: (node: Element) => node is HTMLSlotElement;
-export declare const isCustomElement: (node: Element) => node is HTMLElement;

package/dist/types/dom/node-type-guards.d.ts

@@ -0,0 +1,33 @@
+/**
+ * DOM Node Type Guards
+ * Extracted to break circular dependencies
+ */
+/**
+ * Check if node is an Element
+ */
+export declare const isElementNode: (node: Node) => node is Element;
+/**
+ * Check if node is a Text node
+ */
+export declare const isTextNode: (node: Node) => node is Text;
+/**
+ * Check if element is an SVG element
+ */
+export declare const isSVGElementNode: (element: Element) => element is SVGElement;
+/**
+ * Check if node is an HTML element
+ */
+export declare const isHTMLElementNode: (node: Node) => node is HTMLElement;
+/**
+ * Check if node is an LI element
+ */
+export declare const isLIElement: (node: Element) => node is HTMLLIElement;
+/**
+ * Check if node is an OL element
+ */
+export declare const isOLElement: (node: Element) => node is HTMLOListElement;
+/**
+ * Check if element is a custom element
+ * Custom elements must have a hyphen and cannot be SVG elements
+ */
+export declare const isCustomElement: (element: Element) => element is HTMLElement;

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

@@ -1,11 +1,14 @@
 import { ElementContainer } from '../element-container';
 import { Color } from '../../css/types/color';
 import { Context } from '../../core/context';
+type ParseTreeFunction = (context: Context, node: Node) => ElementContainer;
 export declare class IFrameElementContainer extends ElementContainer {
     src: string;
     width: number;
     height: number;
     tree?: ElementContainer;
     backgroundColor: Color;
-    constructor(context: Context, iframe: HTMLIFrameElement);
+    private parseTreeFn?;
+    constructor(context: Context, iframe: HTMLIFrameElement, parseTreeFn?: ParseTreeFunction);
 }
+export {};

package/dist/types/index.d.ts

@@ -1,15 +1,60 @@
 import { CloneOptions, WindowOptions } from './dom/document-cloner';
 import { RenderOptions } from './render/canvas/canvas-renderer';
 import { ContextOptions } from './core/context';
+import { Html2CanvasConfig, ConfigOptions } from './config';
+import { createDefaultValidator, Validator, ValidationResult } from './core/validator';
+import { PerformanceMonitor } from './core/performance-monitor';
 export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOptions & {
     backgroundColor: string | null;
     foreignObjectRendering: boolean;
     removeContainer?: boolean;
+    cspNonce?: string;
+    validator?: Validator;
+    skipValidation?: boolean;
+    enablePerformanceMonitoring?: boolean;
+    /**
+     * Enable/disable image smoothing (anti-aliasing) globally.
+     * - `false`: Pixel-perfect rendering for pixel art, sprites, and retro graphics
+     * - `true`: Smooth rendering for photos and high-quality images
+     * - CSS `image-rendering` property on individual elements takes precedence
+     * @default true (browser default)
+     * @example
+     * // Pixel art game screenshot
+     * html2canvas(element, { imageSmoothing: false, scale: 2 });
+     *
+     * // High-quality photo
+     * html2canvas(element, { imageSmoothing: true, imageSmoothingQuality: 'high' });
+     */
+    imageSmoothing?: boolean;
+    /**
+     * Image smoothing quality level when imageSmoothing is enabled.
+     * - `'low'`: Faster, lower quality (good for preview)
+     * - `'medium'`: Balanced (default in most browsers)
+     * - `'high'`: Slower, best quality (good for final export)
+     *
+     * Browser support: Chrome 54+, Firefox 94+, Safari 17+
+     * Falls back gracefully in older browsers.
+     * @default browser default (usually 'low' or 'medium')
+     */
+    imageSmoothingQuality?: 'low' | 'medium' | 'high';
 };
-declare const setCspNonce: (nonce: string) => void;
+/**
+ * Main html2canvas function with improved configuration management
+ *
+ * @param element - Element to render
+ * @param options - Rendering options
+ * @param config - Optional configuration (for advanced use cases)
+ * @returns Promise resolving to rendered canvas
+ */
 declare const html2canvas: {
-    (element: HTMLElement, options?: Partial<Options>): Promise<HTMLCanvasElement>;
+    (element: HTMLElement, options?: Partial<Options>, config?: Html2CanvasConfig): Promise<HTMLCanvasElement>;
     setCspNonce: (nonce: string) => void;
 };
+/**
+ * Set CSP nonce for inline styles
+ * @deprecated Use options.cspNonce instead
+ */
+declare const setCspNonce: (nonce: string) => void;
 export default html2canvas;
-export { html2canvas, setCspNonce };
+export { html2canvas, setCspNonce, Html2CanvasConfig, ConfigOptions, Validator, ValidationResult, createDefaultValidator, PerformanceMonitor };
+export { IMAGE_RENDERING } from './css/property-descriptors/image-rendering';

package/dist/types/render/canvas/__tests__/background-renderer.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/types/render/canvas/__tests__/effects-renderer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/render/canvas/__tests__/text-renderer.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,87 @@
+/**
+ * Background Renderer
+ *
+ * Handles rendering of element backgrounds including:
+ * - Background colors
+ * - Background images (URL)
+ * - Linear gradients
+ * - Radial gradients
+ * - Background patterns and repeats
+ */
+import { Context } from '../../core/context';
+import { ElementContainer } from '../../dom/element-container';
+/**
+ * Dependencies required for BackgroundRenderer
+ */
+export interface BackgroundRendererDependencies {
+    ctx: CanvasRenderingContext2D;
+    context: Context;
+    canvas: HTMLCanvasElement;
+    options: {
+        width: number;
+        height: number;
+        scale: number;
+    };
+}
+/**
+ * Background Renderer
+ *
+ * Specialized renderer for element backgrounds.
+ * Extracted from CanvasRenderer to improve code organization and maintainability.
+ */
+export declare class BackgroundRenderer {
+    private readonly ctx;
+    private readonly context;
+    private readonly canvas;
+    constructor(deps: BackgroundRendererDependencies);
+    /**
+     * Render background images for a container
+     * Supports URL images, linear gradients, and radial gradients
+     *
+     * @param container - Element container with background styles
+     */
+    renderBackgroundImage(container: ElementContainer): Promise<void>;
+    /**
+     * Render a URL-based background image
+     */
+    private renderBackgroundURLImage;
+    /**
+     * Render a linear gradient background
+     */
+    private renderLinearGradient;
+    /**
+     * Render a radial gradient background
+     */
+    private renderRadialGradient;
+    /**
+     * Render a repeating pattern with offset
+     *
+     * @param path - Path to fill
+     * @param pattern - Canvas pattern or gradient
+     * @param offsetX - X offset for pattern
+     * @param offsetY - Y offset for pattern
+     */
+    private renderRepeat;
+    /**
+     * Resize an image to target dimensions
+     *
+     * @param image - Source image
+     * @param width - Target width
+     * @param height - Target height
+     * @param imageRendering - CSS image-rendering property value
+     * @returns Resized canvas or original image
+     */
+    private resizeImage;
+    /**
+     * Create a canvas path from path array
+     *
+     * @param paths - Array of path points
+     */
+    private path;
+    /**
+     * Format path points into canvas path
+     *
+     * @param paths - Array of path points
+     */
+    private formatPath;
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Border Renderer
+ *
+ * Handles rendering of element borders including:
+ * - Solid borders
+ * - Double borders
+ * - Dashed borders
+ * - Dotted borders
+ */
+import { Color } from '../../css/types/color';
+import { BoundCurves } from '../bound-curves';
+import { BORDER_STYLE } from '../../css/property-descriptors/border-style';
+import { Path } from '../path';
+/**
+ * Dependencies required for BorderRenderer
+ */
+export interface BorderRendererDependencies {
+    ctx: CanvasRenderingContext2D;
+}
+/**
+ * Path creation callbacks
+ * The main CanvasRenderer retains path() and formatPath() methods,
+ * so we inject them as callbacks to avoid duplication
+ */
+export interface PathCallbacks {
+    path(paths: Path[]): void;
+    formatPath(paths: Path[]): void;
+}
+/**
+ * Border Renderer
+ *
+ * Specialized renderer for element borders.
+ * Extracted from CanvasRenderer to improve code organization and maintainability.
+ */
+export declare class BorderRenderer {
+    private readonly ctx;
+    private pathCallbacks;
+    constructor(deps: BorderRendererDependencies, pathCallbacks: PathCallbacks);
+    /**
+     * Render a solid border
+     *
+     * @param color - Border color
+     * @param side - Border side (0=top, 1=right, 2=bottom, 3=left)
+     * @param curvePoints - Border curve points
+     */
+    renderSolidBorder(color: Color, side: number, curvePoints: BoundCurves): Promise<void>;
+    /**
+     * Render a double border
+     * Falls back to solid border if width is too small
+     *
+     * @param color - Border color
+     * @param width - Border width
+     * @param side - Border side (0=top, 1=right, 2=bottom, 3=left)
+     * @param curvePoints - Border curve points
+     */
+    renderDoubleBorder(color: Color, width: number, side: number, curvePoints: BoundCurves): Promise<void>;
+    /**
+     * Render a dashed or dotted border
+     *
+     * @param color - Border color
+     * @param width - Border width
+     * @param side - Border side (0=top, 1=right, 2=bottom, 3=left)
+     * @param curvePoints - Border curve points
+     * @param style - Border style (DASHED or DOTTED)
+     */
+    renderDashedDottedBorder(color: Color, width: number, side: number, curvePoints: BoundCurves, style: BORDER_STYLE): Promise<void>;
+}

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

@@ -1,19 +1,28 @@
 import { ElementPaint, StackingContext } from '../stacking-context';
 import { Color } from '../../css/types/color';
 import { ElementContainer } from '../../dom/element-container';
-import { BORDER_STYLE } from '../../css/property-descriptors/border-style';
-import { CSSParsedDeclaration } from '../../css';
-import { TextContainer } from '../../dom/text-container';
 import { Path } from '../path';
 import { BoundCurves } from '../bound-curves';
-import { TextBounds } from '../../css/layout/text';
 import { ReplacedElementContainer } from '../../dom/replaced-elements';
-import { IElementEffect } from '../effects';
-import { Bounds } from '../../css/layout/bounds';
 import { Renderer } from '../renderer';
 import { Context } from '../../core/context';
 export type RenderConfigurations = RenderOptions & {
     backgroundColor: Color | null;
+    /**
+     * Enable/disable image smoothing (anti-aliasing).
+     * When disabled, images are rendered with pixel-perfect sharpness (no interpolation).
+     * CSS `image-rendering` property on individual elements takes precedence.
+     * @default browser default (usually true)
+     */
+    imageSmoothing?: boolean;
+    /**
+     * Image smoothing quality level when imageSmoothing is enabled.
+     * Higher quality may be slower for large images.
+     * Only supported in modern browsers (Chrome 54+, Firefox 94+, Safari 17+).
+     * Falls back gracefully in older browsers.
+     * @default browser default
+     */
+    imageSmoothingQuality?: 'low' | 'medium' | 'high';
 };
 export interface RenderOptions {
     scale: number;
@@ -26,37 +35,24 @@ export interface RenderOptions {
 export declare class CanvasRenderer extends Renderer {
     canvas: HTMLCanvasElement;
     ctx: CanvasRenderingContext2D;
-    private readonly _activeEffects;
     private readonly fontMetrics;
+    private readonly backgroundRenderer;
+    private readonly borderRenderer;
+    private readonly effectsRenderer;
+    private readonly textRenderer;
     constructor(context: Context, options: RenderConfigurations);
-    applyEffects(effects: IElementEffect[]): void;
-    applyEffect(effect: IElementEffect): void;
-    popEffect(): void;
     renderStack(stack: StackingContext): Promise<void>;
     renderNode(paint: ElementPaint): Promise<void>;
-    renderTextWithLetterSpacing(text: TextBounds, letterSpacing: number, baseline: number): void;
     /**
      * Helper method to render text with paint order support
      * Reduces code duplication in line-clamp and normal rendering
      */
-    private renderTextBoundWithPaintOrder;
-    private renderTextDecoration;
-    private drawDecorationLine;
-    private truncateTextWithEllipsis;
-    private createFontStyle;
-    renderTextNode(text: TextContainer, styles: CSSParsedDeclaration, containerBounds?: Bounds): Promise<void>;
     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;
-    renderRepeat(path: Path[], pattern: CanvasPattern | CanvasGradient, offsetX: number, offsetY: number): void;
-    resizeImage(image: HTMLImageElement, width: number, height: number): HTMLCanvasElement | HTMLImageElement;
-    renderBackgroundImage(container: ElementContainer): Promise<void>;
-    renderSolidBorder(color: Color, side: number, curvePoints: BoundCurves): Promise<void>;
-    renderDoubleBorder(color: Color, width: number, side: number, curvePoints: BoundCurves): Promise<void>;
     renderNodeBackgroundAndBorders(paint: ElementPaint): Promise<void>;
-    renderDashedDottedBorder(color: Color, width: number, side: number, curvePoints: BoundCurves, style: BORDER_STYLE): Promise<void>;
     render(element: ElementContainer): Promise<HTMLCanvasElement>;
 }