dompdf.js 1.1.1 → 1.2.0

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

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

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

@@ -0,0 +1,45 @@
+import { Bounds } from '../css/layout/bounds';
+import { Context } from '../core/context';
+export interface CloneOptions {
+    ignoreElements?: (element: Element) => boolean;
+    onclone?: (document: Document, element: HTMLElement) => void;
+    allowTaint?: boolean;
+}
+export interface WindowOptions {
+    scrollX: number;
+    scrollY: number;
+    windowWidth: number;
+    windowHeight: number;
+}
+export type CloneConfigurations = CloneOptions & {
+    inlineImages: boolean;
+    copyStyles: boolean;
+};
+export declare class DocumentCloner {
+    private readonly context;
+    private readonly options;
+    private readonly scrolledElements;
+    private readonly referenceElement;
+    clonedReferenceElement?: HTMLElement;
+    private readonly documentElement;
+    private readonly counters;
+    private quoteDepth;
+    constructor(context: Context, element: HTMLElement, options: CloneConfigurations);
+    toIFrame(ownerDocument: Document, windowSize: Bounds): Promise<HTMLIFrameElement>;
+    createElementClone<T extends HTMLElement | SVGElement>(node: T): HTMLElement | SVGElement;
+    createCustomElementClone(node: HTMLElement): HTMLElement;
+    createStyleClone(node: HTMLStyleElement): HTMLStyleElement;
+    createCanvasClone(canvas: HTMLCanvasElement): HTMLImageElement | HTMLCanvasElement;
+    createVideoClone(video: HTMLVideoElement): HTMLCanvasElement;
+    appendChildNode(clone: HTMLElement | SVGElement, child: Node, copyStyles: boolean): void;
+    cloneChildNodes(node: Element, clone: HTMLElement | SVGElement, copyStyles: boolean): void;
+    cloneNode(node: Node, copyStyles: boolean): Node;
+    resolvePseudoContent(node: Element, clone: Element, style: CSSStyleDeclaration, pseudoElt: PseudoElementType): HTMLElement | void;
+    static destroy(container: HTMLIFrameElement): boolean;
+}
+declare enum PseudoElementType {
+    BEFORE = 0,
+    AFTER = 1
+}
+export declare const copyCSSStyles: <T extends HTMLElement | SVGElement>(style: CSSStyleDeclaration, target: T) => T;
+export {};

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { ElementContainer } from '../element-container';
+import { Context } from '../../core/context';
+export declare class OLElementContainer extends ElementContainer {
+    readonly start: number;
+    readonly reversed: boolean;
+    constructor(context: Context, element: HTMLOListElement);
+}

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { Context } from '../core/context';
+import { ElementContainer } from './element-container';
+export declare const parseTree: (context: Context, element: HTMLElement) => Promise<ElementContainer>;
+export declare const isTextNode: (node: Node) => node is Text;
+export declare const isElementNode: (node: Node) => node is Element;
+export declare const isHTMLElementNode: (node: Node) => node is HTMLElement;
+export declare const isSVGElementNode: (element: Element) => element is SVGElement;
+export declare const isLIElement: (node: Element) => node is HTMLLIElement;
+export declare const isOLElement: (node: Element) => node is HTMLOListElement;
+export declare const isInputElement: (node: Element) => node is HTMLInputElement;
+export declare const isHTMLElement: (node: Element) => node is HTMLHtmlElement;
+export declare const isSVGElement: (node: Element) => node is SVGSVGElement;
+export declare const isBodyElement: (node: Element) => node is HTMLBodyElement;
+export declare const isCanvasElement: (node: Element) => node is HTMLCanvasElement;
+export declare const isVideoElement: (node: Element) => node is HTMLVideoElement;
+export declare const isImageElement: (node: Element) => node is HTMLImageElement;
+export declare const isIFrameElement: (node: Element) => node is HTMLIFrameElement;
+export declare const isStyleElement: (node: Element) => node is HTMLStyleElement;
+export declare const isScriptElement: (node: Element) => node is HTMLScriptElement;
+export declare const isTextareaElement: (node: Element) => node is HTMLTextAreaElement;
+export declare const isSelectElement: (node: Element) => node is HTMLSelectElement;
+export declare const isSlotElement: (node: Element) => node is HTMLSlotElement;
+export declare const isCustomElement: (node: Element) => node is HTMLElement;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+import { jsPDF } from 'jspdf';
+import { ContextOptions } from './core/context';
+import { CloneOptions, WindowOptions } from './dom/document-cloner';
+import { RenderOptions } from './render/canvas/pdf-renderer';
+import { FontConfig } from './utils';
+export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOptions & {
+    backgroundColor: string | null;
+    foreignObjectRendering: boolean;
+    divisionDisable?: boolean;
+    removeContainer?: boolean;
+    fontConfig?: FontConfig | FontConfig[] | undefined;
+    onJspdfReady?: (jspdfCtx: jsPDF) => void;
+    onJspdfFinish?: (jspdfCtx: jsPDF) => void;
+};
+export type DompdfResult = HTMLCanvasElement | Blob;
+declare const dompdf: (element: HTMLElement, options?: Partial<Options>) => Promise<DompdfResult>;
+export default dompdf;

package/dist/types/invariant.d.ts

@@ -0,0 +1 @@
+export declare const invariant: (assertion: boolean, error: string) => void;

package/dist/types/render/background.d.ts

@@ -0,0 +1,16 @@
+import { Bounds } from '../css/layout/bounds';
+import { BACKGROUND_ORIGIN } from '../css/property-descriptors/background-origin';
+import { ElementContainer } from '../dom/element-container';
+import { BackgroundSizeInfo } from '../css/property-descriptors/background-size';
+import { Vector } from './vector';
+import { BACKGROUND_REPEAT } from '../css/property-descriptors/background-repeat';
+import { CSSValue } from '../css/syntax/parser';
+import { Path } from './path';
+import { BACKGROUND_CLIP } from '../css/property-descriptors/background-clip';
+export declare const calculateBackgroundPositioningArea: (backgroundOrigin: BACKGROUND_ORIGIN, element: ElementContainer) => Bounds;
+export declare const calculateBackgroundPaintingArea: (backgroundClip: BACKGROUND_CLIP, element: ElementContainer) => Bounds;
+export declare const calculateBackgroundRendering: (container: ElementContainer, index: number, intrinsicSize: [number | null, number | null, number | null]) => [Path[], number, number, number, number];
+export declare const isAuto: (token: CSSValue) => boolean;
+export declare const calculateBackgroundSize: (size: BackgroundSizeInfo[], [intrinsicWidth, intrinsicHeight, intrinsicProportion]: [number | null, number | null, number | null], bounds: Bounds) => [number, number];
+export declare const getBackgroundValueForIndex: <T>(values: T[], index: number) => T;
+export declare const calculateBackgroundRepeatPath: (repeat: BACKGROUND_REPEAT, [x, y]: [number, number], [width, height]: [number, number], backgroundPositioningArea: Bounds, backgroundPaintingArea: Bounds) => [Vector, Vector, Vector, Vector];

package/dist/types/render/bezier-curve.d.ts

@@ -0,0 +1,14 @@
+import { Vector } from './vector';
+import { IPath, PathType, Path } from './path';
+export declare class BezierCurve implements IPath {
+    type: PathType;
+    start: Vector;
+    startControl: Vector;
+    endControl: Vector;
+    end: Vector;
+    constructor(start: Vector, startControl: Vector, endControl: Vector, end: Vector);
+    subdivide(t: number, firstHalf: boolean): BezierCurve;
+    add(deltaX: number, deltaY: number): BezierCurve;
+    reverse(): BezierCurve;
+}
+export declare const isBezierCurve: (path: Path) => path is BezierCurve;

package/dist/types/render/border.d.ts

@@ -0,0 +1,6 @@
+import { Path } from './path';
+import { BoundCurves } from './bound-curves';
+export declare const parsePathForBorder: (curves: BoundCurves, borderSide: number) => Path[];
+export declare const parsePathForBorderDoubleOuter: (curves: BoundCurves, borderSide: number) => Path[];
+export declare const parsePathForBorderDoubleInner: (curves: BoundCurves, borderSide: number) => Path[];
+export declare const parsePathForBorderStroke: (curves: BoundCurves, borderSide: number) => Path[];

package/dist/types/render/bound-curves.d.ts

@@ -0,0 +1,32 @@
+import { ElementContainer } from '../dom/element-container';
+import { Path } from './path';
+export declare class BoundCurves {
+    readonly topLeftBorderDoubleOuterBox: Path;
+    readonly topRightBorderDoubleOuterBox: Path;
+    readonly bottomRightBorderDoubleOuterBox: Path;
+    readonly bottomLeftBorderDoubleOuterBox: Path;
+    readonly topLeftBorderDoubleInnerBox: Path;
+    readonly topRightBorderDoubleInnerBox: Path;
+    readonly bottomRightBorderDoubleInnerBox: Path;
+    readonly bottomLeftBorderDoubleInnerBox: Path;
+    readonly topLeftBorderStroke: Path;
+    readonly topRightBorderStroke: Path;
+    readonly bottomRightBorderStroke: Path;
+    readonly bottomLeftBorderStroke: Path;
+    readonly topLeftBorderBox: Path;
+    readonly topRightBorderBox: Path;
+    readonly bottomRightBorderBox: Path;
+    readonly bottomLeftBorderBox: Path;
+    readonly topLeftPaddingBox: Path;
+    readonly topRightPaddingBox: Path;
+    readonly bottomRightPaddingBox: Path;
+    readonly bottomLeftPaddingBox: Path;
+    readonly topLeftContentBox: Path;
+    readonly topRightContentBox: Path;
+    readonly bottomRightContentBox: Path;
+    readonly bottomLeftContentBox: Path;
+    constructor(element: ElementContainer);
+}
+export declare const calculateBorderBoxPath: (curves: BoundCurves) => Path[];
+export declare const calculateContentBoxPath: (curves: BoundCurves) => Path[];
+export declare const calculatePaddingBoxPath: (curves: BoundCurves) => Path[];

package/dist/types/render/box-sizing.d.ts

@@ -0,0 +1,4 @@
+import { Bounds } from '../css/layout/bounds';
+import { ElementContainer } from '../dom/element-container';
+export declare const paddingBox: (element: ElementContainer) => Bounds;
+export declare const contentBox: (element: ElementContainer) => Bounds;

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

@@ -0,0 +1,11 @@
+import { Context } from '../../core/context';
+import { Renderer } from '../renderer';
+import { RenderConfigurations } from './pdf-renderer';
+export declare class ForeignObjectRenderer extends Renderer {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    options: RenderConfigurations;
+    constructor(context: Context, options: RenderConfigurations);
+    render(element: HTMLElement): Promise<HTMLCanvasElement>;
+}
+export declare const loadSerializedSVG: (svg: Node) => Promise<HTMLImageElement>;

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

@@ -0,0 +1,110 @@
+import { Context2d, EncryptionOptions, jsPDF } from 'jspdf';
+import 'jspdf/dist/polyfills.es.js';
+import { Context } from '../../core/context';
+import { CSSParsedDeclaration } from '../../css';
+import { Bounds } from '../../css/layout/bounds';
+import { TextBounds } from '../../css/layout/text';
+import { BORDER_STYLE } from '../../css/property-descriptors/border-style';
+import { Color } from '../../css/types/color';
+import { ElementContainer } from '../../dom/element-container';
+import { CanvasElementContainer } from '../../dom/replaced-elements/canvas-element-container';
+import { ImageElementContainer } from '../../dom/replaced-elements/image-element-container';
+import { SVGElementContainer } from '../../dom/replaced-elements/svg-element-container';
+import { TextContainer } from '../../dom/text-container';
+import { BoundCurves } from '../bound-curves';
+import { IElementEffect } from '../effects';
+import { FontConfig } from '../../utils';
+import { Path } from '../path';
+import { Renderer } from '../renderer';
+import { ElementPaint, StackingContext } from '../stacking-context';
+export type RenderConfigurations = RenderOptions & {
+    backgroundColor: Color | null;
+    fontConfig: FontConfig | FontConfig[] | undefined;
+};
+export type pageConfigOptions = {
+    header: {
+        content: string | ((renderer: any, pageNum: string) => void);
+        height: number;
+        contentPosition: 'center' | 'centerLeft' | 'centerRight' | 'centerTop' | 'centerBottom' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom' | [number, number];
+        contentColor: string;
+        contentFontSize: number;
+        padding?: [number, number, number, number];
+    };
+    footer: {
+        content: string | ((renderer: any, pageNum: string) => void);
+        height: number;
+        contentPosition: 'center' | 'centerLeft' | 'centerRight' | 'centerTop' | 'centerBottom' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom' | [number, number];
+        contentColor: string;
+        contentFontSize: number;
+        padding?: [number, number, number, number];
+    };
+};
+export interface RenderOptions {
+    scale: number;
+    canvas?: HTMLCanvasElement;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pdfFileName?: string;
+    encryption?: EncryptionOptions | undefined;
+    precision?: number;
+    floatPrecision?: number | 'smart';
+    compress?: boolean;
+    putOnlyUsedFonts?: boolean;
+    pagination?: boolean;
+    format?: 'a0' | 'a1' | 'a2' | 'a3' | 'a4' | 'a5' | 'a6' | 'a7' | 'a8' | 'a9' | 'a10' | 'b0' | 'b1' | 'b2' | 'b3' | 'b4' | 'b5' | 'b6' | 'b7' | 'b8' | 'b9' | 'b10' | 'c0' | 'c1' | 'c2' | 'c3' | 'c4' | 'c5' | 'c6' | 'c7' | 'c8' | 'c9' | 'c10' | 'dl' | 'letter' | 'government-letter' | 'legal' | 'junior-legal' | 'ledger' | 'tabloid' | 'credit-card' | [number, number];
+    pageConfig?: pageConfigOptions;
+}
+export declare class JsPdfContext2d {
+}
+export interface JsPdfContext2d extends Context2d {
+    getLineDash(): number[];
+    setLineDash(segments: number[]): void;
+}
+export declare class CanvasRenderer extends Renderer {
+    canvas: HTMLCanvasElement;
+    readonly jspdfCtx: jsPDF;
+    readonly context2dCtx: JsPdfContext2d;
+    private readonly _activeEffects;
+    private readonly fontMetrics;
+    private readonly pxToPt;
+    private totalPages;
+    constructor(context: Context, options: RenderConfigurations);
+    addFontToJsPDF(): void;
+    resetJsPDFFont(): void;
+    setTextFont(styles: CSSParsedDeclaration): string;
+    applyEffects(effects: IElementEffect[]): void;
+    applyEffect(effect: IElementEffect): void;
+    popEffect(): void;
+    renderStack(stack: StackingContext): Promise<void>;
+    renderNode(paint: ElementPaint): Promise<void>;
+    renderTextWithLetterSpacing(text: TextBounds, letterSpacing: number, baseline: number): void;
+    private createFontStyle;
+    private convertColor;
+    renderTextNode(text: TextContainer, styles: CSSParsedDeclaration): Promise<void>;
+    renderReplacedJsPdfImage(container: ImageElementContainer, image: HTMLImageElement | HTMLCanvasElement): void;
+    renderReplacedJsPdfSvg(container: SVGElementContainer, image: HTMLImageElement | HTMLCanvasElement): void;
+    renderReplacedJsPdfCanvasImage(container: CanvasElementContainer): void;
+    renderNodeContent(paint: ElementPaint): Promise<void>;
+    renderStackContent(stack: StackingContext): Promise<void>;
+    mask(paths: Path[]): void;
+    path(paths: Path[], ctx2d?: Context2d | CanvasRenderingContext2D): void;
+    formatPath(paths: Path[], ctx2d?: Context2d | CanvasRenderingContext2D): void;
+    renderRepeat(boxs: Bounds, ctx: CanvasRenderingContext2D, path: Path[], pattern: CanvasPattern | CanvasGradient): void;
+    resizeImage(image: HTMLImageElement, width: number, height: number): HTMLCanvasElement | HTMLImageElement;
+    renderBackgroundImage(container: ElementContainer): Promise<void>;
+    renderSolidBorder(color: Color, side: number, curvePoints: BoundCurves): Promise<void>;
+    renderDoubleBorder(color: Color, width: number, side: number, curvePoints: BoundCurves): Promise<void>;
+    renderNodeBackgroundAndBorders(paint: ElementPaint): Promise<void>;
+    renderDashedDottedBorder(color: Color, width: number, side: number, curvePoints: BoundCurves, style: BORDER_STYLE): Promise<void>;
+    addPage(offsetY: number): Promise<void>;
+    renderPage(element: ElementContainer, pageNum: number): Promise<void>;
+    setTotalPages(total: number): void;
+    private setTextColorFromString;
+    private safe;
+    private textPdf;
+    private computeContentPosition;
+    private addImagePdf;
+    output(): Promise<Blob>;
+}

package/dist/types/render/effects.d.ts

@@ -0,0 +1,38 @@
+import { Matrix } from '../css/property-descriptors/transform';
+import { Path } from './path';
+export declare const enum EffectType {
+    TRANSFORM = 0,
+    CLIP = 1,
+    OPACITY = 2
+}
+export declare const enum EffectTarget {
+    BACKGROUND_BORDERS = 2,
+    CONTENT = 4
+}
+export interface IElementEffect {
+    readonly type: EffectType;
+    readonly target: number;
+}
+export declare class TransformEffect implements IElementEffect {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly matrix: Matrix;
+    readonly type: EffectType;
+    readonly target: number;
+    constructor(offsetX: number, offsetY: number, matrix: Matrix);
+}
+export declare class ClipEffect implements IElementEffect {
+    readonly path: Path[];
+    readonly target: EffectTarget;
+    readonly type: EffectType;
+    constructor(path: Path[], target: EffectTarget);
+}
+export declare class OpacityEffect implements IElementEffect {
+    readonly opacity: number;
+    readonly type: EffectType;
+    readonly target: number;
+    constructor(opacity: number);
+}
+export declare const isTransformEffect: (effect: IElementEffect) => effect is TransformEffect;
+export declare const isClipEffect: (effect: IElementEffect) => effect is ClipEffect;
+export declare const isOpacityEffect: (effect: IElementEffect) => effect is OpacityEffect;

package/dist/types/render/font-metrics.d.ts

@@ -0,0 +1,11 @@
+export interface FontMetric {
+    baseline: number;
+    middle: number;
+}
+export declare class FontMetrics {
+    private readonly _data;
+    private readonly _document;
+    constructor(document: Document);
+    private parseMetrics;
+    getMetrics(fontFamily: string, fontSize: string): FontMetric;
+}

package/dist/types/render/page-format-map.d.ts

@@ -0,0 +1,4 @@
+export declare const PAGE_FORMAT_MAP: Record<string, {
+    width: number;
+    height: number;
+}>;

package/dist/types/render/paginate copy 2.d.ts

@@ -0,0 +1,3 @@
+import type { ElementContainer } from '../dom/element-container';
+import { pageConfigOptions } from './canvas/pdf-renderer';
+export declare const paginateNode: (root: ElementContainer, pageHeight: number, initialOffset?: number, totalHeight?: number, pageConfig?: pageConfigOptions) => ElementContainer[];

package/dist/types/render/paginate.d.ts

@@ -0,0 +1,3 @@
+import type { ElementContainer } from '../dom/element-container';
+import { pageConfigOptions } from './canvas/pdf-renderer';
+export declare const paginateNode: (root: ElementContainer, pageHeight: number, initialOffset?: number, totalHeight?: number, pageConfig?: pageConfigOptions) => ElementContainer[];

package/dist/types/render/path.d.ts

@@ -0,0 +1,13 @@
+import { BezierCurve } from './bezier-curve';
+import { Vector } from './vector';
+export declare const enum PathType {
+    VECTOR = 0,
+    BEZIER_CURVE = 1
+}
+export interface IPath {
+    type: PathType;
+    add(deltaX: number, deltaY: number): IPath;
+}
+export declare const equalPath: (a: Path[], b: Path[]) => boolean;
+export declare const transformPath: (path: Path[], deltaX: number, deltaY: number, deltaW: number, deltaH: number) => Path[];
+export type Path = Vector | BezierCurve;

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

@@ -0,0 +1,7 @@
+import { Context } from '../core/context';
+import { RenderConfigurations } from './canvas/pdf-renderer';
+export declare class Renderer {
+    protected readonly context: Context;
+    protected readonly options: RenderConfigurations;
+    constructor(context: Context, options: RenderConfigurations);
+}

package/dist/types/render/stacking-context.d.ts

@@ -0,0 +1,24 @@
+import { ElementContainer } from '../dom/element-container';
+import { BoundCurves } from './bound-curves';
+import { EffectTarget, IElementEffect } from './effects';
+export declare class StackingContext {
+    element: ElementPaint;
+    negativeZIndex: StackingContext[];
+    zeroOrAutoZIndexOrTransformedOrOpacity: StackingContext[];
+    positiveZIndex: StackingContext[];
+    nonPositionedFloats: StackingContext[];
+    nonPositionedInlineLevel: StackingContext[];
+    inlineLevel: ElementPaint[];
+    nonInlineLevel: ElementPaint[];
+    constructor(container: ElementPaint);
+}
+export declare class ElementPaint {
+    readonly container: ElementContainer;
+    readonly parent: ElementPaint | null;
+    readonly effects: IElementEffect[];
+    readonly curves: BoundCurves;
+    listValue?: string;
+    constructor(container: ElementContainer, parent: ElementPaint | null);
+    getEffects(target: EffectTarget): IElementEffect[];
+}
+export declare const parseStackingContexts: (container: ElementContainer) => StackingContext;

package/dist/types/render/vector.d.ts

@@ -0,0 +1,9 @@
+import { IPath, Path, PathType } from './path';
+export declare class Vector implements IPath {
+    type: PathType;
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    add(deltaX: number, deltaY: number): Vector;
+}
+export declare const isVector: (path: Path) => path is Vector;

package/dist/types/utils/css-utils.d.ts

@@ -0,0 +1,2 @@
+import { BACKGROUND_REPEAT } from '../css/property-descriptors/background-repeat';
+export declare function getBackgroundRepeat(value: BACKGROUND_REPEAT): string;

package/dist/types/utils/element-utils.d.ts

@@ -0,0 +1,7 @@
+import type { ElementContainer } from '../dom/element-container';
+/**
+ * Recursively traverse the nodes and check whether the textNodes of all levels are empty arrays
+ * @param {ElementContainer} node
+ * @returns {boolean} - If all textNodes are empty, return true; otherwise, return false
+ */
+export declare function checkAllTextNodesEmpty(node: ElementContainer): boolean;

package/dist/types/utils/font-utils.d.ts

@@ -0,0 +1,9 @@
+export interface FontConfig {
+    fontFamily: string;
+    fontBase64: string;
+    fontStyle: string;
+    fontWeight: 400 | 700;
+    iconFont?: boolean;
+}
+export declare function validateFontConfig(fontConfig: FontConfig | FontConfig[] | undefined): boolean;
+export declare function setOptionFontConfig(rawConfig: FontConfig | FontConfig[] | undefined): FontConfig[] | undefined;

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

@@ -0,0 +1,5 @@
+export * from './css-utils';
+export * from './element-utils';
+export * from './font-utils';
+export * from './type-utils';
+export * from './url-path';

package/dist/types/utils/type-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isEmptyValue(obj: unknown): boolean;
+export declare function isArray(obj: unknown): obj is Array<unknown>;
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isFunction(fn: unknown): fn is (...args: unknown[]) => unknown;

package/dist/types/utils/url-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 判断图片路径是否为指定类型的图片
+ * @param {string} path 图片路径/URL（如 "../tests/assets/image.svg"、"https://xxx.com/photo.webp"）
+ * @param {("svg" | "webp" | "png" | "jpg" | "gif" | "unknown")} type 要判断的图片类型
+ * @returns {boolean} 是否为指定类型的图片
+ */
+export declare function getImageTypeByPath(path: string, type: 'svg' | 'webp' | 'png' | 'jpg' | 'gif' | 'unknown'): boolean;

package/dist/utils/font-utils.d.ts

@@ -3,5 +3,7 @@ export interface FontConfig {
     fontBase64: string;
     fontStyle: string;
     fontWeight: 400 | 700;
+    iconFont?: boolean;
 }
 export declare function validateFontConfig(fontConfig: FontConfig | FontConfig[] | undefined): boolean;
+export declare function setOptionFontConfig(rawConfig: FontConfig | FontConfig[] | undefined): FontConfig[] | undefined;

package/fontconverter/fontconverter.html

@@ -56,8 +56,8 @@
       var fontName = document.getElementById('fontName').value;
       var fontStyle = document.getElementById('fontStyle').value;
       var createdFileName = fontName + '-' + fontStyle + '.ttf';
-      jsFile += 'var ' + fontName + ' = \'' + window.loadedFileContents + '\';\n';
-      jsFile += 'window.fontBase64 = ' + fontName + ';\n';
+      jsFile += 'window. ' + fontName + ' = \'' + window.loadedFileContents + '\';\n';
+      // jsFile += 'window.' + fontBase64 + ' = ' + fontName + ';\n';
 
       var newJsfile = new File([jsFile], fontName + '-' + fontStyle + '.js', { type: 'text/plain;charset=utf-8' });
       saveAs(newJsfile);