@pdfme/pdf-lib 0.0.0

package/dist/types/src/types/fontkit.d.ts

@@ -0,0 +1,597 @@
+/**
+ * Represents a glyph bounding box
+ */
+export interface BoundingBox {
+    minX: number /** The minimum X position in the bounding box */;
+    minY: number /** The minimum Y position in the bounding box */;
+    maxX: number /** The maxmimum X position in the bounding box */;
+    maxY: number /** The maxmimum Y position in the bounding box */;
+    width: number /** The width of the bounding box */;
+    height: number /** The height of the bounding box */;
+}
+/**
+ * Path objects are returned by glyphs and represent the actual vector outlines
+ * for each glyph in the font. Paths can be converted to SVG path data strings,
+ * or to functions that can be applied to render the path to a graphics context.
+ */
+export interface Path {
+    /**
+     * This property represents the path’s bounding box, i.e. the smallest
+     * rectangle that contains the entire path shape. This is the exact
+     * bounding box, taking into account control points that may be outside the
+     * visible shape.
+     */
+    bbox: BoundingBox;
+    /**
+     * This property represents the path’s control box. It is like the
+     * bounding box, but it includes all points of the path, including control
+     * points of bezier segments. It is much faster to compute than the real
+     * bounding box, but less accurate if there are control points outside of the
+     * visible shape.
+     */
+    cbox: BoundingBox;
+    /**
+     * Moves the virtual pen to the given x, y coordinates.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Adds a line to the path from the current point to the
+     * given x, y coordinates.
+     */
+    lineTo(x: number, y: number): void;
+    /**
+     * Adds a quadratic curve to the path from the current point to the
+     * given x, y coordinates using cpx, cpy as a control point.
+     */
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    /**
+     * Adds a bezier curve to the path from the current point to the
+     * given x, y coordinates using cp1x, cp1y and cp2x, cp2y as control points.
+     */
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    /**
+     * Closes the current sub-path by drawing a straight line back to the
+     * starting point.
+     */
+    closePath(): void;
+    /**
+     * Compiles the path to a JavaScript function that can be applied with a
+     * graphics context in order to render the path.
+     */
+    toFunction(): Function;
+    /**
+     * Converts the path to an SVG path data string.
+     */
+    toSVG(): string;
+}
+/**
+ * Glyph objects represent a glyph in the font. They have various properties for
+ * accessing metrics and the actual vector path the glyph represents, and
+ * methods for rendering the glyph to a graphics context.
+ *
+ * You do not create glyph objects directly. They are created by various methods
+ * on the Font object. There are several subclasses of the base Glyph class
+ * internally that may be returned depending on the font format, but they all
+ * include the following API.
+ */
+export interface Glyph {
+    id: number /** The glyph's id in the font */;
+    /**
+     * An array of unicode code points that are represented by this glyph. There
+     * can be multiple code points in the case of ligatures and other glyphs that
+     * represent multiple visual characters.
+     */
+    codePoints: number[];
+    path: Path /** Vector Path object representing the glyph */;
+    /**
+     * The Glyph’s bounding box, i.e. the rectangle that encloses the glyph
+     * outline as tightly as possible.
+     */
+    bbox: BoundingBox;
+    /**
+     * The Glyph’s control box. This is often the same as the bounding box, but is
+     * faster to compute. Because of the way bezier curves are defined, some of
+     * the control points can be outside of the bounding box. Where bbox takes
+     * this into account, cbox does not. Thus, cbox is less accurate, but faster
+     * to compute.
+     */
+    cbox: BoundingBox;
+    advanceWidth: number /** The Glyph's advance width */;
+    /**
+     * For COLR glyphs, which are vector based, this returns an array of objects
+     * representing the glyphs and colors for each layer in render order.
+     */
+    layers: any[];
+    /**
+     * Renders the glyph to the given graphics context, at the specified
+     * font size.
+     */
+    render(context: any, size: number): void;
+    /**
+     * For SBIX glyphs, which are bitmap based, this returns an object containing
+     * some properties about the image, along with the image data itself
+     * (usually PNG).
+     */
+    getImageForSize(size: number): Uint8Array;
+}
+/**
+ * Represents positioning information for a glyph in a GlyphRun.
+ */
+export interface GlyphPosition {
+    /**
+     * The amount to move the virtual pen in the X direction after rendering
+     * this glyph.
+     */
+    xAdvance: number;
+    /**
+     * The amount to move the virtual pen in the Y direction after rendering
+     * this glyph.
+     */
+    yAdvance: number;
+    /**
+     * The offset from the pen position in the X direction at which to render
+     * this glyph.
+     */
+    xOffset: number;
+    /**
+     * The offset from the pen position in the Y direction at which to render
+     * this glyph.
+     */
+    yOffset: number;
+}
+/**
+ * Represents a run of Glyph and GlyphPosition objects.
+ * Returned by the Font.layout method.
+ */
+export interface GlyphRun {
+    /**
+     * An array of Glyph objects in the run
+     */
+    glyphs: Glyph[];
+    /**
+     * An array of GlyphPosition objects for each glyph in the run
+     */
+    positions: GlyphPosition[];
+    /**
+     * The script that was requested for shaping. This was either passed in or detected automatically.
+     */
+    script: string;
+    /**
+     * The language requested for shaping, as passed in. If `null`, the default language for the
+     * script was used.
+     */
+    language: string | null;
+    /**
+     * The direction requested for shaping, as passed in (either ltr or rtl).
+     * If `null`, the default direction of the script is used.
+     */
+    direction: 'ltr' | 'rtl' | null;
+    /**
+     * The features requested during shaping. This is a combination of user
+     * specified features and features chosen by the shaper.
+     */
+    features: object;
+    /**
+     * The total advance width of the run.
+     */
+    advanceWidth: number;
+    /**
+     * The total advance height of the run.
+     */
+    advanceHeight: number;
+    /**
+     * The bounding box containing all glyphs in the run.
+     */
+    bbox: BoundingBox;
+}
+export interface SubsetStream {
+    on: (eventType: 'data' | 'end', callback: (data: Uint8Array) => any) => SubsetStream;
+}
+export type Subset = {
+    /**
+     * Includes the given glyph object or glyph ID in the subset.
+     * Returns the glyph's new ID in the subset.
+     */
+    includeGlyph(glyph: number | Glyph): number;
+} & (SubsetV1 | SubsetV2);
+/**
+ * Compatible with https://github.com/foliojs/fontkit (v1.x)
+ */
+interface SubsetV1 {
+    /**
+     * Returns a stream containing the encoded font file that can be piped to a
+     * destination, such as a file.
+     */
+    encodeStream(): SubsetStream;
+}
+/**
+ * Compatible with https://github.com/foliojs/fontkit (v2.x)
+ */
+interface SubsetV2 {
+    /**
+     * Returns a unit8array containing the encoded font file that can be piped to a
+     * destination, such as a file.
+     */
+    encode(): Uint8Array;
+}
+/**
+ * A map of OpenType features as described in OpenType's spec:
+ * https://docs.microsoft.com/en-gb/typography/opentype/spec/featurelist.
+ */
+export interface OpenTypeFeatures {
+    aalt?: boolean;
+    abvf?: boolean;
+    abvm?: boolean;
+    abvs?: boolean;
+    afrc?: boolean;
+    akhn?: boolean;
+    blwf?: boolean;
+    blwm?: boolean;
+    blws?: boolean;
+    calt?: boolean;
+    case?: boolean;
+    ccmp?: boolean;
+    cfar?: boolean;
+    cjct?: boolean;
+    clig?: boolean;
+    cpct?: boolean;
+    cpsp?: boolean;
+    cswh?: boolean;
+    curs?: boolean;
+    cv01?: boolean;
+    cv02?: boolean;
+    cv03?: boolean;
+    cv04?: boolean;
+    cv05?: boolean;
+    cv06?: boolean;
+    cv07?: boolean;
+    cv08?: boolean;
+    cv09?: boolean;
+    cv10?: boolean;
+    cv11?: boolean;
+    cv22?: boolean;
+    cv23?: boolean;
+    cv24?: boolean;
+    cv25?: boolean;
+    cv26?: boolean;
+    cv27?: boolean;
+    cv28?: boolean;
+    cv29?: boolean;
+    cv30?: boolean;
+    cv31?: boolean;
+    cv32?: boolean;
+    cv33?: boolean;
+    cv34?: boolean;
+    cv35?: boolean;
+    cv36?: boolean;
+    cv37?: boolean;
+    cv38?: boolean;
+    cv39?: boolean;
+    cv40?: boolean;
+    cv41?: boolean;
+    cv42?: boolean;
+    cv43?: boolean;
+    cv44?: boolean;
+    cv45?: boolean;
+    cv46?: boolean;
+    cv47?: boolean;
+    cv48?: boolean;
+    cv49?: boolean;
+    cv50?: boolean;
+    cv51?: boolean;
+    cv52?: boolean;
+    cv53?: boolean;
+    cv54?: boolean;
+    cv55?: boolean;
+    cv56?: boolean;
+    cv57?: boolean;
+    cv58?: boolean;
+    cv59?: boolean;
+    cv60?: boolean;
+    cv61?: boolean;
+    cv62?: boolean;
+    cv63?: boolean;
+    cv64?: boolean;
+    cv65?: boolean;
+    cv66?: boolean;
+    cv67?: boolean;
+    cv68?: boolean;
+    cv69?: boolean;
+    cv70?: boolean;
+    cv71?: boolean;
+    cv72?: boolean;
+    cv73?: boolean;
+    cv74?: boolean;
+    cv75?: boolean;
+    cv76?: boolean;
+    cv77?: boolean;
+    cv78?: boolean;
+    cv79?: boolean;
+    cv80?: boolean;
+    cv81?: boolean;
+    cv82?: boolean;
+    cv83?: boolean;
+    cv84?: boolean;
+    cv85?: boolean;
+    cv86?: boolean;
+    cv87?: boolean;
+    cv88?: boolean;
+    cv89?: boolean;
+    cv90?: boolean;
+    cv91?: boolean;
+    cv92?: boolean;
+    cv93?: boolean;
+    cv94?: boolean;
+    cv95?: boolean;
+    cv96?: boolean;
+    cv97?: boolean;
+    cv98?: boolean;
+    cv99?: boolean;
+    c2pc?: boolean;
+    c2sc?: boolean;
+    dist?: boolean;
+    dlig?: boolean;
+    dnom?: boolean;
+    dtls?: boolean;
+    expt?: boolean;
+    falt?: boolean;
+    fin2?: boolean;
+    fin3?: boolean;
+    fina?: boolean;
+    flac?: boolean;
+    frac?: boolean;
+    fwid?: boolean;
+    half?: boolean;
+    haln?: boolean;
+    halt?: boolean;
+    hist?: boolean;
+    hkna?: boolean;
+    hlig?: boolean;
+    hngl?: boolean;
+    hojo?: boolean;
+    hwid?: boolean;
+    init?: boolean;
+    isol?: boolean;
+    ital?: boolean;
+    jalt?: boolean;
+    jp78?: boolean;
+    jp83?: boolean;
+    jp90?: boolean;
+    jp04?: boolean;
+    kern?: boolean;
+    lfbd?: boolean;
+    liga?: boolean;
+    ljmo?: boolean;
+    lnum?: boolean;
+    locl?: boolean;
+    ltra?: boolean;
+    ltrm?: boolean;
+    mark?: boolean;
+    med2?: boolean;
+    medi?: boolean;
+    mgrk?: boolean;
+    mkmk?: boolean;
+    mset?: boolean;
+    nalt?: boolean;
+    nlck?: boolean;
+    nukt?: boolean;
+    numr?: boolean;
+    onum?: boolean;
+    opbd?: boolean;
+    ordn?: boolean;
+    ornm?: boolean;
+    palt?: boolean;
+    pcap?: boolean;
+    pkna?: boolean;
+    pnum?: boolean;
+    pref?: boolean;
+    pres?: boolean;
+    pstf?: boolean;
+    psts?: boolean;
+    pwid?: boolean;
+    qwid?: boolean;
+    rand?: boolean;
+    rclt?: boolean;
+    rkrf?: boolean;
+    rlig?: boolean;
+    rphf?: boolean;
+    rtbd?: boolean;
+    rtla?: boolean;
+    rtlm?: boolean;
+    ruby?: boolean;
+    rvrn?: boolean;
+    salt?: boolean;
+    sinf?: boolean;
+    size?: boolean;
+    smcp?: boolean;
+    smpl?: boolean;
+    ss01?: boolean;
+    ss02?: boolean;
+    ss03?: boolean;
+    ss04?: boolean;
+    ss05?: boolean;
+    ss06?: boolean;
+    ss07?: boolean;
+    ss08?: boolean;
+    ss09?: boolean;
+    ss10?: boolean;
+    ss11?: boolean;
+    ss12?: boolean;
+    ss13?: boolean;
+    ss14?: boolean;
+    ss15?: boolean;
+    ss16?: boolean;
+    ss17?: boolean;
+    ss18?: boolean;
+    ss19?: boolean;
+    ss20?: boolean;
+    ssty?: boolean;
+    stch?: boolean;
+    subs?: boolean;
+    sups?: boolean;
+    swsh?: boolean;
+    titl?: boolean;
+    tjmo?: boolean;
+    tnam?: boolean;
+    tnum?: boolean;
+    trad?: boolean;
+    twid?: boolean;
+    unic?: boolean;
+    valt?: boolean;
+    vatu?: boolean;
+    vert?: boolean;
+    vhal?: boolean;
+    vjmo?: boolean;
+    vkna?: boolean;
+    vkrn?: boolean;
+    vpal?: boolean;
+    vrt2?: boolean;
+    vrtr?: boolean;
+    zero?: boolean;
+}
+/**
+ * A map of Apple Advanced Typography (AAT) as decribed by Apple’s TrueType
+ * Reference manual:
+ * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html
+ */
+export interface AATFeatures {
+    acnt?: boolean;
+    ankr?: boolean;
+    avar?: boolean;
+    bdat?: boolean;
+    bhed?: boolean;
+    bloc?: boolean;
+    bsln?: boolean;
+    cmap?: boolean;
+    cvar?: boolean;
+    cvt?: boolean;
+    EBSC?: boolean;
+    fdsc?: boolean;
+    feat?: boolean;
+    fmtx?: boolean;
+    fond?: boolean;
+    fpgm?: boolean;
+    fvar?: boolean;
+    gasp?: boolean;
+    gcid?: boolean;
+    glyf?: boolean;
+    gvar?: boolean;
+    hdmx?: boolean;
+    head?: boolean;
+    hhea?: boolean;
+    hmtx?: boolean;
+    just?: boolean;
+    kern?: boolean;
+    kerx?: boolean;
+    lcar?: boolean;
+    loca?: boolean;
+    ltag?: boolean;
+    maxp?: boolean;
+    meta?: boolean;
+    mort?: boolean;
+    morx?: boolean;
+    name?: boolean;
+    opbd?: boolean;
+    'OS/2'?: boolean;
+    post?: boolean;
+    prep?: boolean;
+    prop?: boolean;
+    sbix?: boolean;
+    trak?: boolean;
+    vhea?: boolean;
+    vmtx?: boolean;
+    xref?: boolean;
+    Zapf?: boolean;
+}
+/**
+ * The features is an object mapping OpenType features to a boolean
+ * enabling or disabling each. If this is an AAT font,
+ * the OpenType feature tags are mapped to AAT features.
+ */
+export interface TypeFeatures extends OpenTypeFeatures, AATFeatures {
+    [key: string]: boolean | undefined;
+}
+/**
+ * There are several different types of font objects that are returned by
+ * fontkit depending on the font format. They all inherit from the TTFFont class
+ * and have the same public API.
+ */
+export interface Font {
+    postscriptName: string | null;
+    fullName: string | null;
+    familyName: string | null;
+    subfamilyName: string | null;
+    copyright: string | null;
+    version: string | null;
+    unitsPerEm: number /** Size of the font’s internal coordinate grid */;
+    ascent: number /** The font’s ascender */;
+    descent: number /** The font’s descender */;
+    lineGap: number /** Amount of space that should be included between lines */;
+    underlinePosition: number /** Offset from the normal underline position that should be used */;
+    underlineThickness: number /** Weight of the underline that should be used */;
+    italicAngle: number /** If this is an italic font, the angle the cursor should be drawn at to match the font design */;
+    capHeight: number /** Height of capital letters above the baseline. */;
+    xHeight: number /** Height of lower case letters. */;
+    bbox: BoundingBox /** Font’s bounding box, i.e. the box that encloses all glyphs in the font */;
+    numGlyphs: number /** Number of glyphs in the font */;
+    characterSet: number[] /** Array of all of the unicode code points supported by the font */;
+    availableFeatures: (keyof TypeFeatures)[] /** Array of all OpenType feature tags (or mapped AAT tags) supported by the font */;
+    cff: any;
+    'OS/2': {
+        sFamilyClass: number;
+    };
+    head: {
+        macStyle: {
+            italic: boolean;
+        };
+    };
+    post: {
+        isFixedPitch: boolean;
+    };
+    /**
+     * Maps a single unicode code point (number) to a Glyph object.
+     * Does not perform any advanced substitutions (there is no context to do so).
+     */
+    glyphForCodePoint(codePoint: number): Glyph;
+    /**
+     * Returns whether there is glyph in the font for the given
+     * unicode code point.
+     */
+    hasGlyphForCodePoint(codePoint: number): boolean;
+    /**
+     * This method returns an array of Glyph objects for the given string.
+     * This is only a one-to-one mapping from characters to glyphs. For most uses,
+     * you should use Font.layout, which provides a much more advanced mapping
+     * supporting AAT and OpenType shaping.
+     */
+    glyphsForString(str: string): Glyph[];
+    /**
+     * Returns the advance width (described above) for a single glyph id.
+     */
+    widthOfGlyph(glyphId: number): number;
+    /**
+     * This method returns a GlyphRun object, which includes an array of Glyphs
+     * and GlyphPositions for the given string. Glyph objects are described below.
+     * GlyphPosition objects include 4 properties: xAdvance, yAdvance, xOffset,
+     * and yOffset.
+     *
+     * The features parameter is an array of OpenType feature tags to be applied
+     * in addition to the default set. If this is an AAT font, the OpenType
+     * feature tags are mapped to AAT features.
+     */
+    layout(str: string, features?: TypeFeatures | (keyof TypeFeatures)[]): GlyphRun;
+    /**
+     * Returns a glyph object for the given glyph id. You can pass the array of
+     * code points this glyph represents for your use later, and it will be
+     * stored in the glyph object.
+     */
+    getGlyph(glyphId: number, codePoints?: number[]): Glyph;
+    /**
+     * Returns a Subset object for this font.
+     */
+    createSubset(): Subset;
+}
+export interface Fontkit {
+    create(buffer: Uint8Array, postscriptName?: string): Font;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import Arc from '../utils/elements/Arc';
+import Circle from '../utils/elements/Circle';
+import Ellipse from '../utils/elements/Ellipse';
+import Line from '../utils/elements/Line';
+import Plot from '../utils/elements/Plot';
+import Point from '../utils/elements/Point';
+import Rectangle from '../utils/elements/Rectangle';
+import Segment from '../utils/elements/Segment';
+export type { TransformationMatrix } from './matrix';
+export type Size = {
+    width: number;
+    height: number;
+};
+export type Coordinates = {
+    x: number;
+    y: number;
+};
+export type GraphicElement = Arc | Circle | Ellipse | Line | Plot | Point | Rectangle | Segment;
+export type Space = {
+    topLeft: Coordinates;
+    topRight: Coordinates;
+    bottomRight: Coordinates;
+    bottomLeft: Coordinates;
+};
+export type LinkElement = Rectangle | Ellipse;

package/dist/types/src/types/matrix.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A transformation matrix according to section `8.3.3 Common Transformations`
+ * of the PDF specification (page 117).
+ *
+ * To cite from the spec:
+ *
+ *   * Translations shall be specified as `[1 0 0 1 tx ty]`, where `tx` and
+ *     `ty` shall be the distances to translate the origin of the coordinate
+ *     system in the horizontal and vertical dimensions, respectively.
+ *   * Scaling shall be obtained by `[sx 0 0 sy 0 0]`. This scales the
+ *     coordinates so that 1 unit in the horizontal and vertical dimensions of
+ *     the new coordinate system is the same size as `sx` and `sy` units,
+ *     respectively, in the previous coordinate system.
+ *   * Rotations shall be produced by `[cos(q) sin(q) -sin(q) cos(q) 0 0]`,
+ *     which has the effect of rotating the coordinate system axes by an angle
+ *     `q` counter clockwise.
+ *   * Skew shall be specified by `[1 tan(a) tan(b) 1 0 0]`, which skews the
+ *     x-axis by an angle `a` and the y axis by an angle `b`.
+ */
+export type TransformationMatrix = [number, number, number, number, number, number];
+export declare const identityMatrix: TransformationMatrix;

package/dist/types/src/utils/Cache.d.ts

@@ -0,0 +1,10 @@
+declare class Cache<T> {
+    static readonly populatedBy: <T_1>(populate: () => T_1) => Cache<T_1>;
+    private readonly populate;
+    private value;
+    private constructor();
+    getValue(): T | undefined;
+    access(): T;
+    invalidate(): void;
+}
+export default Cache;

package/dist/types/src/utils/arrays.d.ts

@@ -0,0 +1,16 @@
+export declare const last: <T>(array: T[]) => T;
+export declare const typedArrayFor: (value: string | Uint8Array) => Uint8Array;
+export declare const mergeIntoTypedArray: (...arrays: (string | Uint8Array)[]) => Uint8Array<ArrayBuffer>;
+export declare const mergeUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
+export declare const arrayAsString: (array: Uint8Array | number[]) => string;
+export declare const byAscendingId: <T extends {
+    id: any;
+}>(a: T, b: T) => number;
+export declare const sortedUniq: <T>(array: T[], indexer: (elem: T) => any) => T[];
+export declare const isArrayEqual: <T>(arr1: ArrayLike<T>, arr2: ArrayLike<T>) => boolean;
+export declare const reverseArray: (array: Uint8Array) => Uint8Array<ArrayBufferLike>;
+export declare const sum: (array: number[] | Uint8Array) => number;
+export declare const range: (start: number, end: number) => number[];
+export declare const pluckIndices: <T>(arr: T[], indices: number[]) => T[];
+export declare const canBeConvertedToUint8Array: (input: any) => input is string | ArrayBuffer | Uint8Array;
+export declare const toUint8Array: (input: string | ArrayBuffer | Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/types/src/utils/async.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a Promise that resolves after at least one tick of the
+ * Macro Task Queue occurs.
+ */
+export declare const waitForTick: () => Promise<void>;

package/dist/types/src/utils/base64.d.ts

@@ -0,0 +1,10 @@
+export declare const encodeToBase64: (bytes: Uint8Array) => string;
+export declare const decodeFromBase64: (base64: string) => Uint8Array;
+/**
+ * If the `dataUri` input is a data URI, then the data URI prefix must not be
+ * longer than 100 characters, or this function will fail to decode it.
+ *
+ * @param dataUri a base64 data URI or plain base64 string
+ * @returns a Uint8Array containing the decoded input
+ */
+export declare const decodeFromBase64DataUri: (dataUri: string) => Uint8Array;