@jasy/pdf 1.0.0-alpha.1 → 1.0.0-alpha.10

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

@@ -1,5 +1,16 @@
-import type { PDFConfig } from "../renderer/pdf-document-class";
-import type { FontMetrics } from "./font-metrics";
+import type { OverflowPolicy } from "../layout/fragmentation.js";
+import { TTFParser } from "./ttf-parser.js";
+import { type ShapedGlyph } from "../text/shape.js";
+import type { SecurityHandler } from "../crypto/security-handler.js";
+import type { Gradient } from "../ir/display-list.js";
+import type { FontVerticals } from "../text/line-metrics.js";
+import type { FontDecoration } from "../text/text-decoration.js";
+import { StructTree } from "./struct-tree.js";
+import { OutlineBuilder } from "./outline.js";
+import { DestRegistry } from "./dest-registry.js";
+import { AcroFormCollector } from "../forms/acroform.js";
+import type { PDFConfig } from "../renderer/pdf-document-class.js";
+import type { FontMetrics } from "./font-metrics.js";
 interface FontIndexes {
     fontIndex: number;
     resourceIndex: number;
@@ -19,31 +30,69 @@ export declare class PDFObjectManager implements FontMetrics {
     private fonts;
     private images;
     private extGStates;
+    private shadings;
+    private emojiFontName?;
+    private emojiImage?;
     private pdfConfig;
     pageFormat: [number, number];
     private afmParsers;
     private customFonts;
+    private verticalsCache;
+    private decorationCache;
     private customFontEmit;
+    private shapeCache;
+    private shapedOrigins;
     private attachments;
     private xmpMetadata?;
     private outputIntent?;
     private pdfVersion;
     private documentId;
     private compress;
+    private overflowPolicy;
+    private security?;
+    private encJobs;
+    private strJobs;
+    private encryptObjNum?;
+    private _struct;
+    get struct(): StructTree;
+    private _outline;
+    get outline(): OutlineBuilder;
+    private _dests;
+    get dests(): DestRegistry;
+    private _acroform;
+    get acroform(): AcroFormCollector;
     constructor();
     addObject(content: string): number;
     replaceObject(objectNumber: number, content: string): void;
     setCompress(on: boolean): void;
+    setOverflowPolicy(policy: OverflowPolicy): void;
+    getOverflowPolicy(): OverflowPolicy;
+    private encToken;
+    private strToken;
+    /**
+     * The single choke-point every literal string in an OBJECT goes through - a field's `/T` and `/V`, a
+     * bookmark `/Title`, a link `/URI`, an `/Alt` text, a destination name.
+     *
+     * Without a security handler this is the escaped literal we have always written, so output stays
+     * byte-identical. With one, the raw bytes are registered for the finalize pass and a placeholder takes
+     * their place: ISO 32000-1 7.6.2 requires ALL strings and streams to be encrypted, and the ones missed
+     * here were exactly the values a password is supposed to protect (ISSUE-7).
+     *
+     * A string INSIDE a content stream needs none of this - the stream is enciphered as a whole.
+     */
+    pdfString(text: string): string;
+    private streamPayload;
     private stream;
     addContentStream(content: string): number;
+    addFormXObject(bbox: string, content: string, resources?: 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?: {
+    registerImage(width: number, height: number, imageType: string, imageData: string, smaskData?: string): number;
+    attachFile(name: string, data: Uint8Array, opts?: {
         relationship?: string;
         mimeType?: string;
         description?: string;
@@ -54,7 +103,7 @@ export declare class PDFObjectManager implements FontMetrics {
     }[];
     setXmpMetadata(xml: string): void;
     getXmpMetadata(): string | undefined;
-    setOutputIntent(icc: Buffer, opts?: {
+    setOutputIntent(icc: Uint8Array, opts?: {
         identifier?: string;
         info?: string;
     }): void;
@@ -63,10 +112,15 @@ export declare class PDFObjectManager implements FontMetrics {
     getPdfVersion(): string;
     getHeader(): string;
     enableDocumentId(): void;
+    setSecurityHandler(handler: SecurityHandler): void;
+    finalizeEncryption(): Promise<void>;
     registerExtGState(fillAlpha: number, strokeAlpha: number): string;
     getAllExtGStatesRaw(): Map<string, number>;
+    registerShading(g: Gradient): string;
+    private buildShadingFunction;
+    getAllShadingsRaw(): Map<string, number>;
     registerFont(fontName: string, fontStyle?: FontStyle, fullName?: string): FontIndexes;
-    registerCustomFont(name: string, data: Buffer, style?: FontStyle): void;
+    registerCustomFont(name: string, data: Uint8Array, style?: FontStyle): void;
     private ensureEmitted;
     finalizeCustomFonts(): void;
     private subsetTag;
@@ -74,18 +128,66 @@ export declare class PDFObjectManager implements FontMetrics {
     private resolveCustomStyle;
     private getCustomFont;
     isCustomFont(name?: string, style?: FontStyle): boolean;
+    getColorFont(name: string, style?: FontStyle): TTFParser | undefined;
+    setEmojiFont(name: string): void;
+    getEmojiFont(): string | undefined;
+    setEmojiImageSource(url: string, format: string): void;
+    getEmojiImageSource(): {
+        url: string;
+        format: string;
+    } | undefined;
+    /**
+     * Whether a family can draw this code point at all. An embedded face answers from its `cmap`; a
+     * standard-14 one can only draw what Windows-1252 encodes, which is what its `/Widths` array covers.
+     * Used to pick a family out of a fallback stack, per code point.
+     */
+    hasGlyph(codePoint: number, fontFamily: string, fontStyle?: FontStyle): boolean;
+    private colorRenders;
     getCustomFontResource(name: string, style?: FontStyle): FontIndexes | undefined;
+    /** How many glyphs a run draws - its code-point count unless a ligature merged some. `letterSpacing`
+     *  is per glyph (`Tc`), so this is what it multiplies. */
+    shapedGlyphCount(text: string, fontFamily?: string, fontStyle?: FontStyle): number | undefined;
+    /**
+     * The shaped glyphs of a run, or undefined when nothing needed shaping. The ONE place shaping is
+     * decided, so measuring and drawing cannot disagree. Memoised: a paragraph is measured several
+     * times (layout, pagination, drawing).
+     */
+    shapeText(text: string, fontFamily?: string, fontStyle?: FontStyle): ShapedGlyph[] | undefined;
+    /** Hex Identity-H for glyphs the producer already resolved (a shaped run), which cannot be given as
+     *  text. Recording each keeps it in the subset. */
+    registerGlyphs(name: string, glyphs: readonly number[], style?: FontStyle): string;
     encodeCustomText(name: string, text: string, style?: FontStyle): string;
     private buildFontFile2;
     private buildFontDescriptor;
     private buildCIDFont;
     private buildToUnicode;
     private buildType0;
+    getFontVerticals(fontFamily: string, fontStyle: FontStyle): FontVerticals;
+    getFontDecoration(fontFamily: string, fontStyle: FontStyle): FontDecoration;
+    kerningEnabled: boolean;
+    setKerning(enabled: boolean): void;
+    /**
+     * The kerning adjustment for each adjacent code-point pair of `text`, in em/1000 (the sign the
+     * font declares: negative tightens). Length is `codePointCount - 1`. Zero at any pair next to a
+     * space - letters are never kerned against a space, which also keeps a per-word measure equal to a
+     * whole-line one (the space pairs contribute nothing either way).
+     *
+     * Standard-14 answers from the AFM `KPX` pairs. An embedded font has no kerning yet (its `kern` /
+     * `GPOS` tables are unparsed), so it returns zeros - never a wrong value, just no adjustment.
+     */
+    getKernPairs(text: string, fontFamily: string, fontStyle: FontStyle): number[];
+    /**
+     * Where the glyphs of `text` put ink inside a horizontal band, as x-intervals in POINTS measured
+     * from the start of the run. This is what an underline steps around ("skip-ink").
+     *
+     * `bandTop` / `bandBottom` are in points relative to the baseline, y UP (so both negative under
+     * it). Only an EMBEDDED font can answer: the standard-14 outlines live in the viewer, not here.
+     * Callers must check `isCustomFont` first rather than treat an empty result as "no descenders".
+     */
+    getInkSpansInBand(text: string, fontSize: number, fontFamily: string, fontStyle: FontStyle, bandTop: number, bandBottom: number, letterSpacing?: number): Array<[number, number]>;
     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;