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

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

@@ -0,0 +1,107 @@
+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 { 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;
+export declare const packLab: (_context: Context, args: CSSValue[]) => number;
+export declare const packOkLab: (_context: Context, args: CSSValue[]) => number;
+export declare const packOkLch: (_context: Context, args: CSSValue[]) => number;
+export declare const packLch: (_context: Context, args: CSSValue[]) => number;
+export declare const extractHslComponents: (context: Context, args: CSSValue[]) => [number, number, number, number];
+export declare const packHSL: (context: Context, args: CSSValue[]) => number;
+export declare const extractLchComponents: (args: CSSValue[]) => [number, number, number, number];
+export declare const extractLabComponents: (args: CSSValue[]) => [number, number, number, number];
+export declare const extractOkLchComponents: (args: CSSValue[]) => [number, number, number, number];
+/**
+ * Convert D65 to D50
+ *
+ * @param xyz
+ */
+export declare const d65toD50: (xyz: [number, number, number]) => [number, number, number];
+/**
+ * Convert D50 to D65
+ *
+ * @param xyz
+ */
+export declare const d50toD65: (xyz: [number, number, number]) => [number, number, number];
+export declare const hue2rgb: (t1: number, t2: number, hue: number) => number;
+/**
+ * Convert RGB to XYZ
+ *
+ * @param _context
+ * @param args
+ */
+export declare const rgbToXyz: (_context: Context, args: CSSValue[]) => [number, number, number, number];
+/**
+ * HSL to XYZ
+ *
+ * @param context
+ * @param args
+ */
+export declare const hslToXyz: (context: Context, args: CSSValue[]) => [number, number, number, number];
+/**
+ * LAB to XYZ
+ *
+ * @param _context
+ * @param args
+ */
+export declare const labToXyz: (_context: Context, args: CSSValue[]) => [number, number, number, number];
+/**
+ * LCH to XYZ
+ *
+ * @param _context
+ * @param args
+ */
+export declare const lchToXyz: (_context: Context, args: CSSValue[]) => [number, number, number, number];
+/**
+ * OKLch to XYZ
+ *
+ * @param _context
+ * @param args
+ */
+export declare const oklchToXyz: (_context: Context, args: CSSValue[]) => [number, number, number, number];
+/**
+ * OKLab to XYZ
+ *
+ * @param _context
+ * @param args
+ */
+export declare const oklabToXyz: (_context: Context, args: CSSValue[]) => [number, number, number, number];
+/**
+ * XYZ-50 to XYZ
+ *
+ * @param args
+ */
+export declare const xyz50ToXYZ: (args: number[]) => [number, number, number];
+/**
+ * Does nothing, required for SUPPORTED_COLOR_SPACES_FROM_XYZ in the _color() function
+ *
+ * @param args
+ */
+export declare const xyzFromXYZ: (args: [number, number, number, number]) => [number, number, number, number];
+/**
+ * XYZ-65 to XYZ-50
+ *
+ * @param args
+ */
+export declare const xyz50FromXYZ: (args: [number, number, number, number]) => [number, number, number, number];
+/**
+ * Convert XYZ to SRGB and Pack
+ *
+ * @param args
+ */
+export declare const convertXyz: (args: number[]) => number;
+/**
+ * Convert XYZ-50 to SRGB and Pack
+ *
+ * @param args
+ */
+export declare const convertXyz50: (args: number[]) => number;

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

@@ -0,0 +1,8 @@
+import { ITypeDescriptor } from '../type-descriptor';
+import { Context } from '../../core/context';
+export type Color = number;
+export declare const color: ITypeDescriptor<Color>;
+export declare const parseColor: (context: Context, value: string) => Color;
+export declare const COLORS: {
+    [key: string]: Color;
+};

package/dist/types/css/types/functions/-prefix-linear-gradient.d.ts

@@ -0,0 +1,4 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSLinearGradientImage } from '../image';
+import { Context } from '../../../core/context';
+export declare const prefixLinearGradient: (context: Context, tokens: CSSValue[]) => CSSLinearGradientImage;

package/dist/types/css/types/functions/-prefix-radial-gradient.d.ts

@@ -0,0 +1,4 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSRadialGradientImage } from '../image';
+import { Context } from '../../../core/context';
+export declare const prefixRadialGradient: (context: Context, tokens: CSSValue[]) => CSSRadialGradientImage;

package/dist/types/css/types/functions/-webkit-gradient.d.ts

@@ -0,0 +1,4 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSLinearGradientImage, CSSRadialGradientImage } from '../image';
+import { Context } from '../../../core/context';
+export declare const webkitGradient: (context: Context, tokens: CSSValue[]) => CSSLinearGradientImage | CSSRadialGradientImage;

package/dist/types/css/types/functions/counter.d.ts

@@ -0,0 +1,10 @@
+import { LIST_STYLE_TYPE } from '../../property-descriptors/list-style-type';
+import { CSSParsedCounterDeclaration } from '../../index';
+export declare class CounterState {
+    private readonly counters;
+    getCounterValue(name: string): number;
+    getCounterValues(name: string): readonly number[];
+    pop(counters: string[]): void;
+    parse(style: CSSParsedCounterDeclaration): string[];
+}
+export declare const createCounterText: (value: number, type: LIST_STYLE_TYPE, appendSuffix: boolean) => string;

package/dist/types/css/types/functions/gradient.d.ts

@@ -0,0 +1,7 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSRadialGradientImage, GradientColorStop, GradientCorner, UnprocessedGradientColorStop } from '../image';
+import { Context } from '../../../core/context';
+export declare const parseColorStop: (context: Context, args: CSSValue[]) => UnprocessedGradientColorStop;
+export declare const processColorStops: (stops: UnprocessedGradientColorStop[], lineLength: number) => GradientColorStop[];
+export declare const calculateGradientDirection: (angle: number | GradientCorner, width: number, height: number) => [number, number, number, number, number];
+export declare const calculateRadius: (gradient: CSSRadialGradientImage, x: number, y: number, width: number, height: number) => [number, number];

package/dist/types/css/types/functions/linear-gradient.d.ts

@@ -0,0 +1,4 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSLinearGradientImage } from '../image';
+import { Context } from '../../../core/context';
+export declare const linearGradient: (context: Context, tokens: CSSValue[]) => CSSLinearGradientImage;

package/dist/types/css/types/functions/radial-gradient.d.ts

@@ -0,0 +1,12 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSRadialGradientImage } from '../image';
+import { Context } from '../../../core/context';
+export declare const CLOSEST_SIDE = "closest-side";
+export declare const FARTHEST_SIDE = "farthest-side";
+export declare const CLOSEST_CORNER = "closest-corner";
+export declare const FARTHEST_CORNER = "farthest-corner";
+export declare const CIRCLE = "circle";
+export declare const ELLIPSE = "ellipse";
+export declare const COVER = "cover";
+export declare const CONTAIN = "contain";
+export declare const radialGradient: (context: Context, tokens: CSSValue[]) => CSSRadialGradientImage;

package/dist/types/css/types/functions/repeating-linear-gradient.d.ts

@@ -0,0 +1,4 @@
+import { CSSValue } from '../../syntax/parser';
+import { CSSLinearGradientImage } from '../image';
+import { Context } from '../../../core/context';
+export declare const repeatingLinearGradient: (context: Context, tokens: CSSValue[]) => CSSLinearGradientImage;

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

@@ -0,0 +1,56 @@
+import { CSSValue } from '../syntax/parser';
+import { Color } from './color';
+import { ITypeDescriptor } from '../type-descriptor';
+import { LengthPercentage } from './length-percentage';
+export declare const enum CSSImageType {
+    URL = 0,
+    LINEAR_GRADIENT = 1,
+    RADIAL_GRADIENT = 2,
+    REPEATING_LINEAR_GRADIENT = 3
+}
+export declare const isLinearGradient: (background: ICSSImage) => background is CSSLinearGradientImage;
+export declare const isRadialGradient: (background: ICSSImage) => background is CSSRadialGradientImage;
+export declare const isRepeatingLinearGradient: (background: ICSSImage) => background is CSSLinearGradientImage;
+export interface UnprocessedGradientColorStop {
+    color: Color;
+    stop: LengthPercentage | null;
+}
+export interface GradientColorStop {
+    color: Color;
+    stop: number;
+}
+export interface ICSSImage {
+    type: CSSImageType;
+}
+export interface CSSURLImage extends ICSSImage {
+    url: string;
+    type: CSSImageType.URL;
+}
+export type GradientCorner = [LengthPercentage, LengthPercentage];
+interface ICSSGradientImage extends ICSSImage {
+    stops: UnprocessedGradientColorStop[];
+}
+export interface CSSLinearGradientImage extends ICSSGradientImage {
+    angle: number | GradientCorner;
+    type: CSSImageType.LINEAR_GRADIENT | CSSImageType.REPEATING_LINEAR_GRADIENT;
+}
+export declare const enum CSSRadialShape {
+    CIRCLE = 0,
+    ELLIPSE = 1
+}
+export declare const enum CSSRadialExtent {
+    CLOSEST_SIDE = 0,
+    FARTHEST_SIDE = 1,
+    CLOSEST_CORNER = 2,
+    FARTHEST_CORNER = 3
+}
+export type CSSRadialSize = CSSRadialExtent | LengthPercentage[];
+export interface CSSRadialGradientImage extends ICSSGradientImage {
+    type: CSSImageType.RADIAL_GRADIENT;
+    shape: CSSRadialShape;
+    size: CSSRadialSize;
+    position: LengthPercentage[];
+}
+export declare const image: ITypeDescriptor<ICSSImage>;
+export declare function isSupportedImage(value: CSSValue): boolean;
+export {};

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

@@ -0,0 +1 @@
+export type CSSTypes = 'angle' | 'color' | 'image' | 'length' | 'length-percentage' | 'time';

package/dist/types/css/types/length-percentage.d.ts

@@ -0,0 +1,62 @@
+import { DimensionToken, NumberValueToken, TokenType } from '../syntax/tokenizer';
+import { CSSValue, CSSFunction } from '../syntax/parser';
+/**
+ * Internal token representing a calc() expression that has both a percentage
+ * component and a pixel offset. Created at parse time and resolved at render
+ * time once the container size is known.
+ *
+ * Extends NumberValueToken so it is structurally assignable wherever
+ * LengthPercentage (DimensionToken | NumberValueToken) is expected,
+ * avoiding widespread type changes.
+ */
+export interface CalcWithPercentage extends NumberValueToken {
+    type: TokenType.NUMBER_TOKEN;
+    /** The percentage coefficient (extracted from the calc expression). */
+    _calcPercentage: number;
+    /** The pixel offset (extracted from the calc expression). */
+    _calcPixelOffset: number;
+}
+export type LengthPercentage = DimensionToken | NumberValueToken;
+export type LengthPercentageTuple = [LengthPercentage] | [LengthPercentage, LengthPercentage];
+export declare const isLengthPercentage: (token: CSSValue) => token is LengthPercentage;
+/**
+ * Check if a token is a CalcWithPercentage deferred token.
+ * Accepts CSSValue (structural duck-type check) for use in type guards.
+ */
+export declare const isCalcWithPercentage: (token: CSSValue) => token is CalcWithPercentage;
+/**
+ * Check if a token is a calc() function
+ */
+export declare const isCalcFunction: (token: CSSValue) => token is CSSFunction;
+/**
+ * Parse a calc() token and produce a LengthPercentage.
+ *
+ * Uses two-point evaluation to extract the percentage coefficient and pixel
+ * offset from a calc() expression so it can be resolved later at render time
+ * when the container size is known.
+ *
+ *   evaluate(0)   → pixelOffset
+ *   evaluate(100) → percentage + pixelOffset   →  percentage = evaluate(100) - pixelOffset
+ *
+ * If the expression has no percentage component, returns a plain NUMBER_TOKEN
+ * for backwards compatibility.
+ */
+export declare const parseCalcForLengthPercentage: (calcToken: CSSFunction) => LengthPercentage | null;
+/**
+ * Convenience helper for parsing an optional calc() or length-percentage value.
+ * Used by property descriptors that accept both calc() and regular length-percentage tokens.
+ * Returns null if the value is neither a calc() function nor a length-percentage token.
+ */
+export declare const parseOptionalCalcOrLength: (value: CSSValue) => LengthPercentage | null;
+/**
+ * Evaluate a calc() expression and convert to LengthPercentage token
+ * Supports basic arithmetic: +, -, *, /
+ * Note: Percentages in calc() are converted based on a context value
+ */
+export declare const evaluateCalcToLengthPercentage: (calcToken: CSSFunction, contextValue?: number) => LengthPercentage | null;
+export declare const parseLengthPercentageTuple: (tokens: LengthPercentage[]) => LengthPercentageTuple;
+export declare const ZERO_LENGTH: NumberValueToken;
+export declare const FIFTY_PERCENT: NumberValueToken;
+export declare const HUNDRED_PERCENT: NumberValueToken;
+export declare const getAbsoluteValueForTuple: (tuple: LengthPercentageTuple, width: number, height: number) => [number, number];
+export declare const getAbsoluteValue: (token: LengthPercentage, parent: number) => number;

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

@@ -0,0 +1,4 @@
+import { CSSValue } from '../syntax/parser';
+import { DimensionToken, NumberValueToken } from '../syntax/tokenizer';
+export type Length = DimensionToken | NumberValueToken;
+export declare const isLength: (token: CSSValue) => token is Length;

package/dist/types/css/types/safe-eval.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Safe arithmetic expression evaluator — replaces `new Function()`.
+ *
+ * Supports only: numbers, +, -, *, /, parentheses.
+ * Does NOT execute arbitrary code. Returns NaN on any illegal token.
+ */
+declare const safeEvalArithmetic: (expr: string) => number;
+export default safeEvalArithmetic;

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

@@ -0,0 +1,2 @@
+import { ITypeDescriptor } from '../type-descriptor';
+export declare const time: ITypeDescriptor<number>;

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

@@ -0,0 +1,57 @@
+import { Bounds } from '../css/layout/bounds';
+import { Context } from '../core/context';
+export interface CloneOptions {
+    ignoreElements?: (element: Element) => boolean;
+    onclone?: (document: Document, element: HTMLElement) => void;
+    allowTaint?: boolean;
+    iframeContainer?: HTMLElement | ShadowRoot;
+}
+export interface WindowOptions {
+    scrollX: number;
+    scrollY: number;
+    windowWidth: number;
+    windowHeight: number;
+}
+export type CloneConfigurations = CloneOptions & {
+    inlineImages: boolean;
+    copyStyles: boolean;
+    cspNonce?: string;
+};
+export declare class DocumentCloner {
+    private readonly context;
+    private readonly options;
+    private readonly scrolledElements;
+    private readonly referenceElement;
+    clonedReferenceElement?: HTMLElement;
+    private readonly documentElement;
+    private readonly counters;
+    private readonly slotCloner;
+    private quoteDepth;
+    constructor(context: Context, element: HTMLElement, options: CloneConfigurations);
+    toIFrame(ownerDocument: Document, windowSize: Bounds): Promise<HTMLIFrameElement>;
+    createElementClone<T extends HTMLElement | SVGElement>(node: T): HTMLElement | SVGElement;
+    createCustomElementClone(node: HTMLElement): HTMLElement;
+    createStyleClone(node: HTMLStyleElement): HTMLStyleElement;
+    createCanvasClone(canvas: HTMLCanvasElement): HTMLImageElement | HTMLCanvasElement;
+    createVideoClone(video: HTMLVideoElement): HTMLCanvasElement;
+    appendChildNode(clone: HTMLElement | SVGElement, child: Node, copyStyles: boolean): void;
+    /**
+     * Clone child nodes from source element to clone element.
+     * Delegates to SlotCloner which handles shadow DOM, slots, and light DOM.
+     */
+    cloneChildNodes(node: Element, clone: HTMLElement | SVGElement, copyStyles: boolean): void;
+    cloneNode(node: Node, copyStyles: boolean): Node;
+    resolvePseudoContent(node: Element, clone: Element, style: CSSStyleDeclaration, pseudoElt: PseudoElementType): HTMLElement | void;
+    static destroy(container: HTMLIFrameElement): boolean;
+}
+declare enum PseudoElementType {
+    BEFORE = 0,
+    AFTER = 1
+}
+export declare const copyCSSStyles: <T extends HTMLElement | SVGElement>(style: CSSStyleDeclaration, target: T) => T;
+/**
+ * Serialise a document type declaration to an HTML string.
+ * @internal – exported for testing only, not part of the public API.
+ */
+export declare const serializeDoctype: (doctype?: DocumentType | null) => string;
+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

@@ -0,0 +1,31 @@
+import { CSSParsedDeclaration } from '../css/index';
+import { TextContainer } from './text-container';
+import { Bounds } from '../css/layout/bounds';
+import { Context } from '../core/context';
+export interface ElementContainerOptions {
+    normalizeDom?: boolean;
+}
+export declare class ElementContainer {
+    protected readonly context: Context;
+    readonly styles: CSSParsedDeclaration;
+    readonly textNodes: TextContainer[];
+    readonly elements: ElementContainer[];
+    bounds: Bounds;
+    createsStackingContext: boolean;
+    createsRealStackingContext: boolean;
+    isListOwner: boolean;
+    debugRender: boolean;
+    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/elements/li-element-container.d.ts

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

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

@@ -0,0 +1,7 @@
+import { ElementContainer } 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);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+/**
+ * DOM Node Type Guards
+ *
+ * All DOM node type guards consolidated here to eliminate duplication
+ * and provide a single source of truth for node type checking.
+ */
+export declare const isElementNode: (node: Node) => node is Element;
+export declare const isTextNode: (node: Node) => node is Text;
+export declare const isSVGElementNode: (element: Element) => element is SVGElement;
+export declare const isHTMLElementNode: (node: Node) => node is HTMLElement;
+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;
+export declare const isBodyElement: (node: Element) => node is HTMLBodyElement;
+export declare const isCanvasElement: (node: Element) => node is HTMLCanvasElement;
+export declare const isVideoElement: (node: Element) => node is HTMLVideoElement;
+export declare const isImageElement: (node: Element) => node is HTMLImageElement;
+export declare const isIFrameElement: (node: Element) => node is HTMLIFrameElement;
+export declare const isStyleElement: (node: Element) => node is HTMLStyleElement;
+export declare const isScriptElement: (node: Element) => node is HTMLScriptElement;
+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 isLIElement: (node: Element) => node is HTMLLIElement;
+export declare const isOLElement: (node: Element) => node is HTMLOListElement;
+export declare const isCustomElement: (element: Element) => element is HTMLElement;
+/**
+ * Check if an element can have ::before / ::after pseudo-elements.
+ * Per the CSS spec, replaced elements and void elements cannot have pseudo-elements.
+ * SVG elements also do not support pseudo-elements.
+ */
+export declare const canHavePseudoElements: (element: Element) => boolean;

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

@@ -0,0 +1,8 @@
+import { ElementContainer } 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);
+}

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

@@ -0,0 +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;
+    private parseTreeFn?;
+    constructor(context: Context, iframe: HTMLIFrameElement, parseTreeFn?: ParseTreeFunction);
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { ElementContainer } 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);
+}

package/dist/types/dom/replaced-elements/index.d.ts

@@ -0,0 +1,4 @@
+import { CanvasElementContainer } from './canvas-element-container';
+import { ImageElementContainer } from './image-element-container';
+import { SVGElementContainer } from './svg-element-container';
+export type ReplacedElementContainer = CanvasElementContainer | ImageElementContainer | SVGElementContainer;

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

@@ -0,0 +1,14 @@
+import { ElementContainer } from '../element-container';
+import { Context } from '../../core/context';
+export declare const CHECKBOX = "checkbox";
+export declare const RADIO = "radio";
+export declare const PASSWORD = "password";
+export declare const INPUT_COLOR = 707406591;
+export declare const PLACEHOLDER_COLOR = 1970632191;
+export declare class InputElementContainer extends ElementContainer {
+    readonly type: string;
+    readonly checked: boolean;
+    readonly value: string;
+    readonly isPlaceholder: boolean;
+    constructor(context: Context, input: HTMLInputElement);
+}

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

@@ -0,0 +1,8 @@
+import { ElementContainer } from '../element-container';
+import { Context } from '../../core/context';
+export declare class SVGElementContainer extends ElementContainer {
+    svg: string;
+    intrinsicWidth: number;
+    intrinsicHeight: number;
+    constructor(context: Context, img: SVGSVGElement);
+}