dompdf.js 1.0.0

package/dist/css/property-descriptors/visibility.d.ts

@@ -0,0 +1,7 @@
+import { IPropertyIdentValueDescriptor } from '../IPropertyDescriptor';
+export declare const enum VISIBILITY {
+    VISIBLE = 0,
+    HIDDEN = 1,
+    COLLAPSE = 2
+}
+export declare const visibility: IPropertyIdentValueDescriptor<VISIBILITY>;

package/dist/css/property-descriptors/webkit-text-stroke-color.d.ts

@@ -0,0 +1,2 @@
+import { IPropertyTypeValueDescriptor } from '../IPropertyDescriptor';
+export declare const webkitTextStrokeColor: IPropertyTypeValueDescriptor;

package/dist/css/property-descriptors/webkit-text-stroke-width.d.ts

@@ -0,0 +1,2 @@
+import { IPropertyValueDescriptor } from '../IPropertyDescriptor';
+export declare const webkitTextStrokeWidth: IPropertyValueDescriptor<number>;

package/dist/css/property-descriptors/word-break.d.ts

@@ -0,0 +1,7 @@
+import { IPropertyIdentValueDescriptor } from '../IPropertyDescriptor';
+export declare enum WORD_BREAK {
+    NORMAL = "normal",
+    BREAK_ALL = "break-all",
+    KEEP_ALL = "keep-all"
+}
+export declare const wordBreak: IPropertyIdentValueDescriptor<WORD_BREAK>;

package/dist/css/property-descriptors/z-index.d.ts

@@ -0,0 +1,7 @@
+import { IPropertyValueDescriptor } from '../IPropertyDescriptor';
+interface zIndex {
+    order: number;
+    auto: boolean;
+}
+export declare const zIndex: IPropertyValueDescriptor<zIndex>;
+export {};

package/dist/css/syntax/__tests__/tokernizer-tests.d.ts

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

package/dist/css/syntax/parser.d.ts

@@ -0,0 +1,34 @@
+import { CSSToken, DimensionToken, NumberValueToken, StringValueToken, TokenType } from './tokenizer';
+export type CSSBlockType = TokenType.LEFT_PARENTHESIS_TOKEN | TokenType.LEFT_SQUARE_BRACKET_TOKEN | TokenType.LEFT_CURLY_BRACKET_TOKEN;
+export interface CSSBlock {
+    type: CSSBlockType;
+    values: CSSValue[];
+}
+export interface CSSFunction {
+    type: TokenType.FUNCTION;
+    name: string;
+    values: CSSValue[];
+}
+export type CSSValue = CSSFunction | CSSToken | CSSBlock;
+export declare class Parser {
+    private _tokens;
+    constructor(tokens: CSSToken[]);
+    static create(value: string): Parser;
+    static parseValue(value: string): CSSValue;
+    static parseValues(value: string): CSSValue[];
+    parseComponentValue(): CSSValue;
+    parseComponentValues(): CSSValue[];
+    private consumeComponentValue;
+    private consumeSimpleBlock;
+    private consumeFunction;
+    private consumeToken;
+    private reconsumeToken;
+}
+export declare const isDimensionToken: (token: CSSValue) => token is DimensionToken;
+export declare const isNumberToken: (token: CSSValue) => token is NumberValueToken;
+export declare const isIdentToken: (token: CSSValue) => token is StringValueToken;
+export declare const isStringToken: (token: CSSValue) => token is StringValueToken;
+export declare const isIdentWithValue: (token: CSSValue, value: string) => boolean;
+export declare const nonWhiteSpace: (token: CSSValue) => boolean;
+export declare const nonFunctionArgSeparator: (token: CSSValue) => boolean;
+export declare const parseFunctionArgs: (tokens: CSSValue[]) => CSSValue[][];

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

@@ -0,0 +1,94 @@
+export declare const enum TokenType {
+    STRING_TOKEN = 0,
+    BAD_STRING_TOKEN = 1,
+    LEFT_PARENTHESIS_TOKEN = 2,
+    RIGHT_PARENTHESIS_TOKEN = 3,
+    COMMA_TOKEN = 4,
+    HASH_TOKEN = 5,
+    DELIM_TOKEN = 6,
+    AT_KEYWORD_TOKEN = 7,
+    PREFIX_MATCH_TOKEN = 8,
+    DASH_MATCH_TOKEN = 9,
+    INCLUDE_MATCH_TOKEN = 10,
+    LEFT_CURLY_BRACKET_TOKEN = 11,
+    RIGHT_CURLY_BRACKET_TOKEN = 12,
+    SUFFIX_MATCH_TOKEN = 13,
+    SUBSTRING_MATCH_TOKEN = 14,
+    DIMENSION_TOKEN = 15,
+    PERCENTAGE_TOKEN = 16,
+    NUMBER_TOKEN = 17,
+    FUNCTION = 18,
+    FUNCTION_TOKEN = 19,
+    IDENT_TOKEN = 20,
+    COLUMN_TOKEN = 21,
+    URL_TOKEN = 22,
+    BAD_URL_TOKEN = 23,
+    CDC_TOKEN = 24,
+    CDO_TOKEN = 25,
+    COLON_TOKEN = 26,
+    SEMICOLON_TOKEN = 27,
+    LEFT_SQUARE_BRACKET_TOKEN = 28,
+    RIGHT_SQUARE_BRACKET_TOKEN = 29,
+    UNICODE_RANGE_TOKEN = 30,
+    WHITESPACE_TOKEN = 31,
+    EOF_TOKEN = 32
+}
+interface IToken {
+    type: TokenType;
+}
+export interface Token extends IToken {
+    type: TokenType.BAD_URL_TOKEN | TokenType.BAD_STRING_TOKEN | TokenType.LEFT_PARENTHESIS_TOKEN | TokenType.RIGHT_PARENTHESIS_TOKEN | TokenType.COMMA_TOKEN | TokenType.SUBSTRING_MATCH_TOKEN | TokenType.PREFIX_MATCH_TOKEN | TokenType.SUFFIX_MATCH_TOKEN | TokenType.COLON_TOKEN | TokenType.SEMICOLON_TOKEN | TokenType.LEFT_SQUARE_BRACKET_TOKEN | TokenType.RIGHT_SQUARE_BRACKET_TOKEN | TokenType.LEFT_CURLY_BRACKET_TOKEN | TokenType.RIGHT_CURLY_BRACKET_TOKEN | TokenType.DASH_MATCH_TOKEN | TokenType.INCLUDE_MATCH_TOKEN | TokenType.COLUMN_TOKEN | TokenType.WHITESPACE_TOKEN | TokenType.CDC_TOKEN | TokenType.CDO_TOKEN | TokenType.EOF_TOKEN;
+}
+export interface StringValueToken extends IToken {
+    type: TokenType.STRING_TOKEN | TokenType.DELIM_TOKEN | TokenType.FUNCTION_TOKEN | TokenType.IDENT_TOKEN | TokenType.URL_TOKEN | TokenType.AT_KEYWORD_TOKEN;
+    value: string;
+}
+export interface HashToken extends IToken {
+    type: TokenType.HASH_TOKEN;
+    flags: number;
+    value: string;
+}
+export interface NumberValueToken extends IToken {
+    type: TokenType.PERCENTAGE_TOKEN | TokenType.NUMBER_TOKEN;
+    flags: number;
+    number: number;
+}
+export interface DimensionToken extends IToken {
+    type: TokenType.DIMENSION_TOKEN;
+    flags: number;
+    unit: string;
+    number: number;
+}
+export interface UnicodeRangeToken extends IToken {
+    type: TokenType.UNICODE_RANGE_TOKEN;
+    start: number;
+    end: number;
+}
+export type CSSToken = Token | StringValueToken | NumberValueToken | DimensionToken | UnicodeRangeToken | HashToken;
+export declare const FLAG_UNRESTRICTED: number;
+export declare const FLAG_ID: number;
+export declare const FLAG_INTEGER: number;
+export declare const FLAG_NUMBER: number;
+export declare const EOF_TOKEN: Token;
+export declare class Tokenizer {
+    private _value;
+    constructor();
+    write(chunk: string): void;
+    read(): CSSToken[];
+    private consumeToken;
+    private consumeCodePoint;
+    private reconsumeCodePoint;
+    private peekCodePoint;
+    private consumeUnicodeRangeToken;
+    private consumeIdentLikeToken;
+    private consumeUrlToken;
+    private consumeWhiteSpace;
+    private consumeBadUrlRemnants;
+    private consumeStringSlice;
+    private consumeStringToken;
+    private consumeNumber;
+    private consumeNumericToken;
+    private consumeEscapedCodePoint;
+    private consumeName;
+}
+export {};

package/dist/css/types/__tests__/color-tests.d.ts

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

package/dist/css/types/__tests__/image-tests.d.ts

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

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

@@ -0,0 +1,7 @@
+import { CSSValue } from '../syntax/parser';
+import { ITypeDescriptor } from '../ITypeDescriptor';
+import { GradientCorner } from './image';
+export declare const angle: ITypeDescriptor<number>;
+export declare const isAngle: (value: CSSValue) => boolean;
+export declare const parseNamedSide: (tokens: CSSValue[]) => number | GradientCorner;
+export declare const deg: (deg: number) => number;

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

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

package/dist/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/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/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/css/types/functions/__tests__/radial-gradient.d.ts

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

package/dist/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/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/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/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/css/types/image.d.ts

@@ -0,0 +1,54 @@
+import { CSSValue } from '../syntax/parser';
+import { Color } from './color';
+import { ITypeDescriptor } from '../ITypeDescriptor';
+import { LengthPercentage } from './length-percentage';
+export declare const enum CSSImageType {
+    URL = 0,
+    LINEAR_GRADIENT = 1,
+    RADIAL_GRADIENT = 2
+}
+export declare const isLinearGradient: (background: ICSSImage) => background is CSSLinearGradientImage;
+export declare const isRadialGradient: (background: ICSSImage) => background is CSSRadialGradientImage;
+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;
+}
+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/css/types/index.d.ts

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

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

@@ -0,0 +1,11 @@
+import { DimensionToken, NumberValueToken } from '../syntax/tokenizer';
+import { CSSValue } from '../syntax/parser';
+export type LengthPercentage = DimensionToken | NumberValueToken;
+export type LengthPercentageTuple = [LengthPercentage] | [LengthPercentage, LengthPercentage];
+export declare const isLengthPercentage: (token: CSSValue) => token is LengthPercentage;
+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/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/css/types/time.d.ts

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

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

@@ -0,0 +1,6 @@
+export declare class DocumentCloner {
+    clonedReferenceElement?: HTMLElement;
+    constructor();
+    toIFrame(): Promise<HTMLIFrameElement>;
+    static destroy(): boolean;
+}

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

@@ -0,0 +1,45 @@
+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;
+}
+export interface WindowOptions {
+    scrollX: number;
+    scrollY: number;
+    windowWidth: number;
+    windowHeight: number;
+}
+export type CloneConfigurations = CloneOptions & {
+    inlineImages: boolean;
+    copyStyles: boolean;
+};
+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 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;
+    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 SVGElement | HTMLElement>(style: CSSStyleDeclaration, target: T) => T;
+export {};

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

@@ -0,0 +1,21 @@
+import { CSSParsedDeclaration } from '../css/index';
+import { TextContainer } from './text-container';
+import { Bounds } from '../css/layout/bounds';
+import { Context } from '../core/context';
+export declare const enum FLAGS {
+    CREATES_STACKING_CONTEXT = 2,
+    CREATES_REAL_STACKING_CONTEXT = 4,
+    IS_LIST_OWNER = 8,
+    DEBUG_RENDER = 16
+}
+export declare class ElementContainer {
+    protected readonly context: Context;
+    readonly styles: CSSParsedDeclaration;
+    readonly textNodes: TextContainer[];
+    readonly elements: ElementContainer[];
+    bounds: Bounds;
+    flags: number;
+    foreignobjectrendering: boolean;
+    parentforeignobjectrendering: boolean;
+    constructor(context: Context, element: Element);
+}

package/dist/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/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/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/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/dom/node-parser.d.ts

@@ -0,0 +1,23 @@
+import { ElementContainer } from './element-container';
+import { Context } from '../core/context';
+export declare const parseTree: (context: Context, element: HTMLElement) => Promise<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;
+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 isCustomElement: (node: Element) => node is HTMLElement;

package/dist/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/dom/replaced-elements/iframe-element-container.d.ts

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

package/dist/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/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/dom/replaced-elements/input-element-container.d.ts

@@ -0,0 +1,12 @@
+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 class InputElementContainer extends ElementContainer {
+    readonly type: string;
+    readonly checked: boolean;
+    readonly value: string;
+    constructor(context: Context, input: HTMLInputElement);
+}

package/dist/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);
+}

package/dist/dom/text-container.d.ts

@@ -0,0 +1,8 @@
+import { CSSParsedDeclaration } from '../css/index';
+import { TextBounds } from '../css/layout/text';
+import { Context } from '../core/context';
+export declare class TextContainer {
+    text: string;
+    textBounds: TextBounds[];
+    constructor(context: Context, node: Text, styles: CSSParsedDeclaration);
+}