canvg

  • Version 3.0.7
  • Published
  • 1.49 MB
  • 6 dependencies
  • MIT license

Install

npm i canvg
yarn add canvg
pnpm add canvg

Overview

JavaScript SVG parser and renderer on Canvas.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable PSEUDO_ZERO

const PSEUDO_ZERO: number;

    Functions

    function CB1

    CB1: (t: number) => number;

      function CB2

      CB2: (t: number) => number;

        function CB3

        CB3: (t: number) => number;

          function CB4

          CB4: (t: number) => number;

            function compressSpaces

            compressSpaces: (str: string) => string;
            • HTML-safe compress white-spaces.

              Parameter str

              String to compress.

            function getSelectorSpecificity

            getSelectorSpecificity: (selector: string) => string;
            • Measure selector specificity.

              Parameter selector

              Selector to measure.

            function normalizeAttributeName

            normalizeAttributeName: (name: string) => string;
            • Normalize attribute name.

              Parameter name

              Attribute name.

            function normalizeColor

            normalizeColor: (color: string) => string;
            • Transform floats to integers in rgb colors.

              Parameter color

              Color to normalize.

            function parseExternalUrl

            parseExternalUrl: (url: string) => string;
            • Parse external URL.

              Parameter url

              CSS url string.

            function QB1

            QB1: (t: number) => number;

              function QB2

              QB2: (t: number) => number;

                function QB3

                QB3: (t: number) => number;

                  function toNumbers

                  toNumbers: (str: string) => number[];
                  • String to numbers array.

                    Parameter str

                    Numbers string.

                  function trimLeft

                  trimLeft: (str: string) => string;
                  • HTML-safe left trim.

                    Parameter str

                    String to trim.

                  function trimRight

                  trimRight: (str: string) => string;
                  • HTML-safe right trim.

                    Parameter str

                    String to trim.

                  function vectorMagnitude

                  vectorMagnitude: (v: number[]) => number;
                  • Vector magnitude.

                  function vectorsAngle

                  vectorsAngle: (u: number[], v: number[]) => number;
                  • Angle between two vectors.

                  function vectorsRatio

                  vectorsRatio: (u: number[], v: number[]) => number;
                  • Ratio between two vectors.

                  Classes

                  class AElement

                  class AElement extends TextElement {}

                    constructor

                    constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                      property hasText

                      protected readonly hasText: boolean;

                        property text

                        protected readonly text: string;

                          property type

                          type: string;

                            method getText

                            getText: () => string;

                              method onClick

                              onClick: () => void;

                                method onMouseMove

                                onMouseMove: () => void;

                                  method renderChildren

                                  renderChildren: (ctx: RenderingContext2D) => void;

                                    class AnimateColorElement

                                    class AnimateColorElement extends AnimateElement {}

                                      property type

                                      type: string;

                                        method calcValue

                                        calcValue: () => string;

                                          class AnimateElement

                                          class AnimateElement extends Element {}

                                            constructor

                                            constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                              property begin

                                              protected readonly begin: number;

                                                property duration

                                                protected duration: number;

                                                  property from

                                                  protected readonly from: Property<any>;

                                                    property frozen

                                                    protected frozen: boolean;

                                                      property initialUnits

                                                      protected initialUnits: string;

                                                        property initialValue

                                                        protected initialValue: string;

                                                          property maxDuration

                                                          protected readonly maxDuration: number;

                                                            property removed

                                                            protected removed: boolean;

                                                              property to

                                                              protected readonly to: Property<any>;

                                                                property type

                                                                type: string;

                                                                  property values

                                                                  protected readonly values: Property<any>;

                                                                    method calcValue

                                                                    calcValue: () => string;

                                                                      method getProgress

                                                                      getProgress: () => IProgress;

                                                                        method getProperty

                                                                        protected getProperty: () => Property<any>;

                                                                          method update

                                                                          update: (delta: number) => boolean;

                                                                            class AnimateTransformElement

                                                                            class AnimateTransformElement extends AnimateElement {}

                                                                              property type

                                                                              type: string;

                                                                                method calcValue

                                                                                calcValue: () => string;

                                                                                  class BoundingBox

                                                                                  class BoundingBox {}

                                                                                    constructor

                                                                                    constructor(x1?: number, y1?: number, x2?: number, y2?: number);

                                                                                      property height

                                                                                      readonly height: number;

                                                                                        property width

                                                                                        readonly width: number;

                                                                                          property x

                                                                                          readonly x: number;

                                                                                            property x1

                                                                                            x1: number;

                                                                                              property x2

                                                                                              x2: number;

                                                                                                property y

                                                                                                readonly y: number;

                                                                                                  property y1

                                                                                                  y1: number;

                                                                                                    property y2

                                                                                                    y2: number;

                                                                                                      method addBezierCurve

                                                                                                      addBezierCurve: (
                                                                                                      p0x: number,
                                                                                                      p0y: number,
                                                                                                      p1x: number,
                                                                                                      p1y: number,
                                                                                                      p2x: number,
                                                                                                      p2y: number,
                                                                                                      p3x: number,
                                                                                                      p3y: number
                                                                                                      ) => void;

                                                                                                        method addBoundingBox

                                                                                                        addBoundingBox: (boundingBox: BoundingBox) => void;

                                                                                                          method addPoint

                                                                                                          addPoint: (x: number, y: number) => void;

                                                                                                            method addQuadraticCurve

                                                                                                            addQuadraticCurve: (
                                                                                                            p0x: number,
                                                                                                            p0y: number,
                                                                                                            p1x: number,
                                                                                                            p1y: number,
                                                                                                            p2x: number,
                                                                                                            p2y: number
                                                                                                            ) => void;

                                                                                                              method addX

                                                                                                              addX: (x: number) => void;

                                                                                                                method addY

                                                                                                                addY: (y: number) => void;

                                                                                                                  method isPointInBox

                                                                                                                  isPointInBox: (x: number, y: number) => boolean;

                                                                                                                    class Canvg

                                                                                                                    class Canvg {}
                                                                                                                    • SVG renderer on canvas.

                                                                                                                    constructor

                                                                                                                    constructor(
                                                                                                                    ctx: RenderingContext2D,
                                                                                                                    svg: globalThis.Document,
                                                                                                                    options?: IOptions
                                                                                                                    );
                                                                                                                    • Main constructor.

                                                                                                                      Parameter ctx

                                                                                                                      Rendering context.

                                                                                                                      Parameter svg

                                                                                                                      SVG Document.

                                                                                                                      Parameter options

                                                                                                                      Rendering options.

                                                                                                                    property document

                                                                                                                    readonly document: Document;
                                                                                                                    • Canvg Document.

                                                                                                                    property parser

                                                                                                                    readonly parser: Parser;
                                                                                                                    • XML/HTML parser instance.

                                                                                                                    property screen

                                                                                                                    readonly screen: Screen;
                                                                                                                    • Screen instance.

                                                                                                                    method fork

                                                                                                                    fork: (
                                                                                                                    ctx: RenderingContext2D,
                                                                                                                    svg: string,
                                                                                                                    options?: IOptions
                                                                                                                    ) => Promise<Canvg>;
                                                                                                                    • Create new Canvg instance with inherited options.

                                                                                                                      Parameter ctx

                                                                                                                      Rendering context.

                                                                                                                      Parameter svg

                                                                                                                      SVG source string or URL.

                                                                                                                      Parameter options

                                                                                                                      Rendering options.

                                                                                                                    method forkString

                                                                                                                    forkString: (ctx: RenderingContext2D, svg: string, options?: IOptions) => Canvg;
                                                                                                                    • Create new Canvg instance with inherited options.

                                                                                                                      Parameter ctx

                                                                                                                      Rendering context.

                                                                                                                      Parameter svg

                                                                                                                      SVG source string.

                                                                                                                      Parameter options

                                                                                                                      Rendering options.

                                                                                                                    method from

                                                                                                                    static from: (
                                                                                                                    ctx: RenderingContext2D,
                                                                                                                    svg: string,
                                                                                                                    options?: IOptions
                                                                                                                    ) => Promise<Canvg>;
                                                                                                                    • Create Canvg instance from SVG source string or URL.

                                                                                                                      Parameter ctx

                                                                                                                      Rendering context.

                                                                                                                      Parameter svg

                                                                                                                      SVG source string or URL.

                                                                                                                      Parameter options

                                                                                                                      Rendering options.

                                                                                                                    method fromString

                                                                                                                    static fromString: (
                                                                                                                    ctx: RenderingContext2D,
                                                                                                                    svg: string,
                                                                                                                    options?: IOptions
                                                                                                                    ) => Canvg;
                                                                                                                    • Create Canvg instance from SVG source string.

                                                                                                                      Parameter ctx

                                                                                                                      Rendering context.

                                                                                                                      Parameter svg

                                                                                                                      SVG source string.

                                                                                                                      Parameter options

                                                                                                                      Rendering options.

                                                                                                                    method isReady

                                                                                                                    isReady: () => boolean;
                                                                                                                    • Document is ready value.

                                                                                                                    method ready

                                                                                                                    ready: () => Promise<void>;
                                                                                                                    • Document is ready promise.

                                                                                                                    method render

                                                                                                                    render: (options?: IScreenStartOptions) => Promise<void>;
                                                                                                                    • Render only first frame, ignoring animations and mouse.

                                                                                                                      Parameter options

                                                                                                                      Rendering options.

                                                                                                                    method resize

                                                                                                                    resize: (
                                                                                                                    width: number,
                                                                                                                    height?: number,
                                                                                                                    preserveAspectRatio?: boolean | string
                                                                                                                    ) => void;
                                                                                                                    • Resize SVG to fit in given size.

                                                                                                                      Parameter width

                                                                                                                      Parameter height

                                                                                                                      Parameter preserveAspectRatio

                                                                                                                    method start

                                                                                                                    start: (options?: IScreenStartOptions) => void;
                                                                                                                    • Start rendering.

                                                                                                                      Parameter options

                                                                                                                      Render options.

                                                                                                                    method stop

                                                                                                                    stop: () => void;
                                                                                                                    • Stop rendering.

                                                                                                                    class CircleElement

                                                                                                                    class CircleElement extends PathElement {}

                                                                                                                      property type

                                                                                                                      type: string;

                                                                                                                        method getMarkers

                                                                                                                        getMarkers: () => any;

                                                                                                                          method path

                                                                                                                          path: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                            class ClipPathElement

                                                                                                                            class ClipPathElement extends Element {}

                                                                                                                              property type

                                                                                                                              type: string;

                                                                                                                                method apply

                                                                                                                                apply: (ctx: RenderingContext2D) => void;

                                                                                                                                  method render

                                                                                                                                  render: (_: RenderingContext2D) => void;

                                                                                                                                    class DefsElement

                                                                                                                                    class DefsElement extends Element {}

                                                                                                                                      property type

                                                                                                                                      type: string;

                                                                                                                                        method render

                                                                                                                                        render: () => void;

                                                                                                                                          class DescElement

                                                                                                                                          class DescElement extends Element {}

                                                                                                                                            property type

                                                                                                                                            type: string;

                                                                                                                                              class Document

                                                                                                                                              class Document {}

                                                                                                                                                constructor

                                                                                                                                                constructor(
                                                                                                                                                canvg: Canvg,
                                                                                                                                                {
                                                                                                                                                rootEmSize,
                                                                                                                                                emSize,
                                                                                                                                                createCanvas,
                                                                                                                                                createImage,
                                                                                                                                                anonymousCrossOrigin,
                                                                                                                                                }?: IDocumentOptions
                                                                                                                                                );

                                                                                                                                                  property canvg

                                                                                                                                                  readonly canvg: Canvg;

                                                                                                                                                    property createCanvas

                                                                                                                                                    static readonly createCanvas: (
                                                                                                                                                    width: number,
                                                                                                                                                    height: number
                                                                                                                                                    ) => HTMLCanvasElement;

                                                                                                                                                      property createCanvas

                                                                                                                                                      readonly createCanvas: CreateCanvas;

                                                                                                                                                        property createImage

                                                                                                                                                        static readonly createImage: (
                                                                                                                                                        src: string,
                                                                                                                                                        anonymousCrossOrigin?: boolean
                                                                                                                                                        ) => Promise<HTMLImageElement>;

                                                                                                                                                          property createImage

                                                                                                                                                          readonly createImage: CreateImage;

                                                                                                                                                            property ctx

                                                                                                                                                            readonly ctx: RenderingContext2D;

                                                                                                                                                              property definitions

                                                                                                                                                              readonly definitions: Record<string, Element>;

                                                                                                                                                                property documentElement

                                                                                                                                                                documentElement: SVGElement;

                                                                                                                                                                  property elementTypes

                                                                                                                                                                  static readonly elementTypes: {
                                                                                                                                                                  svg: typeof SVGElement;
                                                                                                                                                                  rect: typeof import('./RectElement').default;
                                                                                                                                                                  circle: typeof import('./CircleElement').default;
                                                                                                                                                                  ellipse: typeof import('./EllipseElement').default;
                                                                                                                                                                  line: typeof import('./LineElement').default;
                                                                                                                                                                  polyline: typeof import('./PolylineElement').default;
                                                                                                                                                                  polygon: typeof import('./PolygonElement').default;
                                                                                                                                                                  path: typeof import('./PathElement').default;
                                                                                                                                                                  pattern: typeof import('./PatternElement').default;
                                                                                                                                                                  marker: typeof import('./MarkerElement').default;
                                                                                                                                                                  defs: typeof import('./DefsElement').default;
                                                                                                                                                                  linearGradient: typeof import('./LinearGradientElement').default;
                                                                                                                                                                  radialGradient: typeof import('./RadialGradientElement').default;
                                                                                                                                                                  stop: typeof import('./StopElement').default;
                                                                                                                                                                  animate: typeof import('./AnimateElement').default;
                                                                                                                                                                  animateColor: typeof import('./AnimateColorElement').default;
                                                                                                                                                                  animateTransform: typeof import('./AnimateTransformElement').default;
                                                                                                                                                                  font: typeof import('./FontElement').default;
                                                                                                                                                                  'font-face': typeof import('./FontFaceElement').default;
                                                                                                                                                                  'missing-glyph': typeof import('./MissingGlyphElement').default;
                                                                                                                                                                  glyph: typeof import('./GlyphElement').default;
                                                                                                                                                                  text: typeof import('./TextElement').default;
                                                                                                                                                                  tspan: typeof import('./TSpanElement').default;
                                                                                                                                                                  tref: typeof import('./TRefElement').default;
                                                                                                                                                                  a: typeof import('./AElement').default;
                                                                                                                                                                  textPath: typeof import('./TextPathElement').default;
                                                                                                                                                                  image: typeof ImageElement;
                                                                                                                                                                  g: typeof import('./GElement').default;
                                                                                                                                                                  symbol: typeof import('./SymbolElement').default;
                                                                                                                                                                  style: typeof import('./StyleElement').default;
                                                                                                                                                                  use: typeof import('./UseElement').default;
                                                                                                                                                                  mask: typeof import('./MaskElement').default;
                                                                                                                                                                  clipPath: typeof import('./ClipPathElement').default;
                                                                                                                                                                  filter: typeof import('./FilterElement').default;
                                                                                                                                                                  feDropShadow: typeof import('./FeDropShadowElement').default;
                                                                                                                                                                  feMorphology: typeof import('./FeMorphologyElement').default;
                                                                                                                                                                  feComposite: typeof import('./FeCompositeElement').default;
                                                                                                                                                                  feColorMatrix: typeof import('./FeColorMatrixElement').default;
                                                                                                                                                                  feGaussianBlur: typeof import('./FeGaussianBlurElement').default;
                                                                                                                                                                  title: typeof import('./TitleElement').default;
                                                                                                                                                                  desc: typeof import('./DescElement').default;
                                                                                                                                                                  };

                                                                                                                                                                    property emSize

                                                                                                                                                                    emSize: number;

                                                                                                                                                                      property fetch

                                                                                                                                                                      readonly fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;

                                                                                                                                                                        property fonts

                                                                                                                                                                        readonly fonts: SVGFontLoader[];

                                                                                                                                                                          property images

                                                                                                                                                                          readonly images: ImageElement[];

                                                                                                                                                                            property rootEmSize

                                                                                                                                                                            rootEmSize: number;

                                                                                                                                                                              property screen

                                                                                                                                                                              readonly screen: Screen;

                                                                                                                                                                                property styles

                                                                                                                                                                                readonly styles: Record<string, Record<string, Property<any>>>;

                                                                                                                                                                                  property stylesSpecificity

                                                                                                                                                                                  readonly stylesSpecificity: Record<string, string>;

                                                                                                                                                                                    property window

                                                                                                                                                                                    readonly window: Window;

                                                                                                                                                                                      method createDocumentElement

                                                                                                                                                                                      createDocumentElement: (document: DOMDocument) => SVGElement;

                                                                                                                                                                                        method createElement

                                                                                                                                                                                        createElement: <T extends Element>(node: HTMLElement) => T;

                                                                                                                                                                                          method createTextNode

                                                                                                                                                                                          createTextNode: (node: HTMLElement) => TextNode;

                                                                                                                                                                                            method getUniqueId

                                                                                                                                                                                            getUniqueId: () => string;

                                                                                                                                                                                              method isFontsLoaded

                                                                                                                                                                                              isFontsLoaded: () => boolean;

                                                                                                                                                                                                method isImagesLoaded

                                                                                                                                                                                                isImagesLoaded: () => boolean;

                                                                                                                                                                                                  method popEmSize

                                                                                                                                                                                                  popEmSize: () => void;

                                                                                                                                                                                                    method setViewBox

                                                                                                                                                                                                    setViewBox: (config: IViewBoxConfig) => void;

                                                                                                                                                                                                      class Element

                                                                                                                                                                                                      abstract class Element {}

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                          property animationFrozen

                                                                                                                                                                                                          animationFrozen: boolean;

                                                                                                                                                                                                            property animationFrozenValue

                                                                                                                                                                                                            animationFrozenValue: string;

                                                                                                                                                                                                              property attributes

                                                                                                                                                                                                              readonly attributes: Record<string, Property<any>>;

                                                                                                                                                                                                                property captureTextNodes

                                                                                                                                                                                                                protected readonly captureTextNodes: boolean;

                                                                                                                                                                                                                  property children

                                                                                                                                                                                                                  children: Element[];

                                                                                                                                                                                                                    property document

                                                                                                                                                                                                                    protected readonly document: Document;

                                                                                                                                                                                                                      property ignoreChildTypes

                                                                                                                                                                                                                      static readonly ignoreChildTypes: string[];

                                                                                                                                                                                                                        property node

                                                                                                                                                                                                                        protected readonly node: HTMLElement;

                                                                                                                                                                                                                          property parent

                                                                                                                                                                                                                          parent: Element;

                                                                                                                                                                                                                            property styles

                                                                                                                                                                                                                            readonly styles: Record<string, Property<any>>;

                                                                                                                                                                                                                              property stylesSpecificity

                                                                                                                                                                                                                              readonly stylesSpecificity: Record<string, string>;

                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                readonly type: string;

                                                                                                                                                                                                                                  method addChild

                                                                                                                                                                                                                                  protected addChild: (childNode: Element | HTMLElement) => void;

                                                                                                                                                                                                                                    method addStylesFromStyleDefinition

                                                                                                                                                                                                                                    addStylesFromStyleDefinition: () => void;

                                                                                                                                                                                                                                      method applyEffects

                                                                                                                                                                                                                                      protected applyEffects: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                        method clearContext

                                                                                                                                                                                                                                        clearContext: (_: RenderingContext2D) => void;

                                                                                                                                                                                                                                          method getAttribute

                                                                                                                                                                                                                                          getAttribute: (name: string, createIfNotExists?: boolean) => Property<any>;

                                                                                                                                                                                                                                            method getHrefAttribute

                                                                                                                                                                                                                                            getHrefAttribute: () => Property<any>;

                                                                                                                                                                                                                                              method getStyle

                                                                                                                                                                                                                                              getStyle: (
                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                              createIfNotExists?: boolean,
                                                                                                                                                                                                                                              skipAncestors?: boolean
                                                                                                                                                                                                                                              ) => Property;

                                                                                                                                                                                                                                                method matchesSelector

                                                                                                                                                                                                                                                protected matchesSelector: (selector: string) => boolean;

                                                                                                                                                                                                                                                  method removeStyles

                                                                                                                                                                                                                                                  protected removeStyles: (
                                                                                                                                                                                                                                                  element: Element,
                                                                                                                                                                                                                                                  ignoreStyles: string[]
                                                                                                                                                                                                                                                  ) => [string, string][];

                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                    render: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                      method renderChildren

                                                                                                                                                                                                                                                      renderChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                        method restoreStyles

                                                                                                                                                                                                                                                        protected restoreStyles: (element: Element, styles: [string, string][]) => void;

                                                                                                                                                                                                                                                          method setContext

                                                                                                                                                                                                                                                          setContext: (_: RenderingContext2D) => void;

                                                                                                                                                                                                                                                            class EllipseElement

                                                                                                                                                                                                                                                            class EllipseElement extends PathElement {}

                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                method getMarkers

                                                                                                                                                                                                                                                                getMarkers: () => any;

                                                                                                                                                                                                                                                                  method path

                                                                                                                                                                                                                                                                  path: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                    class FeColorMatrixElement

                                                                                                                                                                                                                                                                    class FeColorMatrixElement extends Element {}

                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                      constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                        property includeOpacity

                                                                                                                                                                                                                                                                        protected readonly includeOpacity: boolean;

                                                                                                                                                                                                                                                                          property matrix

                                                                                                                                                                                                                                                                          protected readonly matrix: number[];

                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                              apply: (
                                                                                                                                                                                                                                                                              ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                              _: number,
                                                                                                                                                                                                                                                                              __: number,
                                                                                                                                                                                                                                                                              width: number,
                                                                                                                                                                                                                                                                              height: number
                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                class FeCompositeElement

                                                                                                                                                                                                                                                                                class FeCompositeElement extends Element {}

                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                    apply: (
                                                                                                                                                                                                                                                                                    _: RenderingContext2D,
                                                                                                                                                                                                                                                                                    __: number,
                                                                                                                                                                                                                                                                                    ___: number,
                                                                                                                                                                                                                                                                                    ____: number,
                                                                                                                                                                                                                                                                                    _____: number
                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                      class FeDropShadowElement

                                                                                                                                                                                                                                                                                      class FeDropShadowElement extends Element {}

                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                        constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                            apply: (
                                                                                                                                                                                                                                                                                            _: RenderingContext2D,
                                                                                                                                                                                                                                                                                            __: number,
                                                                                                                                                                                                                                                                                            ___: number,
                                                                                                                                                                                                                                                                                            ____: number,
                                                                                                                                                                                                                                                                                            _____: number
                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                              class FeGaussianBlurElement

                                                                                                                                                                                                                                                                                              class FeGaussianBlurElement extends Element {}

                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                  property blurRadius

                                                                                                                                                                                                                                                                                                  protected readonly blurRadius: number;

                                                                                                                                                                                                                                                                                                    property extraFilterDistance

                                                                                                                                                                                                                                                                                                    readonly extraFilterDistance: number;

                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                        method apply

                                                                                                                                                                                                                                                                                                        apply: (
                                                                                                                                                                                                                                                                                                        ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                        x: number,
                                                                                                                                                                                                                                                                                                        y: number,
                                                                                                                                                                                                                                                                                                        width: number,
                                                                                                                                                                                                                                                                                                        height: number
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          class FeMorphologyElement

                                                                                                                                                                                                                                                                                                          class FeMorphologyElement extends Element {}

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                              method apply

                                                                                                                                                                                                                                                                                                              apply: (
                                                                                                                                                                                                                                                                                                              _: RenderingContext2D,
                                                                                                                                                                                                                                                                                                              __: number,
                                                                                                                                                                                                                                                                                                              ___: number,
                                                                                                                                                                                                                                                                                                              ____: number,
                                                                                                                                                                                                                                                                                                              _____: number
                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                class FilterElement

                                                                                                                                                                                                                                                                                                                class FilterElement extends Element {}

                                                                                                                                                                                                                                                                                                                  property ignoreStyles

                                                                                                                                                                                                                                                                                                                  static ignoreStyles: string[];

                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                      apply: (ctx: RenderingContext2D, element: PathElement) => void;

                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                        render: (_: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                          class Font

                                                                                                                                                                                                                                                                                                                          class Font {}

                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                            fontStyle: string,
                                                                                                                                                                                                                                                                                                                            fontVariant: string,
                                                                                                                                                                                                                                                                                                                            fontWeight: string,
                                                                                                                                                                                                                                                                                                                            fontSize: string,
                                                                                                                                                                                                                                                                                                                            fontFamily: string,
                                                                                                                                                                                                                                                                                                                            inherit?: string | Font
                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                              property fontFamily

                                                                                                                                                                                                                                                                                                                              readonly fontFamily: string;

                                                                                                                                                                                                                                                                                                                                property fontSize

                                                                                                                                                                                                                                                                                                                                readonly fontSize: string;

                                                                                                                                                                                                                                                                                                                                  property fontStyle

                                                                                                                                                                                                                                                                                                                                  readonly fontStyle: string;

                                                                                                                                                                                                                                                                                                                                    property fontVariant

                                                                                                                                                                                                                                                                                                                                    readonly fontVariant: string;

                                                                                                                                                                                                                                                                                                                                      property fontWeight

                                                                                                                                                                                                                                                                                                                                      readonly fontWeight: string;

                                                                                                                                                                                                                                                                                                                                        property styles

                                                                                                                                                                                                                                                                                                                                        static readonly styles: string;

                                                                                                                                                                                                                                                                                                                                          property variants

                                                                                                                                                                                                                                                                                                                                          static readonly variants: string;

                                                                                                                                                                                                                                                                                                                                            property weights

                                                                                                                                                                                                                                                                                                                                            static readonly weights: string;

                                                                                                                                                                                                                                                                                                                                              method parse

                                                                                                                                                                                                                                                                                                                                              static parse: (font?: string, inherit?: string | Font) => Font;

                                                                                                                                                                                                                                                                                                                                                method toString

                                                                                                                                                                                                                                                                                                                                                toString: () => string;

                                                                                                                                                                                                                                                                                                                                                  class FontElement

                                                                                                                                                                                                                                                                                                                                                  class FontElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                    constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                      property fontFace

                                                                                                                                                                                                                                                                                                                                                      readonly fontFace: FontFaceElement;

                                                                                                                                                                                                                                                                                                                                                        property glyphs

                                                                                                                                                                                                                                                                                                                                                        readonly glyphs: Record<string, GlyphElement | Record<string, GlyphElement>>;

                                                                                                                                                                                                                                                                                                                                                          property horizAdvX

                                                                                                                                                                                                                                                                                                                                                          readonly horizAdvX: number;

                                                                                                                                                                                                                                                                                                                                                            property isArabic

                                                                                                                                                                                                                                                                                                                                                            readonly isArabic: boolean;

                                                                                                                                                                                                                                                                                                                                                              property isRTL

                                                                                                                                                                                                                                                                                                                                                              readonly isRTL: boolean;

                                                                                                                                                                                                                                                                                                                                                                property missingGlyph

                                                                                                                                                                                                                                                                                                                                                                readonly missingGlyph: MissingGlyphElement;

                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                    render: () => void;

                                                                                                                                                                                                                                                                                                                                                                      class FontFaceElement

                                                                                                                                                                                                                                                                                                                                                                      class FontFaceElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                        constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                          property ascent

                                                                                                                                                                                                                                                                                                                                                                          readonly ascent: number;

                                                                                                                                                                                                                                                                                                                                                                            property descent

                                                                                                                                                                                                                                                                                                                                                                            readonly descent: number;

                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                property unitsPerEm

                                                                                                                                                                                                                                                                                                                                                                                readonly unitsPerEm: number;

                                                                                                                                                                                                                                                                                                                                                                                  class GElement

                                                                                                                                                                                                                                                                                                                                                                                  class GElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                      method getBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                      getBoundingBox: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                        class GlyphElement

                                                                                                                                                                                                                                                                                                                                                                                        class GlyphElement extends PathElement {}

                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                          constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                            property arabicForm

                                                                                                                                                                                                                                                                                                                                                                                            readonly arabicForm: string;

                                                                                                                                                                                                                                                                                                                                                                                              property horizAdvX

                                                                                                                                                                                                                                                                                                                                                                                              readonly horizAdvX: number;

                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property unicode

                                                                                                                                                                                                                                                                                                                                                                                                  readonly unicode: string;

                                                                                                                                                                                                                                                                                                                                                                                                    class GradientElement

                                                                                                                                                                                                                                                                                                                                                                                                    abstract class GradientElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                      constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                        property attributesToInherit

                                                                                                                                                                                                                                                                                                                                                                                                        readonly attributesToInherit: string[];

                                                                                                                                                                                                                                                                                                                                                                                                          property stops

                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly stops: StopElement[];

                                                                                                                                                                                                                                                                                                                                                                                                            method addParentOpacity

                                                                                                                                                                                                                                                                                                                                                                                                            protected addParentOpacity: (
                                                                                                                                                                                                                                                                                                                                                                                                            parentOpacityProp: Property,
                                                                                                                                                                                                                                                                                                                                                                                                            color: string
                                                                                                                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                              method createGradient

                                                                                                                                                                                                                                                                                                                                                                                                              createGradient: (
                                                                                                                                                                                                                                                                                                                                                                                                              ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                              element: any,
                                                                                                                                                                                                                                                                                                                                                                                                              parentOpacityProp: Property
                                                                                                                                                                                                                                                                                                                                                                                                              ) => string | CanvasGradient | CanvasPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                method getGradient

                                                                                                                                                                                                                                                                                                                                                                                                                abstract getGradient: (
                                                                                                                                                                                                                                                                                                                                                                                                                ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                element: PathElement
                                                                                                                                                                                                                                                                                                                                                                                                                ) => CanvasGradient;

                                                                                                                                                                                                                                                                                                                                                                                                                  method getGradientUnits

                                                                                                                                                                                                                                                                                                                                                                                                                  getGradientUnits: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                    method inheritStopContainer

                                                                                                                                                                                                                                                                                                                                                                                                                    protected inheritStopContainer: (stopsContainer: Element) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      class ImageElement

                                                                                                                                                                                                                                                                                                                                                                                                                      class ImageElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                          property image

                                                                                                                                                                                                                                                                                                                                                                                                                          protected image: string | CanvasImageSource;

                                                                                                                                                                                                                                                                                                                                                                                                                            property isSvg

                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly isSvg: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                              property loaded

                                                                                                                                                                                                                                                                                                                                                                                                                              loaded: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                  getBoundingBox: () => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method loadImage

                                                                                                                                                                                                                                                                                                                                                                                                                                    protected loadImage: (href: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method loadSvg

                                                                                                                                                                                                                                                                                                                                                                                                                                      protected loadSvg: (href: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method renderChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                        renderChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                          class LinearGradientElement

                                                                                                                                                                                                                                                                                                                                                                                                                                          class LinearGradientElement extends GradientElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method getGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                getGradient: (ctx: RenderingContext2D, element: PathElement) => CanvasGradient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class LineElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class LineElement extends PathElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMarkers: () => Marker[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                        getPoints: () => Point[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class MarkerElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class MarkerElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: (ctx: RenderingContext2D, point?: Point, angle?: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MaskElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MaskElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ignoreStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static ignoreStyles: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        apply: (ctx: RenderingContext2D, element: Element) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: (_: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Matrix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Matrix implements ITransform {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(_: Document, matrix: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property matrix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected matrix: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method applyToPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      applyToPoint: (point: Point) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method unapply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        unapply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MissingGlyphElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class MissingGlyphElement extends PathElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property horizAdvX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly horizAdvX: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Mouse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Mouse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(screen: Screen);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method checkBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    checkBoundingBox: (element: Element, boundingBox: BoundingBox) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method checkPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkPath: (element: Element, ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method hasEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasEvents: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isWorking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isWorking: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method runEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            runEvents: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stop: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Parser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor({ fetch, DOMParser }?: IParserOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load: (url: string) => Promise<Document>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parse: (resource: string) => Promise<Document>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method parseFromString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parseFromString: (xml: string) => Document;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PathElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PathElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pathParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly pathParser: PathParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getBoundingBox: (_?: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMarkers: () => Marker[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: (ctx?: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pathA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static pathA: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pathParser: PathParser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          currentPoint: Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rX: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rY: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sweepFlag: 0 | 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          xAxisRotation: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          centp: Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          a1: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ad: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method pathC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static pathC: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pathParser: PathParser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => { current: Point; point: Point; controlPoint: Point; currentPoint: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method pathH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static pathH: (pathParser: PathParser) => { current: Point; point: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method pathL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static pathL: (pathParser: PathParser) => { current: Point; point: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method pathM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static pathM: (pathParser: PathParser) => { point: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pathQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static pathQ: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pathParser: PathParser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => { current: Point; controlPoint: Point; currentPoint: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method pathS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static pathS: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pathParser: PathParser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => { current: Point; point: Point; controlPoint: Point; currentPoint: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pathT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static pathT: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pathParser: PathParser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => { current: Point; controlPoint: Point; currentPoint: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pathV

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static pathV: (pathParser: PathParser) => { current: Point; point: Point };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method pathZ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static pathZ: (pathParser: PathParser) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class PathParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class PathParser extends SVGPathData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(path: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    command: Command;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property commands

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly commands: Command[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property control

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        control: Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property current

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          current: Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            start: Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addMarker: (point: Point, from?: Point, priorTo?: Point) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addMarkerAngle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addMarkerAngle: (point: Point, angle: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getAsControlPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getAsControlPoint: (xProp?: string, yProp?: string) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getAsCurrentPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getAsCurrentPoint: (xProp?: string, yProp?: string) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMarkerAngles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMarkerAngles: () => number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getMarkerPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getMarkerPoints: () => Point[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getPoint: (xProp?: string, yProp?: string) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getReflectedControlPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getReflectedControlPoint: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnd: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method makeAbsolute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                makeAbsolute: (point: Point) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  next: () => Command;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reset: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class PatternElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class PatternElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createPattern: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          _: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parentOpacityProp: Property
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => CanvasPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Point {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(x: number, y: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method angleTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    angleTo: (point: Point) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method applyTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      applyTransform: (transform: number[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static parse: (point: string, defaultValue?: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method parsePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static parsePath: (path: string) => Point[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method parseScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static parseScale: (scale: string, defaultValue?: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class PolygonElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class PolygonElement extends PolylineElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: (ctx: RenderingContext2D) => import('..').BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PolylineElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PolylineElement extends PathElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property points

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly points: Point[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getMarkers: () => Marker[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Property<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(document: Document, name: string, value: {});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property textBaselineMapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static readonly textBaselineMapping: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseline: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'before-edge': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'text-before-edge': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    middle: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    central: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'after-edge': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'text-after-edge': string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ideographic: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alphabetic: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hanging: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mathematical: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method addOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addOpacity: (opacity: Property) => Property<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static empty: (document: Document) => Property<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getColor: (def?: T) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDefinition: <T extends Element>() => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDpi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDpi: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getEm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getEm: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getFillStyleDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getFillStyleDefinition: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  element: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opacity: Property
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => string | CanvasPattern | CanvasGradient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getMilliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getMilliseconds: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getNumber: (def?: T) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPixels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getPixels: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (axis?: Axis, processPercent?: boolean): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (isFontSize?: boolean): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getRadians

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getRadians: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getRem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getRem: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getString: (def?: T) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getTextBaseline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getTextBaseline: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getUnits: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getValue: (def?: T) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method hasValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hasValue: (zeroIsValue?: boolean) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isPixels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isPixels: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isString: (regexp?: RegExp) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isUrlDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isUrlDefinition: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setValue: (value: T) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method split

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                split: (separator?: string) => Property<string>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class RadialGradientElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class RadialGradientElement extends GradientElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getGradient: (ctx: RenderingContext2D, element: PathElement) => CanvasGradient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RectElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RectElement extends PathElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMarkers: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class RenderedElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract class RenderedElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method calculateOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected calculateOpacity: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method clearContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clearContext: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setContext: (ctx: RenderingContext2D, fromMeasure?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Rotate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Rotate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            document: Document,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rotate: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transformOrigin: [Property<string>, Property<string>]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                apply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method applyToPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  applyToPoint: (point: Point) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method unapply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unapply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Scale {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(_: Document, scale: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            apply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method applyToPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              applyToPoint: (point: Point) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method unapply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unapply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Screen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Screen {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(ctx: RenderingContext2D, { fetch, window }?: IScreenOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property animations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly animations: AnimateElement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property CLIENT_HEIGHT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CLIENT_HEIGHT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property CLIENT_WIDTH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CLIENT_WIDTH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ctx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly ctx: RenderingContext2D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultFetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly defaultFetch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              input: RequestInfo,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              init?: RequestInit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<Response>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultWindow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static readonly defaultWindow: Window & typeof globalThis;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property FRAMERATE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FRAMERATE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property MAX_VIRTUAL_PIXELS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MAX_VIRTUAL_PIXELS: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property mouse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly mouse: Mouse;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property viewPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly viewPort: ViewPort;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property window

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly window?: Window;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isReady: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ready: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setDefaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setDefaults: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setViewBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setViewBox: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    document,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ctx,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    aspectRatio,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    width,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    desiredWidth,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    height,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    desiredHeight,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minX,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minY,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    refX,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    refY,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clip,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clipX,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clipY,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }: IScreenViewBoxConfig) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      element: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enableRedraw,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreMouse,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreAnimation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreDimensions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreClear,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      forceRedraw,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scaleWidth,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scaleHeight,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offsetX,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offsetY,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }?: IScreenStartOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stop: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method wait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wait: (checker: () => boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Skew

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Skew extends Matrix {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(document: Document, skew: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property angle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected readonly angle: Property<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SkewX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SkewX extends Skew {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(document: Document, skew: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class SkewY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class SkewY extends Skew {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(document: Document, skew: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class StopElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class StopElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly color: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class StyleElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class StyleElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parseExternalUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static readonly parseExternalUrl: (url: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SVGElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SVGElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    root: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method clearContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clearContext: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resize: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          width: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          height?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          preserveAspectRatio?: boolean | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resize SVG to fit in given size.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter preserveAspectRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setContext: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SVGFontLoader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SVGFontLoader {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(document: Document);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loaded: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  load: (fontFamily: string, url: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SymbolElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SymbolElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        render: (_: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TextElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TextElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method adjustChildCoordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected adjustChildCoordinates: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    textParent: TextElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => TextElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAnchorDelta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getAnchorDelta: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parent: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startI: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBoundingBox: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChildBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getChildBoundingBox: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          textParent: TextElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parent: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getFontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected getFontSize: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getGlyph

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getGlyph: (font: FontElement, text: string, i: number) => GlyphElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getTElementBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getTElementBoundingBox: (ctx: RenderingContext2D) => BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getText: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getTextFromNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected getTextFromNode: (node?: ChildNode) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method initializeCoordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected initializeCoordinates: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method measureTargetText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected measureTargetText: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        targetText: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method measureText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected measureText: (ctx: RenderingContext2D) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method measureTextRecursive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected measureTextRecursive: (ctx: RenderingContext2D) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method renderChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected renderChild: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              textParent: TextElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parent: Element,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method renderChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                renderChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method renderTElementChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected renderTElementChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setContext: (ctx: RenderingContext2D, fromMeasure?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TextPathElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TextPathElement extends TextElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dataArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly dataArray: IPathCommand[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property glyphInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected glyphInfo: IGlyphInfo[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pathLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected pathLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected readonly text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property textHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected textHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property textWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected textWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method buildEquidistantCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected buildEquidistantCache: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inputStep: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inputPrecision: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method calcLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected calcLength: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          commandType: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          points: number[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method findSegmentToFitChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected findSegmentToFitChar: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ctx: RenderingContext2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            anchor: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            textFullWidth: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fullPathWidth: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spacesNumber: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inputOffset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dy: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            c: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            charI: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            offset: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            segment: { p0: ICachedPoint; p1: ICachedPoint };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rotation: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getEquidistantPointOnPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getEquidistantPointOnPath: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              targetDistance: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              step?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              precision?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ICachedPoint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getLetterSpacingAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getLetterSpacingAt: (idx?: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getLineLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getLineLength: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  x1: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y1: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  x2: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y2: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getPathLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected getPathLength: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPointOnCubicBezier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getPointOnCubicBezier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pct: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P1x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P1y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P2x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P2y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P3x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P3y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P4x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      P4y: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => IPoint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPointOnEllipticalArc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected getPointOnEllipticalArc: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cx: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cy: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rx: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ry: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        theta: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        psi: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => IPoint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPointOnLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getPointOnLine: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dist: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          P1x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          P1y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          P2x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          P2y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fromX?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fromY?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => IPoint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getPointOnPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected getPointOnPath: (distance: number) => IPoint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getPointOnQuadraticBezier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getPointOnQuadraticBezier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pct: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P1x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P1y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P2x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P2y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P3x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P3y: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => IPoint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getText: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method measureText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected measureText: (ctx: RenderingContext2D, text?: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method parsePathData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected parsePathData: (path: PathElement) => IPathCommand[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pathA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected pathA: (pathParser: PathParser) => number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pathC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected pathC: (pathParser: PathParser, points: number[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method pathH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected pathH: (pathParser: PathParser, points: number[]) => 16;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method pathL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected pathL: (pathParser: PathParser, points: number[]) => 16;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method pathM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected pathM: (pathParser: PathParser, points: number[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method pathQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected pathQ: (pathParser: PathParser, points: number[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pathS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected pathS: (pathParser: PathParser, points: number[]) => 32;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method pathT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected pathT: (pathParser: PathParser, points: number[]) => 128;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pathV

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected pathV: (pathParser: PathParser, points: number[]) => 16;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method renderChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setTextData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected setTextData: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TitleElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TitleElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Transform {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    document: Document,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transform: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transformOrigin?: readonly [Property<string>, Property<string>]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property transformTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static transformTypes: Record<string, ITransformConstructor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        apply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method applyToPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          applyToPoint: (point: Point) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method fromElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static fromElement: (document: Document, element: Element) => Transform;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method unapply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unapply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Translate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Translate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(_: Document, point: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method apply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      apply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method applyToPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        applyToPoint: (point: Point) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method unapply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unapply: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class TRefElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class TRefElement extends TextElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getText: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class TSpanElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class TSpanElement extends TextElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected readonly text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getText: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class UnknownElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class UnknownElement extends Element {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(document: Document, node: HTMLElement, captureTextNodes?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UseElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UseElement extends RenderedElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly element: PathElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method elementTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      elementTransform: () => Transform;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBoundingBox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBoundingBox: (ctx: RenderingContext2D) => import('..').BoundingBox;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method renderChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            renderChildren: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setContext: (ctx: RenderingContext2D) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ViewPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ViewPort {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property viewPorts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    viewPorts: IViewPortSize[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method computeSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          computeSize: (d?: number | Axis) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getCurrent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getCurrent: () => IViewPortSize;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method removeCurrent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeCurrent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setCurrent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setCurrent: (width: number, height: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IDocumentOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property anonymousCrossOrigin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    anonymousCrossOrigin?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Load images anonymously.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property createCanvas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createCanvas?: CreateCanvas;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Function to create new canvas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property createImage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createImage?: CreateImage;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Function to create new image.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property emSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Default em size.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rootEmSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rootEmSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Default rem size.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            run: (event: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extends IParserOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IScreenOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IScreenStartOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IDocumentOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IParserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IParserOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property DOMParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DOMParser?: typeof DOMParser;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • XML/HTML parser from string into DOM Document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fetch?: typeof fetch;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • WHATWG-compatible fetch function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IScreenOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IScreenOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fetch?: typeof fetch;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • WHATWG-compatible fetch function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property window

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    window?: Window;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Window object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IScreenStartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IScreenStartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property enableRedraw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enableRedraw?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether enable the redraw.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreAnimation?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ignore animations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreClear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreClear?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Does not clear canvas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreDimensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreDimensions?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Does not try to resize canvas.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreMouse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreMouse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ignore mouse events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offsetX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offsetX?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Draws at a x offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offsetY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offsetY?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Draws at a y offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scaleHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scaleHeight?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Scales vertically to height.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scaleWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scaleWidth?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Scales horizontally to width.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method forceRedraw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      forceRedraw: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Will call the function on every frame, if it returns true, will redraw.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IScreenViewBoxConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IScreenViewBoxConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property aspectRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        aspectRatio: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property clip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          clip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property clipX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            clipX?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property clipY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clipY?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ctx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ctx: RenderingContext2D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property desiredHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  desiredHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property desiredWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    desiredWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property document

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      document: Document;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property minX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          minX?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property minY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            minY?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property refX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              refX?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property refY