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

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

@@ -0,0 +1,33 @@
+/**
+ * Origin Checker
+ *
+ * Provides origin checking functionality without global static state.
+ * Each instance maintains its own anchor element and origin reference.
+ *
+ * Replaces the static methods in CacheStorage with instance-based approach.
+ */
+export declare class OriginChecker {
+    private readonly link;
+    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")
+     */
+    getOrigin(url: string): string;
+    /**
+     * Check if a URL is from the same origin as the context
+     *
+     * @param src - URL to check
+     * @returns true if same origin, false otherwise
+     */
+    isSameOrigin(src: string): boolean;
+    /**
+     * Get the current context origin
+     *
+     * @returns The origin of the context window
+     */
+    getContextOrigin(): string;
+}

package/dist/types/core/performance-monitor.d.ts

@@ -0,0 +1,120 @@
+import { Context } from './context';
+/**
+ * Performance Metric
+ *
+ * Represents a single performance measurement
+ */
+export interface PerformanceMetric {
+    name: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Performance Summary
+ *
+ * Aggregated performance data
+ */
+export interface PerformanceSummary {
+    totalDuration: number;
+    metrics: PerformanceMetric[];
+    breakdown: Array<{
+        name: string;
+        duration: number;
+        percentage: string;
+    }>;
+}
+/**
+ * Performance Monitor
+ *
+ * Tracks performance metrics throughout the rendering pipeline.
+ * Provides insights into where time is spent during rendering.
+ *
+ * Usage:
+ * ```typescript
+ * const monitor = new PerformanceMonitor(context);
+ *
+ * monitor.start('clone');
+ * await cloneDocument();
+ * monitor.end('clone');
+ *
+ * const summary = monitor.getSummary();
+ * ```
+ */
+export declare class PerformanceMonitor {
+    private readonly context;
+    private readonly activeMetrics;
+    private readonly completedMetrics;
+    private readonly enabled;
+    private readonly getTime;
+    constructor(context: Context | null, enabled?: boolean);
+    /**
+     * Start measuring a performance metric
+     *
+     * @param name - Unique name for this metric
+     * @param metadata - Optional metadata to attach
+     */
+    start(name: string, metadata?: Record<string, unknown>): void;
+    /**
+     * End measuring a performance metric
+     *
+     * @param name - Name of the metric to end
+     * @returns The completed metric, or undefined if not found
+     */
+    end(name: string): PerformanceMetric | undefined;
+    /**
+     * Measure a synchronous function
+     *
+     * @param name - Name for this measurement
+     * @param fn - Function to measure
+     * @param metadata - Optional metadata
+     * @returns The function's return value
+     */
+    measure<T>(name: string, fn: () => T, metadata?: Record<string, unknown>): T;
+    /**
+     * Measure an asynchronous function
+     *
+     * @param name - Name for this measurement
+     * @param fn - Async function to measure
+     * @param metadata - Optional metadata
+     * @returns Promise resolving to the function's return value
+     */
+    measureAsync<T>(name: string, fn: () => Promise<T>, metadata?: Record<string, unknown>): Promise<T>;
+    /**
+     * Get all completed metrics
+     *
+     * @returns Array of completed performance metrics
+     */
+    getMetrics(): PerformanceMetric[];
+    /**
+     * Get a specific metric by name
+     *
+     * @param name - Metric name
+     * @returns The metric, or undefined if not found
+     */
+    getMetric(name: string): PerformanceMetric | undefined;
+    /**
+     * Get performance summary
+     *
+     * @returns Aggregated performance data
+     */
+    getSummary(): PerformanceSummary;
+    /**
+     * Log performance summary to console
+     */
+    logSummary(): void;
+    /**
+     * Clear all metrics
+     */
+    clear(): void;
+    /**
+     * Check if monitoring is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get active (uncompleted) metrics
+     * Useful for debugging leaked measurements
+     */
+    getActiveMetrics(): string[];
+}

package/dist/types/core/render-element.d.ts

@@ -0,0 +1,3 @@
+import { Html2CanvasConfig } from '../config';
+import type { Options } from '../options';
+export declare const renderElement: (element: HTMLElement, opts: Partial<Options>, config: Html2CanvasConfig) => Promise<HTMLCanvasElement>;

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

@@ -0,0 +1 @@
+export declare const SMALL_IMAGE = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";

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

@@ -0,0 +1,130 @@
+/**
+ * Input Validator
+ *
+ * Provides validation and sanitization for user inputs to prevent security vulnerabilities
+ * including SSRF, XSS, and injection attacks.
+ */
+/**
+ * Validation result
+ */
+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
+ */
+export interface ValidatorConfig {
+    /**
+     * Allowed proxy domains for SSRF prevention
+     * If empty, no domain restrictions
+     */
+    allowedProxyDomains?: string[];
+    /**
+     * Allow localhost/127.0.0.1 as proxy URL. Only set for development or test (e.g. Karma reftests).
+     * @default false
+     */
+    allowLocalhostProxy?: boolean;
+    /**
+     * Maximum allowed image timeout in milliseconds
+     */
+    maxImageTimeout?: number;
+    /**
+     * Whether to allow data URLs
+     */
+    allowDataUrls?: boolean;
+    /**
+     * Custom validation function
+     */
+    /** Custom validation function. Receives the raw value and its semantic type. */
+    customValidator?: (value: unknown, type: string) => ValidationResult;
+}
+/**
+ * Input Validator
+ *
+ * Validates and sanitizes user inputs for security and correctness.
+ */
+export declare class Validator {
+    private readonly config;
+    constructor(config?: ValidatorConfig);
+    /**
+     * Validate a URL
+     *
+     * @param url - URL to validate
+     * @param context - Context for validation (e.g., 'proxy', 'image')
+     * @returns Validation result
+     */
+    validateUrl(url: string, context?: 'proxy' | 'image' | 'general'): ValidationResult;
+    /**
+     * Check if a hostname is a private IP address
+     */
+    private isPrivateIP;
+    /**
+     * Check if an IPv6 address is private or special
+     * Handles compressed IPv6 addresses (e.g., ::1, fc00::1)
+     */
+    private isPrivateIPv6;
+    /**
+     * Expand compressed IPv6 address to full form
+     * e.g., "::1" -> "0000:0000:0000:0000:0000:0000:0000:0001"
+     */
+    private expandIPv6;
+    /**
+     * Fallback prefix matching for IPv6 when expansion fails
+     */
+    private isPrivateIPv6Prefix;
+    /**
+     * Validate CSP nonce
+     *
+     * @param nonce - CSP nonce to validate
+     * @returns Validation result
+     */
+    validateCspNonce(nonce: string): ValidationResult;
+    /**
+     * Validate image timeout
+     *
+     * @param timeout - Timeout in milliseconds
+     * @returns Validation result
+     */
+    validateImageTimeout(timeout: number): ValidationResult;
+    /**
+     * Validate window dimensions
+     *
+     * @param width - Window width
+     * @param height - Window height
+     * @returns Validation result
+     */
+    validateDimensions(width: number, height: number): ValidationResult;
+    /**
+     * Validate scale factor
+     *
+     * @param scale - Scale factor
+     * @returns Validation result
+     */
+    validateScale(scale: number): ValidationResult;
+    /**
+     * Validate HTML element
+     *
+     * @param element - Element to validate
+     * @returns Validation result
+     */
+    validateElement(element: unknown): ValidationResult;
+    /**
+     * Validate entire options object
+     *
+     * @param options - Options to validate
+     * @returns Validation result with all errors
+     */
+    validateOptions(options: Record<string, unknown>): ValidationResult;
+}
+/**
+ * Create a default validator instance
+ */
+export declare function createDefaultValidator(config?: ValidatorConfig): Validator;
+/**
+ * Create a strict validator with security-focused settings
+ */
+export declare function createStrictValidator(allowedProxyDomains: string[]): Validator;

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

@@ -0,0 +1,16 @@
+import type { CSSParsedDeclaration } from '../index';
+/**
+ * Read-only grouped accessor for background-related CSS properties.
+ */
+export declare class BackgroundStyles {
+    private readonly styles;
+    constructor(styles: CSSParsedDeclaration);
+    get color(): number;
+    get image(): import("../types/image").ICSSImage[];
+    get clip(): import("../property-descriptors/background-clip").BackgroundClip;
+    get origin(): import("../property-descriptors/background-origin").BackgroundOrigin;
+    get position(): import("../property-descriptors/background-position").BackgroundPosition;
+    get repeat(): import("../property-descriptors/background-repeat").BackgroundRepeat;
+    get size(): import("../property-descriptors/background-size").BackgroundSize;
+    get blendMode(): import("../property-descriptors/background-blend-mode").BackgroundBlendMode;
+}

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

@@ -0,0 +1,31 @@
+import type { CSSParsedDeclaration } from '../index';
+/**
+ * Read-only grouped accessor for border-related CSS properties.
+ *
+ * Provides structured access: `styles.border.topColor` as an alternative
+ * to the flat `styles.borderTopColor`. Both forms remain valid.
+ */
+export declare class BorderStyles {
+    private readonly styles;
+    constructor(styles: CSSParsedDeclaration);
+    get topColor(): number;
+    get rightColor(): number;
+    get bottomColor(): number;
+    get leftColor(): number;
+    get topStyle(): import("../property-descriptors/border-style").BORDER_STYLE;
+    get rightStyle(): import("../property-descriptors/border-style").BORDER_STYLE;
+    get bottomStyle(): import("../property-descriptors/border-style").BORDER_STYLE;
+    get leftStyle(): import("../property-descriptors/border-style").BORDER_STYLE;
+    get topWidth(): number;
+    get rightWidth(): number;
+    get bottomWidth(): number;
+    get leftWidth(): number;
+    get topLeftRadius(): import("../types/length-percentage").LengthPercentageTuple;
+    get topRightRadius(): import("../types/length-percentage").LengthPercentageTuple;
+    get bottomRightRadius(): import("../types/length-percentage").LengthPercentageTuple;
+    get bottomLeftRadius(): import("../types/length-percentage").LengthPercentageTuple;
+    get imageSource(): import("../property-descriptors/border-image-source").BorderImageSource;
+    get imageSlice(): import("../property-descriptors/border-image-slice").BorderImageSlice;
+    get imageRepeat(): import("../property-descriptors/border-image-repeat").BorderImageRepeat;
+    get boxShadow(): import("../property-descriptors/box-shadow").BoxShadow;
+}

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

@@ -0,0 +1,35 @@
+import type { CSSParsedDeclaration } from '../index';
+/**
+ * Read-only grouped accessor for font/text-related CSS properties.
+ */
+export declare class FontStyles {
+    private readonly styles;
+    constructor(styles: CSSParsedDeclaration);
+    get family(): import("../property-descriptors/font-family").FontFamily;
+    get size(): import("../types/length-percentage").LengthPercentage;
+    get style(): import("../property-descriptors/font-style").FONT_STYLE;
+    get variant(): string[];
+    get weight(): number;
+    get ligatures(): import("../property-descriptors/font-variant-ligatures").FONT_VARIANT_LIGATURES;
+    get color(): number;
+    get letterSpacing(): number;
+    get lineHeight(): import("../syntax/parser").CSSValue;
+    get textAlign(): import("../property-descriptors/text-align").TEXT_ALIGN;
+    get textTransform(): import("../property-descriptors/text-transform").TEXT_TRANSFORM;
+    get textOverflow(): import("../property-descriptors/text-overflow").TEXT_OVERFLOW;
+    get textShadow(): import("../property-descriptors/text-shadow").TextShadow;
+    get textDecorationColor(): number;
+    get textDecorationLine(): import("../property-descriptors/text-decoration-line").TextDecorationLine;
+    get textDecorationStyle(): import("../property-descriptors/text-decoration-style").TEXT_DECORATION_STYLE;
+    get textDecorationThickness(): import("../property-descriptors/text-decoration-thickness").TextDecorationThickness;
+    get textUnderlineOffset(): import("../property-descriptors/text-underline-offset").TextUnderlineOffset;
+    get wordBreak(): import("../property-descriptors/word-break").WORD_BREAK;
+    get lineBreak(): import("../property-descriptors/line-break").LINE_BREAK;
+    get overflowWrap(): import("../property-descriptors/overflow-wrap").OVERFLOW_WRAP;
+    get writingMode(): import("../property-descriptors/writing-mode").WRITING_MODE;
+    get direction(): import("../property-descriptors/direction").DIRECTION;
+    get webkitTextStrokeColor(): number;
+    get webkitTextStrokeWidth(): number;
+    get webkitLineClamp(): number;
+    get paintOrder(): import("../property-descriptors/paint-order").PaintOrder;
+}

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

@@ -0,0 +1,46 @@
+import type { CSSParsedDeclaration } from '../index';
+/**
+ * Read-only grouped accessor for layout/display/positioning CSS properties.
+ */
+export declare class LayoutStyles {
+    private readonly styles;
+    constructor(styles: CSSParsedDeclaration);
+    get display(): number;
+    get position(): import("../property-descriptors/position").POSITION;
+    get float(): import("../property-descriptors/float").FLOAT;
+    get zIndex(): CSSParsedDeclaration['zIndex'];
+    get marginTop(): import("../syntax/parser").CSSValue;
+    get marginRight(): import("../syntax/parser").CSSValue;
+    get marginBottom(): import("../syntax/parser").CSSValue;
+    get marginLeft(): import("../syntax/parser").CSSValue;
+    get paddingTop(): import("../types/length-percentage").LengthPercentage;
+    get paddingRight(): import("../types/length-percentage").LengthPercentage;
+    get paddingBottom(): import("../types/length-percentage").LengthPercentage;
+    get paddingLeft(): import("../types/length-percentage").LengthPercentage;
+    get overflowX(): import("../property-descriptors/overflow").OVERFLOW;
+    get overflowY(): import("../property-descriptors/overflow").OVERFLOW;
+    get opacity(): number;
+    get visibility(): import("../property-descriptors/visibility").VISIBILITY;
+    get transform(): import("../property-descriptors/transform").Transform;
+    get transformOrigin(): import("../property-descriptors/transform-origin").TransformOrigin;
+    get rotate(): import("../property-descriptors/rotate").Rotate;
+    get zoom(): number;
+    get clipPath(): import("../property-descriptors/clip-path").ClipPathValue;
+    get mixBlendMode(): import("../property-descriptors/mix-blend-mode").MixBlendMode;
+    get filter(): import("../property-descriptors/filter").FilterValue;
+    get imageRendering(): import("../property-descriptors/image-rendering").IMAGE_RENDERING;
+    get objectFit(): number;
+    get objectPosition(): import("../property-descriptors/object-position").ObjectPosition;
+    get boxDecorationBreak(): import("../property-descriptors/box-decoration-break").BOX_DECORATION_BREAK;
+    get listStyleImage(): import("../types/image").ICSSImage | null;
+    get listStylePosition(): import("../property-descriptors/list-style-position").LIST_STYLE_POSITION;
+    get listStyleType(): import("../property-descriptors/list-style-type").LIST_STYLE_TYPE;
+    get animationDuration(): number[];
+    isVisible(): boolean;
+    isTransparent(): boolean;
+    isTransformed(): boolean;
+    isPositioned(): boolean;
+    isPositionedWithZIndex(): boolean;
+    isFloating(): boolean;
+    isInlineLevel(): boolean;
+}

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

@@ -0,0 +1,185 @@
+import { backgroundClip } from './property-descriptors/background-clip';
+import { backgroundImage } from './property-descriptors/background-image';
+import { backgroundOrigin } from './property-descriptors/background-origin';
+import { backgroundPosition } from './property-descriptors/background-position';
+import { backgroundRepeat } from './property-descriptors/background-repeat';
+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';
+import { letterSpacing } from './property-descriptors/letter-spacing';
+import { lineBreak } from './property-descriptors/line-break';
+import { listStyleImage } from './property-descriptors/list-style-image';
+import { listStylePosition } from './property-descriptors/list-style-position';
+import { listStyleType } from './property-descriptors/list-style-type';
+import { OVERFLOW } from './property-descriptors/overflow';
+import { overflowWrap } from './property-descriptors/overflow-wrap';
+import { textAlign } from './property-descriptors/text-align';
+import { position } from './property-descriptors/position';
+import { textShadow } from './property-descriptors/text-shadow';
+import { textTransform } from './property-descriptors/text-transform';
+import { transform } from './property-descriptors/transform';
+import { transformOrigin } from './property-descriptors/transform-origin';
+import { rotate } from './property-descriptors/rotate';
+import { visibility } from './property-descriptors/visibility';
+import { wordBreak } from './property-descriptors/word-break';
+import { writingMode } from './property-descriptors/writing-mode';
+import { zIndex } from './property-descriptors/z-index';
+import { CSSValue } from './syntax/parser';
+import { Color } from './types/color';
+import { opacity } from './property-descriptors/opacity';
+import { textDecorationLine } from './property-descriptors/text-decoration-line';
+import { textDecorationStyle } from './property-descriptors/text-decoration-style';
+import { textDecorationThickness } from './property-descriptors/text-decoration-thickness';
+import { textUnderlineOffset } from './property-descriptors/text-underline-offset';
+import { LengthPercentage } from './types/length-percentage';
+import { fontFamily } from './property-descriptors/font-family';
+import { fontWeight } from './property-descriptors/font-weight';
+import { fontVariant } from './property-descriptors/font-variant';
+import { fontStyle } from './property-descriptors/font-style';
+import { content } from './property-descriptors/content';
+import { counterIncrement } from './property-descriptors/counter-increment';
+import { counterReset } from './property-descriptors/counter-reset';
+import { duration } from './property-descriptors/duration';
+import { quotes } from './property-descriptors/quotes';
+import { boxShadow } from './property-descriptors/box-shadow';
+import { paintOrder } from './property-descriptors/paint-order';
+import { webkitTextStrokeWidth } from './property-descriptors/webkit-text-stroke-width';
+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';
+import { MixBlendMode } from './property-descriptors/mix-blend-mode';
+import { filter } from './property-descriptors/filter';
+import { fontVariantLigatures } from './property-descriptors/font-variant-ligatures';
+import { zoom } from './property-descriptors/zoom';
+import { objectPosition } from './property-descriptors/object-position';
+import { backgroundBlendMode } from './property-descriptors/background-blend-mode';
+import { borderImageSource } from './property-descriptors/border-image-source';
+import { borderImageSlice } from './property-descriptors/border-image-slice';
+import { borderImageRepeat } from './property-descriptors/border-image-repeat';
+import { boxDecorationBreak } from './property-descriptors/box-decoration-break';
+import { BorderStyles } from './grouped/border-styles';
+import { BackgroundStyles } from './grouped/background-styles';
+import { FontStyles } from './grouped/font-styles';
+import { LayoutStyles } from './grouped/layout-styles';
+export declare class CSSParsedDeclaration {
+    animationDuration: ReturnType<typeof duration.parse>;
+    backgroundClip: ReturnType<typeof backgroundClip.parse>;
+    backgroundColor: Color;
+    backgroundImage: ReturnType<typeof backgroundImage.parse>;
+    backgroundOrigin: ReturnType<typeof backgroundOrigin.parse>;
+    backgroundPosition: ReturnType<typeof backgroundPosition.parse>;
+    backgroundRepeat: ReturnType<typeof backgroundRepeat.parse>;
+    backgroundSize: ReturnType<typeof backgroundSize.parse>;
+    borderTopColor: Color;
+    borderRightColor: Color;
+    borderBottomColor: Color;
+    borderLeftColor: Color;
+    borderTopLeftRadius: ReturnType<typeof borderTopLeftRadius.parse>;
+    borderTopRightRadius: ReturnType<typeof borderTopRightRadius.parse>;
+    borderBottomRightRadius: ReturnType<typeof borderBottomRightRadius.parse>;
+    borderBottomLeftRadius: ReturnType<typeof borderBottomLeftRadius.parse>;
+    borderTopStyle: ReturnType<typeof borderTopStyle.parse>;
+    borderRightStyle: ReturnType<typeof borderRightStyle.parse>;
+    borderBottomStyle: ReturnType<typeof borderBottomStyle.parse>;
+    borderLeftStyle: ReturnType<typeof borderLeftStyle.parse>;
+    borderTopWidth: ReturnType<typeof borderTopWidth.parse>;
+    borderRightWidth: ReturnType<typeof borderRightWidth.parse>;
+    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>;
+    float: ReturnType<typeof float.parse>;
+    fontFamily: ReturnType<typeof fontFamily.parse>;
+    fontSize: LengthPercentage;
+    fontStyle: ReturnType<typeof fontStyle.parse>;
+    fontVariant: ReturnType<typeof fontVariant.parse>;
+    fontWeight: ReturnType<typeof fontWeight.parse>;
+    letterSpacing: ReturnType<typeof letterSpacing.parse>;
+    lineBreak: ReturnType<typeof lineBreak.parse>;
+    lineHeight: CSSValue;
+    listStyleImage: ReturnType<typeof listStyleImage.parse>;
+    listStylePosition: ReturnType<typeof listStylePosition.parse>;
+    listStyleType: ReturnType<typeof listStyleType.parse>;
+    marginTop: CSSValue;
+    marginRight: CSSValue;
+    marginBottom: CSSValue;
+    marginLeft: CSSValue;
+    opacity: ReturnType<typeof opacity.parse>;
+    overflowX: OVERFLOW;
+    overflowY: OVERFLOW;
+    overflowWrap: ReturnType<typeof overflowWrap.parse>;
+    paddingTop: LengthPercentage;
+    paddingRight: LengthPercentage;
+    paddingBottom: LengthPercentage;
+    paddingLeft: LengthPercentage;
+    paintOrder: ReturnType<typeof paintOrder.parse>;
+    position: ReturnType<typeof position.parse>;
+    textAlign: ReturnType<typeof textAlign.parse>;
+    textDecorationColor: Color;
+    textDecorationLine: ReturnType<typeof textDecorationLine.parse>;
+    textDecorationStyle: ReturnType<typeof textDecorationStyle.parse>;
+    textDecorationThickness: ReturnType<typeof textDecorationThickness.parse>;
+    textUnderlineOffset: ReturnType<typeof textUnderlineOffset.parse>;
+    textShadow: ReturnType<typeof textShadow.parse>;
+    textTransform: ReturnType<typeof textTransform.parse>;
+    textOverflow: ReturnType<typeof textOverflow.parse>;
+    transform: ReturnType<typeof transform.parse>;
+    transformOrigin: ReturnType<typeof transformOrigin.parse>;
+    rotate: ReturnType<typeof rotate.parse>;
+    visibility: ReturnType<typeof visibility.parse>;
+    webkitTextStrokeColor: Color;
+    webkitTextStrokeWidth: ReturnType<typeof webkitTextStrokeWidth.parse>;
+    webkitLineClamp: ReturnType<typeof webkitLineClamp.parse>;
+    wordBreak: ReturnType<typeof wordBreak.parse>;
+    writingMode: ReturnType<typeof writingMode.parse>;
+    zIndex: ReturnType<typeof zIndex.parse>;
+    objectFit: ReturnType<typeof objectFit.parse>;
+    imageRendering: ReturnType<typeof imageRendering.parse>;
+    mixBlendMode: MixBlendMode;
+    filter: ReturnType<typeof filter.parse>;
+    fontVariantLigatures: ReturnType<typeof fontVariantLigatures.parse>;
+    zoom: ReturnType<typeof zoom.parse>;
+    objectPosition: ReturnType<typeof objectPosition.parse>;
+    backgroundBlendMode: ReturnType<typeof backgroundBlendMode.parse>;
+    borderImageSource: ReturnType<typeof borderImageSource.parse>;
+    borderImageSlice: ReturnType<typeof borderImageSlice.parse>;
+    borderImageRepeat: ReturnType<typeof borderImageRepeat.parse>;
+    boxDecorationBreak: ReturnType<typeof boxDecorationBreak.parse>;
+    private _border?;
+    private _background?;
+    private _font?;
+    private _layout?;
+    get border(): BorderStyles;
+    get background(): BackgroundStyles;
+    get font(): FontStyles;
+    get layout(): LayoutStyles;
+    private static readonly standardProps;
+    constructor(context: Context, declaration: CSSStyleDeclaration);
+    isVisible(): boolean;
+    isTransparent(): boolean;
+    isTransformed(): boolean;
+    isPositioned(): boolean;
+    isPositionedWithZIndex(): boolean;
+    isFloating(): boolean;
+    isInlineLevel(): boolean;
+}
+export declare class CSSParsedPseudoDeclaration {
+    content: ReturnType<typeof content.parse>;
+    quotes: ReturnType<typeof quotes.parse>;
+    constructor(context: Context, declaration: CSSStyleDeclaration);
+}
+export declare class CSSParsedCounterDeclaration {
+    counterIncrement: ReturnType<typeof counterIncrement.parse>;
+    counterReset: ReturnType<typeof counterReset.parse>;
+    constructor(context: Context, declaration: CSSStyleDeclaration);
+}

package/dist/types/css/layout/bounds.d.ts

@@ -0,0 +1,14 @@
+import { Context } from '../../core/context';
+export declare class Bounds {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    constructor(left: number, top: number, width: number, height: number);
+    add(x: number, y: number, w: number, h: number): Bounds;
+    static fromClientRect(context: Context, clientRect: ClientRect): Bounds;
+    static fromDOMRectList(context: Context, domRectList: DOMRectList): Bounds;
+    static EMPTY: Bounds;
+}
+export declare const parseBounds: (context: Context, node: Element) => Bounds;
+export declare const parseDocumentSize: (document: Document) => Bounds;

package/dist/types/css/layout/text.d.ts

@@ -0,0 +1,10 @@
+import { CSSParsedDeclaration } from '../index';
+import { Bounds } from './bounds';
+import { Context } from '../../core/context';
+export declare class TextBounds {
+    readonly text: string;
+    readonly bounds: Bounds;
+    constructor(text: string, bounds: Bounds);
+}
+export declare const parseTextBounds: (context: Context, value: string, styles: CSSParsedDeclaration, node: Text) => TextBounds[];
+export declare const segmentGraphemes: (value: string) => string[];