html2pdf-accessible 0.0.0-stage → 0.1.5

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { DimensionToken, NumberValueToken } from "../syntax/tokenizer";
+import { CSSValue } from "../syntax/parser";
+export type LengthPercentage = DimensionToken | NumberValueToken;
+export type LengthPercentageTuple = [LengthPercentage] | [LengthPercentage, LengthPercentage];
+export declare const isLengthPercentage: (token: CSSValue) => token is LengthPercentage;
+export declare const parseLengthPercentageTuple: (tokens: LengthPercentage[]) => LengthPercentageTuple;
+export declare const ZERO_LENGTH: NumberValueToken;
+export declare const FIFTY_PERCENT: NumberValueToken;
+export declare const HUNDRED_PERCENT: NumberValueToken;
+export declare const getAbsoluteValueForTuple: (tuple: LengthPercentageTuple, width: number, height: number) => [number, number];
+export declare const getAbsoluteValue: (token: LengthPercentage, parent: number) => number;

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

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

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

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

package/lib/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/lib/types/dom/element-container.d.ts

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

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

@@ -0,0 +1,25 @@
+import { ElementContainer } from "./element-container";
+import { Context } from "../core/context";
+import { Color } from "../css/types/color";
+export declare const parseTree: (context: Context, element: HTMLElement) => 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;
+export declare const parseBackgroundColor: (context: Context, element: HTMLElement, backgroundColorOverride?: string | null) => Color;

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

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

package/lib/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/lib/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/lib/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/lib/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/lib/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/lib/types/fonts/font-collection.d.ts

@@ -0,0 +1,25 @@
+import { CanvasKit, Font, Typeface, TypefaceFontProvider } from "@html2pdf-skia/canvaskit-pdf";
+import { FontFamilyClass, FontStylePojo, IFontCollection, IFontProperties, IFontStyle, UnicodeCharacterBucket } from "./interfaces";
+export declare class SkiaFontCollection implements IFontCollection {
+    canvasKit: CanvasKit;
+    fontMgr: TypefaceFontProvider;
+    private defaultFonts;
+    private fallbackFonts;
+    private families;
+    private fonts;
+    private fontsCache;
+    readonly emptyFont: Font;
+    constructor(canvasKit: CanvasKit);
+    addFont(buffer: ArrayBuffer, family: string, fontStyle?: IFontStyle, url?: string, descriptors?: FontFaceDescriptors): void;
+    setDefaultFonts(fontFamilyClass: FontFamilyClass, families: string[]): void;
+    getFontData(families: string[], weight: number): ArrayBuffer | undefined;
+    setFallbackFonts(unicodeCharacterBucket: UnicodeCharacterBucket, families: string[]): void;
+    getMissingFonts(element: HTMLElement): IFontProperties[];
+    getMissingGlyphsCategories(element: HTMLElement): UnicodeCharacterBucket[];
+    getFallbackFontTypeface(text: string, fontStyle: FontStylePojo): Typeface | null;
+    getFallbackFontFamilies(familyClasses: FontFamilyClass[]): string[];
+    addFontsToDocument(cloneDocument: Document): Promise<void>;
+    getFont(typeface: Typeface, fontSize: number): Font;
+    clearResources(): void;
+}
+export declare function createFontCollection(canvasKit: CanvasKit): IFontCollection;

package/lib/types/fonts/font-enumeration.d.ts

@@ -0,0 +1,5 @@
+import { FontMgr } from "@html2pdf-skia/canvaskit-pdf";
+import { IFontProperties, UnicodeCharacterBucket } from "./interfaces";
+export declare function enumerateFonts(elements: HTMLElement[]): IFontProperties[];
+export declare function enumerateMissingGlyphs(fontMgr: FontMgr, elements: HTMLElement[]): UnicodeCharacterBucket[];
+export declare function getUnicodeCharacterBucket(text: string): UnicodeCharacterBucket;

package/lib/types/fonts/font-style-mapping.d.ts

@@ -0,0 +1,3 @@
+import { IFontProperties, FontSlant, FontStylePojo } from "./interfaces";
+export declare function toSkiaFontSlant(slant: FontSlant): number;
+export declare function toSkiaFontStyle(fontStyle: IFontProperties): [string[], FontStylePojo];

package/lib/types/fonts/interfaces.d.ts

@@ -0,0 +1,27 @@
+export type FontWidth = "normal" | "narrow" | "wide";
+export type FontSlant = "normal" | "italic" | "oblique";
+export type FontFamilyClass = "serif" | "sans-serif" | "monospace" | "cursive" | "fantasy" | "fangsong";
+export type UnicodeCharacterBucket = "cjk" | "emoji" | "symbol" | "unicode";
+export interface IFontStyle {
+    fontWeight?: number;
+    fontWidth?: FontWidth;
+    fontSlant?: FontSlant;
+}
+export type IFontProperties = IFontStyle & {
+    families: string[];
+};
+export type FontFamilyKey = FontFamilyClass | UnicodeCharacterBucket;
+export interface IFontCollection {
+    getFontData?(families: string[], weight: number): ArrayBuffer | undefined;
+    addFont(buffer: ArrayBuffer, family: string, fontStyle?: IFontStyle, url?: string, descriptors?: FontFaceDescriptors): void;
+    setDefaultFonts(fontFamilyClass: FontFamilyClass, families: string[]): void;
+    setFallbackFonts(unicodeCharacterBucket: UnicodeCharacterBucket, families: string[]): void;
+    getMissingFonts(element: HTMLElement): IFontProperties[];
+    getMissingGlyphsCategories(element: HTMLElement, fontStyle: IFontStyle): string[];
+    clearResources(): void;
+}
+export interface FontStylePojo {
+    weight?: number;
+    width?: number;
+    slant?: number;
+}

package/lib/types/html2canvas.d.ts

@@ -0,0 +1,10 @@
+import { CloneOptions, WindowOptions } from "./dom/document-cloner";
+import { RenderOptions } from "./render/canvas/canvas-renderer";
+import { ContextOptions } from "./core/context";
+export type Options = CloneOptions & WindowOptions & RenderOptions & ContextOptions & {
+    backgroundColor: string | null;
+    foreignObjectRendering: boolean;
+    removeContainer?: boolean;
+};
+declare const html2canvas: (element: HTMLElement, options?: Partial<Options>) => Promise<HTMLCanvasElement>;
+export default html2canvas;

package/lib/types/index.d.ts

@@ -0,0 +1,7 @@
+export { exportHTMLDocumentToPdf } from "./pdf/single-html-multi-page";
+export type { ExportPdfOptions } from "./pdf/single-html-multi-page";
+export { loadCanvasKit, preloadCanvasKit } from "./pdf/canvaskit-loader";
+export type { CanvasKitLoadOptions } from "./pdf/canvaskit-loader";
+export { isCanvasKitLoaded, getCanvasKitInstance, } from "./pdf/canvaskit-loader";
+export * from "./fonts/interfaces";
+export { createFontCollection } from "./fonts/font-collection";

package/lib/types/invariant.d.ts

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

package/lib/types/pdf/bookmarks.d.ts

@@ -0,0 +1,4 @@
+import { PDFDocument } from "pdf-lib";
+import { PDFStructureTag } from "./document-structure";
+/** Follow the heading hierarchy and use the renderer's actual page positions. */
+export declare function addBookmarks(pdf: PDFDocument, headings: PDFStructureTag[]): void;

package/lib/types/pdf/canvaskit-loader.d.ts

@@ -0,0 +1,56 @@
+import { CanvasKit } from "@html2pdf-skia/canvaskit-pdf";
+/**
+ * Configuration options for CanvasKit loading
+ */
+export interface CanvasKitLoadOptions {
+    /**
+     * Custom WASM binary URL. If not provided, uses the bundled WASM file.
+     */
+    wasmBinaryUrl: string;
+    /**
+     * Timeout in milliseconds for loading CanvasKit (default: 30000)
+     */
+    timeout?: number;
+    /**
+     * Whether to log loading progress
+     */
+    verbose?: boolean;
+}
+/**
+ * Loads CanvasKit WASM module and returns the CanvasKit instance
+ *
+ * @param options - Configuration options for loading CanvasKit
+ * @returns Promise that resolves to the CanvasKit instance
+ */
+export declare const loadCanvasKit: (options: CanvasKitLoadOptions) => Promise<CanvasKit>;
+/**
+ * Checks if CanvasKit is already loaded
+ *
+ * @returns True if CanvasKit is loaded, false otherwise
+ */
+export declare const isCanvasKitLoaded: () => boolean;
+/**
+ * Gets the cached CanvasKit instance without loading
+ *
+ * @returns The cached CanvasKit instance or null if not loaded
+ */
+export declare const getCanvasKitInstance: () => CanvasKit | null;
+/**
+ * Preloads CanvasKit WASM in the background
+ * This can be called early in the application lifecycle to improve performance
+ *
+ * @param options - Configuration options for loading CanvasKit
+ * @returns Promise that resolves when CanvasKit is loaded
+ */
+export declare const preloadCanvasKit: (options: CanvasKitLoadOptions) => Promise<void>;
+/**
+ * Resets the CanvasKit loader state
+ * This is mainly useful for testing or when you need to reload CanvasKit
+ */
+export declare const resetCanvasKitLoader: () => void;
+/**
+ * Utility function to check if CanvasKit is supported in the current environment
+ *
+ * @returns True if CanvasKit is likely to be supported
+ */
+export declare const isCanvasKitSupported: () => boolean;

package/lib/types/pdf/document-structure.d.ts

@@ -0,0 +1,105 @@
+import { PDFTag } from "@html2pdf-skia/canvaskit-pdf";
+export interface PDFStructureTag extends PDFTag {
+    children?: PDFStructureTag[];
+    elementIdentifier?: string;
+    headerIdentifiers?: string[];
+    bookmarkTitle?: string;
+    linkUri?: string;
+    linkText?: string;
+    linkDestinationIdentifier?: string;
+    linkToPageTop?: boolean;
+    isLinkDestination?: boolean;
+    hiddenCaption?: {
+        text: string;
+        families: string[];
+        weight: number;
+    };
+    renderedBounds?: {
+        pageIndex: number;
+        rect: [number, number, number, number];
+    }[];
+}
+export declare const STRUCTURE_MARKER_OWNER = "html2pdf-skia";
+export declare const STRUCTURE_MARKER_NAME = "NodeId";
+export declare const PREDEFINED_TAG_IDS: {
+    readonly Nothing: 0;
+    readonly OtherArtifact: -1;
+    readonly PaginationArtifact: -2;
+    readonly PaginationHeaderArtifact: -3;
+    readonly PaginationFooterArtifact: -4;
+    readonly PaginationWatermarkArtifact: -5;
+    readonly LayoutArtifact: -6;
+    readonly PageArtifact: -7;
+    readonly BackgroundArtifact: -8;
+};
+export declare const PDF_STRUCTURE_TYPES: {
+    readonly Document: "Document";
+    readonly Part: "Part";
+    readonly Art: "Art";
+    readonly Sect: "Sect";
+    readonly Div: "Div";
+    readonly P: "P";
+    readonly H1: "H1";
+    readonly H2: "H2";
+    readonly H3: "H3";
+    readonly H4: "H4";
+    readonly H5: "H5";
+    readonly H6: "H6";
+    readonly BlockQuote: "BlockQuote";
+    readonly Caption: "Caption";
+    readonly TOC: "TOC";
+    readonly TOCI: "TOCI";
+    readonly Index: "Index";
+    readonly Span: "Span";
+    readonly Quote: "Quote";
+    readonly Note: "Note";
+    readonly Reference: "Reference";
+    readonly BibEntry: "BibEntry";
+    readonly Code: "Code";
+    readonly Link: "Link";
+    readonly Annot: "Annot";
+    readonly L: "L";
+    readonly LI: "LI";
+    readonly Lbl: "Lbl";
+    readonly LBody: "LBody";
+    readonly Table: "Table";
+    readonly TR: "TR";
+    readonly TH: "TH";
+    readonly TD: "TD";
+    readonly THead: "THead";
+    readonly TBody: "TBody";
+    readonly TFoot: "TFoot";
+    readonly Figure: "Figure";
+    readonly Formula: "Formula";
+    readonly Form: "Form";
+    readonly NonStruct: "NonStruct";
+    readonly Artifact: "Artifact";
+};
+export declare const PDF_TAG_ATTRIBUTE = "data-x-pdf-tag-id";
+/**
+ * Generate document structure from HTML tree
+ */
+export declare function generateDocumentStructure(htmlElement: Element | Element[]): {
+    structure: PDFTag;
+    tagIdMap: Map<Element, number>;
+};
+/**
+ * Apply PDF structure to existing HTML document
+ */
+export declare function applyPDFStructureToDocument(document: Document): {
+    structure: PDFTag;
+    tagIdMap: Map<Element, number>;
+};
+/**
+ * Get PDF tag for specific HTML element
+ */
+export declare function getPDFTagForElement(element: Element): number | undefined;
+export declare function getPDFTagForElementFromMap(element: Element, tagIdMap: Map<Element, number>): number | undefined;
+/**
+ * Serialize PDF structure to JSON for debugging
+ */
+export declare function serializePDFStructure(structure: PDFTag): string;
+/**
+ * Validate PDF structure integrity
+ */
+export declare function validatePDFStructure(structure: PDFTag): boolean;

package/lib/types/pdf/dom-updates.d.ts

@@ -0,0 +1,6 @@
+export declare const HIDE_PREVIOUS_PAGE_ITEM_CLASS = "hide-previous-page-item";
+export declare const HIDE_NEXT_PAGE_ITEM_CLASS = "hide-next-page-item";
+export declare function appendPageStyles(document: Document): void;
+export declare function clearPageStyles(document: Document): void;
+export declare function clearHidePreviousPageItems(document: Document): void;
+export declare function clearHideNextPageItems(document: Document): void;

package/lib/types/pdf/finalize-structure.d.ts

@@ -0,0 +1,6 @@
+import { PDFTag } from "@html2pdf-skia/canvaskit-pdf";
+import { IFontCollection } from "../fonts/interfaces";
+/** Bridge the missing ID/Headers operations in Google SkPDF.
+ * Also restore clipped captions as invisible, embedded-font text.
+ */
+export declare function finalizePDFStructure(bytes: Uint8Array, root: PDFTag, fontCollection?: IFontCollection): Promise<Uint8Array>;

package/lib/types/pdf/hidden-captions.d.ts

@@ -0,0 +1,15 @@
+import { PDFDict, PDFDocument, PDFRef } from "pdf-lib";
+import { IFontCollection } from "../fonts/interfaces";
+import { PDFStructureTag } from "./document-structure";
+/** Replace only Skia's empty text object in this caption's existing MCID.
+ * Graphics and text state are isolated so subsequent visible text is unchanged.
+ */
+export declare function fillEmptyCaption(content: string, mcid: number, font: string, encodedText: string, y: number): string;
+/** Keep visually clipped table captions readable, using invisible text (Tr 3).
+ * Reuse the original MCID, structure node and ParentTree entry. Embed the supplied
+ * font with a Unicode map; do not substitute alternate text for an empty node.
+ */
+export declare function restoreHiddenCaptions(pdf: PDFDocument, nodes: Map<number, {
+    node: PDFDict;
+    ref: PDFRef;
+}>, tags: Map<number, PDFStructureTag>, fonts?: IFontCollection): Promise<void>;

package/lib/types/pdf/html-page-break.d.ts

@@ -0,0 +1,11 @@
+export declare class HtmlPageBreak {
+    private document;
+    private pageHeight;
+    private pageItems;
+    constructor(document: Document, pageHeight: number);
+    processPage(): HTMLElement | null;
+    protected shouldTreatAsSingleElement(element: HTMLElement): boolean;
+    protected shouldCheckForOverlap(element: HTMLElement): boolean;
+    protected shouldRepeatOnEveryPage(element: HTMLElement): boolean;
+    postProcess(): void;
+}

package/lib/types/pdf/link-annotations.d.ts

@@ -0,0 +1,8 @@
+import { PDFDict, PDFDocument, PDFRef } from "pdf-lib";
+import { PDFStructureTag } from "./document-structure";
+/** Link text, annotation, OBJR and ParentTree must describe the same action. */
+export declare function addLinkAnnotations(pdf: PDFDocument, tree: PDFDict, links: {
+    tag: PDFStructureTag;
+    node: PDFDict;
+    ref: PDFRef;
+}[], tags: Map<number, PDFStructureTag>): void;

package/lib/types/pdf/link-uri.d.ts

@@ -0,0 +1,2 @@
+/** Only web URLs may be emitted as external PDF URI actions. */
+export declare function safeExternalLinkUri(value: string): string | undefined;

package/lib/types/pdf/logical-structure.d.ts

@@ -0,0 +1,3 @@
+import { PDFDocument } from "pdf-lib";
+/** Repair inline text directly inside grouping elements without changing MCIDs. */
+export declare function normalizeLogicalStructure(pdf: PDFDocument): void;