@jasy/pdf 1.0.0-alpha.1

package/dist/utils/flex-layout.d.ts

@@ -0,0 +1,53 @@
+import { PDFElement, LayoutContext } from "../elements/pdf-element";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+/** Distribution of the children ALONG the stacking (main) axis when there is leftover
+ *  space and no flex child to absorb it. */
+export type MainAlign = "start" | "center" | "end" | "between" | "around";
+/** Position/size of each child ACROSS the cross axis. `stretch` fills the cross extent;
+ *  the others place the child at its natural cross size. */
+export type CrossAlign = "start" | "center" | "end" | "stretch";
+/**
+ * Maps the abstract MAIN/CROSS axes onto concrete width/height + x/y, so one flex
+ * algorithm drives both a vertical Column (main = height) and a horizontal Row
+ * (main = width). "main" is the stacking direction; "cross" is perpendicular.
+ */
+export interface FlexAxis {
+    mainOf(size: Size): number;
+    crossOf(size: Size): number;
+    /**
+     * Constraints for a fixed child: the main extent is unbounded (it takes its natural
+     * size); the cross extent is ALWAYS capped to what the line offers. The cap is a hard
+     * ceiling regardless of `cross` alignment - it is what guarantees nothing ever overflows
+     * (a paragraph wraps at the column width instead of running one line off the page). A
+     * child smaller than the cap keeps its size and is positioned by `crossOffset`; a child
+     * that wants to fill (Container, Text) fills the cap. So `stretch` vs `start/center/end`
+     * differ only in where a smaller child sits, never in the ceiling.
+     */
+    measureConstraints(crossAvail: number): BoxConstraints;
+    /** Constraints for a flex child (fills the cross axis like a stretched child). */
+    flexConstraints(mainExtent: number, crossAvail: number): BoxConstraints;
+    /** Absolute offset for a child at main position `mainPos`, cross position `crossPos`. */
+    offsetAt(mainPos: number, crossPos: number): Offset;
+}
+export declare const VERTICAL_AXIS: FlexAxis;
+export declare const HORIZONTAL_AXIS: FlexAxis;
+export interface FlexOptions {
+    gap?: number;
+    main?: MainAlign;
+    cross?: CrossAlign;
+}
+export declare class FlexLayoutHelper {
+    /**
+     * Lays out a flex line along `axis`, IN SOURCE ORDER, and places every child.
+     * Fixed children take their natural main extent; flex (`ExpandedElement`) children
+     * split the leftover main space by their `flex`. `gap` is inserted between children.
+     * `main` distributes any leftover when there is no flex child; `cross` positions/sizes
+     * each child across the line. Returns the total main extent consumed and the cross
+     * extent occupied. Vertical with `gap 0`, `main start`, `cross stretch` reproduces the
+     * previous Column layout exactly.
+     */
+    static layout(children: PDFElement[], axis: FlexAxis, mainAvail: number, crossAvail: number, mainStart: number, crossOrigin: number, options: FlexOptions, ctx: LayoutContext): {
+        mainUsed: number;
+        crossUsed: number;
+    };
+}

package/dist/utils/flex-layout.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexLayoutHelper = exports.HORIZONTAL_AXIS = exports.VERTICAL_AXIS = void 0;
+const pdf_element_1 = require("../elements/pdf-element");
+const box_constraints_1 = require("../layout/box-constraints");
+exports.VERTICAL_AXIS = {
+    mainOf: (s) => s.height,
+    crossOf: (s) => s.width,
+    measureConstraints: (crossAvail) => box_constraints_1.BoxConstraints.loose(crossAvail, Infinity),
+    flexConstraints: (mainExtent, crossAvail) => box_constraints_1.BoxConstraints.loose(crossAvail, mainExtent),
+    offsetAt: (mainPos, crossPos) => ({ x: crossPos, y: mainPos }),
+};
+exports.HORIZONTAL_AXIS = {
+    mainOf: (s) => s.width,
+    crossOf: (s) => s.height,
+    measureConstraints: (crossAvail) => box_constraints_1.BoxConstraints.loose(Infinity, crossAvail),
+    flexConstraints: (mainExtent, crossAvail) => box_constraints_1.BoxConstraints.loose(mainExtent, crossAvail),
+    offsetAt: (mainPos, crossPos) => ({ x: mainPos, y: crossPos }),
+};
+/** Cross-axis offset of a child of size `childCross` within `crossExtent`. */
+function crossOffset(align, crossExtent, childCross) {
+    if (align === "center")
+        return Math.max(0, (crossExtent - childCross) / 2);
+    if (align === "end")
+        return Math.max(0, crossExtent - childCross);
+    return 0; // start, stretch (stretch fills, so no offset)
+}
+class FlexLayoutHelper {
+    /**
+     * Lays out a flex line along `axis`, IN SOURCE ORDER, and places every child.
+     * Fixed children take their natural main extent; flex (`ExpandedElement`) children
+     * split the leftover main space by their `flex`. `gap` is inserted between children.
+     * `main` distributes any leftover when there is no flex child; `cross` positions/sizes
+     * each child across the line. Returns the total main extent consumed and the cross
+     * extent occupied. Vertical with `gap 0`, `main start`, `cross stretch` reproduces the
+     * previous Column layout exactly.
+     */
+    static layout(children, axis, mainAvail, crossAvail, mainStart, crossOrigin, options, ctx) {
+        var _a, _b, _c;
+        const gap = (_a = options.gap) !== null && _a !== void 0 ? _a : 0;
+        const main = (_b = options.main) !== null && _b !== void 0 ? _b : "start";
+        const cross = (_c = options.cross) !== null && _c !== void 0 ? _c : "stretch";
+        const count = children.length;
+        // Pass 1: measure the fixed children (main extent + cross size) and total the flex.
+        let fixedMain = 0;
+        let totalFlex = 0;
+        let crossUsed = 0;
+        const fixedSize = new Map();
+        for (const child of children) {
+            if (child instanceof pdf_element_1.FlexiblePDFElement) {
+                totalFlex += child.getFlex();
+            }
+            else {
+                const size = child.calculateLayout(axis.measureConstraints(crossAvail), axis.offsetAt(mainStart, crossOrigin), ctx);
+                fixedMain += axis.mainOf(size);
+                crossUsed = Math.max(crossUsed, axis.crossOf(size));
+                fixedSize.set(child, size);
+            }
+        }
+        const totalGap = Math.max(0, count - 1) * gap;
+        const leftover = mainAvail - fixedMain - totalGap;
+        const remaining = Math.max(leftover, 0); // for flex children
+        // Main-axis distribution only kicks in with no flex child and bounded, positive space.
+        let leadingSpace = 0;
+        let betweenSpace = gap;
+        if (totalFlex === 0 && mainAvail !== Infinity && leftover > 0) {
+            if (main === "center")
+                leadingSpace = leftover / 2;
+            else if (main === "end")
+                leadingSpace = leftover;
+            else if (main === "between" && count > 1)
+                betweenSpace = gap + leftover / (count - 1);
+            else if (main === "around") {
+                const unit = leftover / count;
+                leadingSpace = unit / 2;
+                betweenSpace = gap + unit;
+            }
+        }
+        // Measure flex children too (at their main share) so a tall/wrapping flex cell counts
+        // toward the line's cross extent - they're placed in pass 2, but crossExtent needs them now.
+        if (totalFlex > 0) {
+            for (const child of children) {
+                if (child instanceof pdf_element_1.FlexiblePDFElement) {
+                    const mainExtent = (child.getFlex() / totalFlex) * remaining;
+                    const size = child.calculateLayout(axis.flexConstraints(mainExtent, crossAvail), axis.offsetAt(mainStart, crossOrigin), ctx);
+                    crossUsed = Math.max(crossUsed, axis.crossOf(size));
+                }
+            }
+        }
+        // The cross extent children align within: the bounded line size, else the tallest child.
+        const crossExtent = crossAvail !== Infinity ? crossAvail : crossUsed;
+        // `stretch` caps a child's cross to `crossExtent` (not `crossAvail`) so siblings end up
+        // equal across the axis. Bounded lines have crossExtent == crossAvail (byte-identical);
+        // only an unbounded line (a shrink-wrap Row) now equalises instead of staying natural.
+        const stretch = cross === "stretch";
+        // Pass 2: place each child at the running main position, offset across by `cross`.
+        let mainPos = mainStart + leadingSpace;
+        let placedCross = 0;
+        children.forEach((child, index) => {
+            let mainExtent;
+            if (child instanceof pdf_element_1.FlexiblePDFElement) {
+                mainExtent = (child.getFlex() / totalFlex) * remaining;
+                const size = child.calculateLayout(axis.flexConstraints(mainExtent, stretch ? crossExtent : crossAvail), axis.offsetAt(mainPos, crossOrigin), ctx);
+                placedCross = Math.max(placedCross, axis.crossOf(size));
+            }
+            else {
+                const childCross = axis.crossOf(fixedSize.get(child));
+                const size = child.calculateLayout(axis.measureConstraints(stretch ? crossExtent : crossAvail), axis.offsetAt(mainPos, crossOrigin + crossOffset(cross, crossExtent, childCross)), ctx);
+                mainExtent = axis.mainOf(size);
+                placedCross = Math.max(placedCross, axis.crossOf(size));
+            }
+            mainPos += mainExtent;
+            if (index < count - 1)
+                mainPos += betweenSpace;
+        });
+        return { mainUsed: mainPos - mainStart, crossUsed: placedCross };
+    }
+}
+exports.FlexLayoutHelper = FlexLayoutHelper;

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

@@ -0,0 +1,12 @@
+import type { FontStyle } from "./pdf-object-manager";
+/**
+ * Read-only font measurement - the slice of the object manager that the layout pass
+ * needs. Keeping layout (and, later, fragmentation) behind this interface means those
+ * passes depend only on metrics, never on the PDF byte writer. `PDFObjectManager`
+ * implements it today; a standalone metrics service can replace it later without
+ * touching layout code.
+ */
+export interface FontMetrics {
+    getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle): number;
+    getCharWidth(char: string, fontSize: number, fullFontName?: string, fontName?: string, fontStyle?: FontStyle): number;
+}

package/dist/utils/font-metrics.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export declare function getFontPath(fontName: string): string;

package/dist/utils/font-path.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFontPath = getFontPath;
+const os = require("os");
+const path = require("path");
+function getFontPath(fontName) {
+    const platform = os.platform();
+    let fontPath = "";
+    if (platform === "win32") {
+        fontPath = path.join("C:\\Windows\\Fonts", fontName);
+    }
+    else if (platform === "darwin") {
+        fontPath = path.join("/Library/Fonts", fontName);
+    }
+    else if (platform === "linux") {
+        fontPath = path.join("/usr/share/fonts", fontName);
+    }
+    return fontPath;
+}

package/dist/utils/image-helper.d.ts

@@ -0,0 +1,43 @@
+declare global {
+    interface DataView {
+        getUint24(byteOffset: number, littleEndian?: boolean): number;
+    }
+}
+interface ImageDimensions {
+    width: number;
+    height: number;
+}
+export declare function getImageDimensions(buffer: Buffer): Promise<ImageDimensions>;
+/**
+ * Converts the given image to grayscale and returns its binary data.
+ * @param imagePath Path to the input image file.
+ * @returns Promise that resolves with the binary data of the grayscale image.
+ */
+/**
+ * Decodes a PNG into raw DeviceRGB samples, Flate-compressed, ready to embed as a PDF
+ * image XObject. A PNG file is NOT a valid `/FlateDecode` stream (it's a signature plus
+ * chunks of filtered, zlib-compressed scanlines), so it must be decoded first. PDF has
+ * no alpha channel for DeviceRGB, so transparent pixels are composited over white.
+ */
+export declare function decodePngToRgbFlate(pngBuffer: Buffer): Promise<{
+    data: string;
+    width: number;
+    height: number;
+}>;
+export declare function convertImageToGrayscaleBuffer(imagePath: string): Promise<Buffer>;
+export interface FitResult {
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+}
+export declare function applyContainFit(imageWidth: number, imageHeight: number, containerWidth: number, containerHeight: number): FitResult;
+export declare function applyCoverFit(imageWidth: number, imageHeight: number, containerWidth: number, containerHeight: number): FitResult;
+export declare function applyFillFit(containerWidth: number, containerHeight: number): FitResult;
+export declare function applyFitNone(imageWidth: number, imageHeight: number, containerWidth: number, containerHeight: number): {
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+};
+export {};

package/dist/utils/image-helper.js

@@ -0,0 +1,206 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImageDimensions = getImageDimensions;
+exports.decodePngToRgbFlate = decodePngToRgbFlate;
+exports.convertImageToGrayscaleBuffer = convertImageToGrayscaleBuffer;
+exports.applyContainFit = applyContainFit;
+exports.applyCoverFit = applyCoverFit;
+exports.applyFillFit = applyFillFit;
+exports.applyFitNone = applyFitNone;
+const jimp_1 = require("jimp");
+const zlib_1 = require("zlib");
+// Implement the method to handle 24-bit integers
+DataView.prototype.getUint24 = function (byteOffset, littleEndian = false) {
+    const b1 = this.getUint8(byteOffset);
+    const b2 = this.getUint8(byteOffset + 1);
+    const b3 = this.getUint8(byteOffset + 2);
+    return littleEndian ? (b3 << 16) | (b2 << 8) | b1 : (b1 << 16) | (b2 << 8) | b3;
+};
+function getImageDimensions(buffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dataView = new DataView(buffer.buffer);
+        // Check for JPEG (0xFFD8 is the start of JPEG file)
+        if (dataView.getUint16(0) === 0xffd8) {
+            let offset = 2;
+            while (offset < buffer.byteLength) {
+                const marker = dataView.getUint16(offset, false);
+                offset += 2;
+                if (marker === 0xffc0 || marker === 0xffc2) {
+                    // SOF0 or SOF2
+                    return {
+                        height: dataView.getUint16(offset + 3, false),
+                        width: dataView.getUint16(offset + 5, false),
+                    };
+                }
+                else {
+                    offset += dataView.getUint16(offset, false);
+                }
+            }
+        }
+        // Check for PNG (0x89504E47 is the PNG signature)
+        if (dataView.getUint32(0) === 0x89504e47) {
+            return {
+                width: dataView.getUint32(16, false),
+                height: dataView.getUint32(20, false),
+            };
+        }
+        // Check for BMP (0x424D is the BMP signature)
+        if (dataView.getUint16(0) === 0x424d) {
+            return {
+                width: dataView.getUint32(18, true),
+                height: dataView.getUint32(22, true),
+            };
+        }
+        // Check for WebP (0x52494646 is the WebP signature 'RIFF')
+        if (dataView.getUint32(0) === 0x52494646 && dataView.getUint32(8) === 0x57454250) {
+            // 'WEBP'
+            if (dataView.getUint32(12) === 0x56503820) {
+                // 'VP8 '
+                return {
+                    width: dataView.getUint16(26, true),
+                    height: dataView.getUint16(28, true),
+                };
+            }
+            else if (dataView.getUint32(12) === 0x56503858) {
+                // 'VP8X'
+                return {
+                    width: dataView.getUint24(24, true) + 1,
+                    height: dataView.getUint24(27, true) + 1,
+                };
+            }
+        }
+        throw new Error("Unsupported image format");
+    });
+}
+/**
+ * Converts the given image to grayscale and returns its binary data.
+ * @param imagePath Path to the input image file.
+ * @returns Promise that resolves with the binary data of the grayscale image.
+ */
+/**
+ * Decodes a PNG into raw DeviceRGB samples, Flate-compressed, ready to embed as a PDF
+ * image XObject. A PNG file is NOT a valid `/FlateDecode` stream (it's a signature plus
+ * chunks of filtered, zlib-compressed scanlines), so it must be decoded first. PDF has
+ * no alpha channel for DeviceRGB, so transparent pixels are composited over white.
+ */
+function decodePngToRgbFlate(pngBuffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const image = yield jimp_1.Jimp.fromBuffer(pngBuffer);
+        const { width, height, data: rgba } = image.bitmap;
+        const rgb = Buffer.allocUnsafe(width * height * 3);
+        for (let i = 0, j = 0; i < rgba.length; i += 4, j += 3) {
+            const alpha = rgba[i + 3] / 255;
+            rgb[j] = Math.round(rgba[i] * alpha + 255 * (1 - alpha));
+            rgb[j + 1] = Math.round(rgba[i + 1] * alpha + 255 * (1 - alpha));
+            rgb[j + 2] = Math.round(rgba[i + 2] * alpha + 255 * (1 - alpha));
+        }
+        // Compress so the existing `/Filter /FlateDecode` XObject path embeds it correctly.
+        return { data: (0, zlib_1.deflateSync)(rgb).toString("binary"), width, height };
+    });
+}
+function convertImageToGrayscaleBuffer(imagePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // We get the image from the buffer
+        const image = yield jimp_1.Jimp.read(imagePath);
+        // Get MIME type. If emtpy throw error
+        const mime = image.mime;
+        if (!mime)
+            throw new Error("Cannot read MIME type");
+        // We need to check the MIME type (the exact union `getBuffer` accepts).
+        let mimeType;
+        switch (mime) {
+            case jimp_1.JimpMime.png:
+            case jimp_1.JimpMime.jpeg:
+            case jimp_1.JimpMime.bmp:
+                mimeType = mime;
+                break;
+            default:
+                throw new Error("Unsupported MIME type");
+        }
+        image.greyscale();
+        // Convert the image back to buffer with current MIME type
+        const grayscaleBuffer = yield image.getBuffer(mimeType);
+        return grayscaleBuffer;
+    });
+}
+function applyContainFit(imageWidth, imageHeight, containerWidth, containerHeight) {
+    const imageAspectRatio = imageWidth / imageHeight;
+    const containerAspectRatio = containerWidth / containerHeight;
+    let width, height, offsetX, offsetY;
+    if (imageAspectRatio > containerAspectRatio) {
+        // The images width is bigger than the containers width
+        const scaleFactor = containerWidth / imageWidth;
+        width = containerWidth;
+        height = imageHeight * scaleFactor;
+        offsetX = 0;
+        offsetY = (containerHeight - height) / 2; // Center vertically
+    }
+    else {
+        // THe images height is bigge rthan the containers height
+        const scaleFactor = containerHeight / imageHeight;
+        width = imageWidth * scaleFactor;
+        height = containerHeight;
+        offsetX = (containerWidth - width) / 2; // Center horizontally
+        offsetY = 0;
+    }
+    return {
+        width,
+        height,
+        offsetX,
+        offsetY,
+    };
+}
+function applyCoverFit(imageWidth, imageHeight, containerWidth, containerHeight) {
+    const imageAspectRatio = imageWidth / imageHeight;
+    const containerAspectRatio = containerWidth / containerHeight;
+    let width, height, offsetX, offsetY;
+    if (imageAspectRatio > containerAspectRatio) {
+        // The images width is bigger than containers width
+        const scaleFactor = containerHeight / imageHeight;
+        width = imageWidth * scaleFactor;
+        height = containerHeight;
+        offsetX = (containerWidth - width) / 2; // Center horizontally
+        offsetY = 0;
+    }
+    else {
+        // The images height is bigger than containers height
+        const scaleFactor = containerWidth / imageWidth;
+        width = containerWidth;
+        height = imageHeight * scaleFactor;
+        offsetX = 0;
+        offsetY = (containerHeight - height) / 2; // Center vertically
+    }
+    return {
+        width,
+        height,
+        offsetX,
+        offsetY,
+    };
+}
+function applyFillFit(containerWidth, containerHeight) {
+    return {
+        width: containerWidth,
+        height: containerHeight,
+        offsetX: 0,
+        offsetY: 0,
+    };
+}
+function applyFitNone(imageWidth, imageHeight, containerWidth, containerHeight) {
+    const offsetX = (containerWidth - imageWidth) / 2; // Center horizontally
+    const offsetY = (containerHeight - imageHeight) / 2; // Center vertically
+    return {
+        width: imageWidth, // Hold orignal image size
+        height: imageHeight,
+        offsetX: offsetX > 0 ? offsetX : 0, // Dont move outside the container...
+        offsetY: offsetY > 0 ? offsetY : 0,
+    };
+}

package/dist/utils/pdf-object-manager.d.ts

@@ -0,0 +1,97 @@
+import type { PDFConfig } from "../renderer/pdf-document-class";
+import type { FontMetrics } from "./font-metrics";
+interface FontIndexes {
+    fontIndex: number;
+    resourceIndex: number;
+    fontStyle: FontStyle;
+    fullName: string;
+}
+export declare enum FontStyle {
+    Normal = "normal",
+    Bold = "bold",
+    Italic = "italic",
+    BoldItalic = "boldItalic"
+}
+export declare class PDFObjectManager implements FontMetrics {
+    private objects;
+    private objectPositions;
+    private parentObjectNumber;
+    private fonts;
+    private images;
+    private extGStates;
+    private pdfConfig;
+    pageFormat: [number, number];
+    private afmParsers;
+    private customFonts;
+    private customFontEmit;
+    private attachments;
+    private xmpMetadata?;
+    private outputIntent?;
+    private pdfVersion;
+    private documentId;
+    private compress;
+    constructor();
+    addObject(content: string): number;
+    replaceObject(objectNumber: number, content: string): void;
+    setCompress(on: boolean): void;
+    private stream;
+    addContentStream(content: string): number;
+    changePDFConfig(config: PDFConfig): void;
+    getPDFConfig(): PDFConfig;
+    private fillConfigWithStandardValues;
+    private getCurrentByteLength;
+    setParentObjectNumber(number: number): void;
+    getParentObjectNumber(): number;
+    registerImage(width: number, height: number, imageType: string, imageData: string): number;
+    attachFile(name: string, data: Buffer, opts?: {
+        relationship?: string;
+        mimeType?: string;
+        description?: string;
+    }): void;
+    getAttachments(): {
+        name: string;
+        filespec: number;
+    }[];
+    setXmpMetadata(xml: string): void;
+    getXmpMetadata(): string | undefined;
+    setOutputIntent(icc: Buffer, opts?: {
+        identifier?: string;
+        info?: string;
+    }): void;
+    getOutputIntent(): number | undefined;
+    setPdfVersion(version: string): void;
+    getPdfVersion(): string;
+    getHeader(): string;
+    enableDocumentId(): void;
+    registerExtGState(fillAlpha: number, strokeAlpha: number): string;
+    getAllExtGStatesRaw(): Map<string, number>;
+    registerFont(fontName: string, fontStyle?: FontStyle, fullName?: string): FontIndexes;
+    registerCustomFont(name: string, data: Buffer, style?: FontStyle): void;
+    private ensureEmitted;
+    finalizeCustomFonts(): void;
+    private subsetTag;
+    private customKey;
+    private resolveCustomStyle;
+    private getCustomFont;
+    isCustomFont(name?: string, style?: FontStyle): boolean;
+    getCustomFontResource(name: string, style?: FontStyle): FontIndexes | undefined;
+    encodeCustomText(name: string, text: string, style?: FontStyle): string;
+    private buildFontFile2;
+    private buildFontDescriptor;
+    private buildCIDFont;
+    private buildToUnicode;
+    private buildType0;
+    getStringWidth(text: string, fontFamily: string, fontSize: number, fontStyle: FontStyle): number;
+    private getCharCode;
+    private getAVMParserByFont;
+    getCharWidth(char: string, fontSize: number, fullFontName?: string, fontName?: string, fontStyle?: FontStyle): number;
+    private getKerning;
+    getAllFontsRaw(): Map<string, FontIndexes>;
+    getAllImagesRaw(): Map<string, number>;
+    getRenderedObjects(): string;
+    getXRefTable(): string;
+    getTrailerAndXRef(startxref: number): string;
+    private contentId;
+    getObjectCount(): number;
+}
+export {};