@pdfme/pdf-lib 1.17.3 → 1.18.3

package/ts3.4/es/core/structures/PDFFlateStream.d.ts

@@ -1,6 +1,6 @@
-import PDFDict from "../objects/PDFDict";
-import PDFStream from "../objects/PDFStream";
-import { Cache } from "../../utils";
+import PDFDict from '../objects/PDFDict';
+import PDFStream from '../objects/PDFStream';
+import { Cache } from '../../utils';
 declare class PDFFlateStream extends PDFStream {
     protected readonly contentsCache: Cache<Uint8Array>;
     protected readonly encode: boolean;

package/ts3.4/es/core/structures/PDFObjectStream.d.ts

@@ -1,7 +1,7 @@
-import PDFObject from "../objects/PDFObject";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFFlateStream from "./PDFFlateStream";
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
 export declare type IndirectObject = [PDFRef, PDFObject];
 declare class PDFObjectStream extends PDFFlateStream {
     static withContextAndObjects: (context: PDFContext, objects: IndirectObject[], encode?: boolean) => PDFObjectStream;

package/ts3.4/es/core/structures/PDFPageLeaf.d.ts

@@ -1,12 +1,12 @@
-import PDFArray from "../objects/PDFArray";
-import PDFDict, { DictMap } from "../objects/PDFDict";
-import PDFName from "../objects/PDFName";
-import PDFNumber from "../objects/PDFNumber";
-import PDFObject from "../objects/PDFObject";
-import PDFRef from "../objects/PDFRef";
-import PDFStream from "../objects/PDFStream";
-import PDFContext from "../PDFContext";
-import PDFPageTree from "./PDFPageTree";
+import PDFArray from '../objects/PDFArray';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFStream from '../objects/PDFStream';
+import PDFContext from '../PDFContext';
+import PDFPageTree from './PDFPageTree';
 declare class PDFPageLeaf extends PDFDict {
     static readonly InheritableEntries: string[];
     static withContextAndParent: (context: PDFContext, parent: PDFRef) => PDFPageLeaf;

package/ts3.4/es/core/structures/PDFPageTree.d.ts

@@ -1,9 +1,9 @@
-import PDFArray from "../objects/PDFArray";
-import PDFDict, { DictMap } from "../objects/PDFDict";
-import PDFNumber from "../objects/PDFNumber";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFPageLeaf from "./PDFPageLeaf";
+import PDFArray from '../objects/PDFArray';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFNumber from '../objects/PDFNumber';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFPageLeaf from './PDFPageLeaf';
 export declare type TreeNode = PDFPageTree | PDFPageLeaf;
 declare class PDFPageTree extends PDFDict {
     static withContext: (context: PDFContext, parent?: PDFRef | undefined) => PDFPageTree;

package/ts3.4/es/core/syntax/Keywords.d.ts

@@ -1,4 +1,4 @@
-import CharCodes from "./CharCodes";
+import CharCodes from './CharCodes';
 export declare const Keywords: {
     header: CharCodes[];
     eof: CharCodes[];

package/ts3.4/es/core/writers/PDFStreamWriter.d.ts

@@ -1,9 +1,9 @@
-import PDFHeader from "../document/PDFHeader";
-import PDFTrailer from "../document/PDFTrailer";
-import PDFObject from "../objects/PDFObject";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFWriter from "./PDFWriter";
+import PDFHeader from '../document/PDFHeader';
+import PDFTrailer from '../document/PDFTrailer';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFWriter from './PDFWriter';
 declare class PDFStreamWriter extends PDFWriter {
     static forContext: (context: PDFContext, objectsPerTick: number, encodeStreams?: boolean, objectsPerStream?: number) => PDFStreamWriter;
     private readonly encodeStreams;

package/ts3.4/es/core/writers/PDFWriter.d.ts

@@ -1,11 +1,11 @@
-import PDFCrossRefSection from "../document/PDFCrossRefSection";
-import PDFHeader from "../document/PDFHeader";
-import PDFTrailer from "../document/PDFTrailer";
-import PDFTrailerDict from "../document/PDFTrailerDict";
-import PDFDict from "../objects/PDFDict";
-import PDFObject from "../objects/PDFObject";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
+import PDFCrossRefSection from '../document/PDFCrossRefSection';
+import PDFHeader from '../document/PDFHeader';
+import PDFTrailer from '../document/PDFTrailer';
+import PDFTrailerDict from '../document/PDFTrailerDict';
+import PDFDict from '../objects/PDFDict';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
 export interface SerializationInfo {
     size: number;
     header: PDFHeader;

package/ts3.4/es/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./api/index";
-export * from "./core/index";
-export * from "./types/index";
-export * from "./utils/index";
+export * from './api';
+export * from './core';
+export * from './types';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/ts3.4/es/types/index.d.ts

@@ -1,2 +1,26 @@
-export { TransformationMatrix } from "./matrix";
+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 { TransformationMatrix } from './matrix';
+export declare type Size = {
+    width: number;
+    height: number;
+};
+export declare type Coordinates = {
+    x: number;
+    y: number;
+};
+export declare type GraphicElement = Arc | Circle | Ellipse | Line | Plot | Point | Rectangle | Segment;
+export declare type Space = {
+    topLeft: Coordinates;
+    topRight: Coordinates;
+    bottomRight: Coordinates;
+    bottomLeft: Coordinates;
+};
+export declare type LinkElement = Rectangle | Ellipse;
 //# sourceMappingURL=index.d.ts.map

package/ts3.4/es/utils/arrays.d.ts

@@ -7,10 +7,11 @@ 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;
 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 canBeConvertedToUint8Array: (input: any) => input is string | Uint8Array | ArrayBuffer;
 export declare const toUint8Array: (input: string | ArrayBuffer | Uint8Array) => Uint8Array;
 //# sourceMappingURL=arrays.d.ts.map

package/ts3.4/es/utils/elements/Arc.d.ts

@@ -0,0 +1,23 @@
+import Circle from './Circle';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Arc extends GraphElement {
+    O: Point;
+    A: Point;
+    B: Point;
+    /** Last sweep. Used to deduce the angle orientation */
+    lastSweep: number;
+    constructor(O?: Point, A?: Point, B?: Point, lastSweep?: number);
+    center(): Point;
+    origin(): Point;
+    destination(): Point;
+    sweep(): number;
+    ray(): number;
+    isEqual(element: GraphElement): boolean;
+    getCircle(): Circle;
+    originVect(): import("../..").Coordinates;
+    middle(): Point;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+}
+//# sourceMappingURL=Arc.d.ts.map

package/ts3.4/es/utils/elements/Circle.d.ts

@@ -0,0 +1,15 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Circle extends GraphElement {
+    O: Point;
+    r: number;
+    constructor(O?: Point, r?: number);
+    ray(): number;
+    center(): Point;
+    /** This is used to standardize type Circle | Arc */
+    getCircle(): this;
+    isEqual(element: GraphElement): boolean;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+}
+//# sourceMappingURL=Circle.d.ts.map

package/ts3.4/es/utils/elements/Ellipse.d.ts

@@ -0,0 +1,21 @@
+import { Size } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+export default class Ellipse extends GraphElement {
+    A: Point;
+    B: Point;
+    C: Point;
+    constructor(A?: Point, B?: Point, C?: Point);
+    center(): Point;
+    axis(): Segment;
+    a(): number;
+    b(): number;
+    rotation(): number;
+    getSize(): Size;
+    isEqual(element: GraphElement): boolean;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+    polarRay(teta: number): number;
+}
+//# sourceMappingURL=Ellipse.d.ts.map

package/ts3.4/es/utils/elements/GraphElement.d.ts

@@ -0,0 +1,7 @@
+import Point from './Point';
+export default abstract class GraphElement {
+    abstract isEqual(element: GraphElement): boolean;
+    abstract orthoProjection(P: Point): Point;
+    distance(P: Point): number;
+}
+//# sourceMappingURL=GraphElement.d.ts.map

package/ts3.4/es/utils/elements/Line.d.ts

@@ -0,0 +1,24 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Line extends GraphElement {
+    origin(): Point;
+    dirVect(): Coordinates;
+    A: Point;
+    B: Point;
+    constructor(A?: Point, B?: Point);
+    /** Line equation */
+    y(x: number): number;
+    /** The slope */
+    a(): number;
+    /** Origin y coordinate */
+    b(): number;
+    isEqual(element: GraphElement): boolean;
+    /** Reversed line equation */
+    x(y: number): number;
+    includes(P: Point): boolean;
+    /** This is used to standarsize type Segment | HalfLine | Line */
+    getLine(): Line;
+    orthoProjection(P: Point): Point;
+}
+//# sourceMappingURL=Line.d.ts.map

package/ts3.4/es/utils/elements/Plot.d.ts

@@ -0,0 +1,12 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Plot extends GraphElement {
+    points: Coordinates[];
+    constructor(points?: Coordinates[]);
+    getPoints(): Coordinates[];
+    translate(translationVector: Coordinates): void;
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(P: Point): Point;
+}
+//# sourceMappingURL=Plot.d.ts.map

package/ts3.4/es/utils/elements/Point.d.ts

@@ -0,0 +1,19 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+export default class Point extends GraphElement {
+    static type: string;
+    x: number;
+    y: number;
+    constructor(coords?: {
+        x: number;
+        y: number;
+    });
+    toCoords(): {
+        x: number;
+        y: number;
+    };
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(): Point;
+    plus(vect: Coordinates): Point;
+}
+//# sourceMappingURL=Point.d.ts.map

package/ts3.4/es/utils/elements/Rectangle.d.ts

@@ -0,0 +1,22 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Rectangle extends GraphElement {
+    static type: string;
+    start: Point;
+    end: Point;
+    constructor(start?: Point, end?: Point);
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCoords(): {
+        x: number;
+        y: number;
+    };
+    getStart(): Point;
+    getEnd(): Point;
+    center(): Point;
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(P: Point): Point;
+}
+//# sourceMappingURL=Rectangle.d.ts.map

package/ts3.4/es/utils/elements/Segment.d.ts

@@ -0,0 +1,20 @@
+import GraphElement from './GraphElement';
+import Line from './Line';
+import Point from './Point';
+export default class Segment extends GraphElement {
+    static type: string;
+    A: Point;
+    B: Point;
+    constructor(A?: Point, B?: Point);
+    origin(): Point;
+    destination(): Point;
+    dirVect(): import("../..").Coordinates;
+    length(): number;
+    isEqual(element: GraphElement): boolean;
+    /** Returns an equivalent line object */
+    getLine(): Line;
+    includes(P: Point): boolean;
+    middle(): Point;
+    orthoProjection(P: Point): Point;
+}
+//# sourceMappingURL=Segment.d.ts.map

package/ts3.4/es/utils/elements/index.d.ts

@@ -0,0 +1,10 @@
+export { default as Arc } from './Arc';
+export { default as Circle } from './Circle';
+export { default as GraphElement } from './GraphElement';
+export { default as Ellipse } from './Ellipse';
+export { default as Line } from './Line';
+export { default as SegmePlotnt } from './Plot';
+export { default as Point } from './Point';
+export { default as Rectangle } from './Rectangle';
+export { default as Segment } from './Segment';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/es/utils/index.d.ts

@@ -1,12 +1,12 @@
-export * from "./arrays";
-export * from "./async";
-export * from "./strings";
-export * from "./unicode";
-export * from "./numbers";
-export * from "./errors";
-export * from "./base64";
-export * from "./objects";
-export * from "./validators";
-export * from "./pdfDocEncoding";
-export { default as Cache } from "./Cache";
+export * from './arrays';
+export * from './async';
+export * from './strings';
+export * from './unicode';
+export * from './numbers';
+export * from './errors';
+export * from './base64';
+export * from './objects';
+export * from './validators';
+export * from './pdfDocEncoding';
+export { default as Cache } from './Cache';
 //# sourceMappingURL=index.d.ts.map

package/ts3.4/es/utils/intersections.d.ts

@@ -0,0 +1,10 @@
+import Circle from './elements/Circle';
+import Line from './elements/Line';
+import { Coordinates, GraphicElement } from '../types';
+export declare function intersections(A: GraphicElement, B: GraphicElement): Coordinates[];
+export declare function intersection(A: GraphicElement, B: GraphicElement): Coordinates | undefined;
+export declare function intersectionLine(A: Line, B: Line): Coordinates[];
+export declare function intersectionCircleLine(A: Circle, B: Line): Coordinates[];
+export declare function intersectionCircle(A: Circle, B: Circle): Coordinates[];
+export declare function getIntersections(elements: GraphicElement[]): Coordinates[];
+//# sourceMappingURL=intersections.d.ts.map

package/ts3.4/es/utils/maths.d.ts

@@ -0,0 +1,46 @@
+import Point from './elements/Point';
+import { Coordinates } from '../types';
+/** This value represents the precision we accept for float values */
+export declare const FLOAT_APPROXIMATION = 0.000001;
+/** Calculates the distance between 2 points */
+export declare const distance: (A: Point, B: Point) => number;
+export declare const distanceCoords: (A: Coordinates, B: Coordinates) => number;
+/** Calculates the distance denoted by a vector */
+export declare const norm: (vect: Coordinates) => number;
+/** Calculates the orthogonal vector of provided vector */
+export declare const orthogonal: ({ x, y }: Coordinates) => Coordinates;
+/** Check if 2 vectors are proportional */
+export declare const isColinear: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => boolean;
+/** Check if 2 floating values can be considered equals */
+export declare const isEqual: (a: number, b: number) => boolean;
+/** Return true if a is proportional to b: (a = kb), considering float imprecision */
+export declare const isProportional: (a: number, b: number) => boolean;
+/** Calculate the scalar product between 2 vectors */
+export declare const scalar: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => number;
+/** Calculate the sum of 2 vectors */
+export declare const plus: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => Coordinates;
+/** Calculate the vector multiplied by a scalar */
+export declare const times: ({ x, y }: Coordinates, k?: number) => Coordinates;
+/** Calculate the difference of 2 vectors */
+export declare const minus: (u: Coordinates, v: Coordinates) => Coordinates;
+/** Returns the vector between 2 points. */
+export declare const vector: (A: Point, B: Point) => Coordinates;
+/**
+ * Returns the angle between the vector and the horizontal axis (Ox).
+ * The return value is between -PI and PI.
+ * @returns {number} angle in radian between -Pi and Pi
+ */
+export declare const orientation: ({ x, y }: Coordinates) => number;
+/** Returns the unit vector associated to the provided vector,
+ * or the Null vector (0, 0) if the vector is null
+ */
+export declare const unitVector: (u: Coordinates) => Coordinates;
+/** Returns the angle from u to v in radian */
+export declare const angle: (u: Coordinates, v: Coordinates, previousAngle?: number) => number;
+/** Returns the angle between the lines (BA) and (BC) in radian
+ * @returns {number} the angle in radian, between -Pi and Pi
+ */
+export declare const angleABC: (A: Point, B: Point, C: Point, previousAngle?: number) => number;
+/** Rotate the vector by an angle in radian */
+export declare const rotate: (vect: Coordinates, teta: number) => Coordinates;
+//# sourceMappingURL=maths.d.ts.map

package/ts3.4/es/utils/strings.d.ts

@@ -5,6 +5,7 @@ export declare const toHexString: (num: number) => string;
 export declare const charFromCode: (code: number) => string;
 export declare const charFromHexCode: (hex: string) => string;
 export declare const padStart: (value: string, length: number, padChar: string) => string;
+export declare const stringAsByteArray: (str: string) => Uint8Array;
 export declare const copyStringIntoBuffer: (str: string, buffer: Uint8Array, offset: number) => number;
 export declare const addRandomSuffix: (prefix: string, suffixLength?: number) => string;
 export declare const escapeRegExp: (str: string) => string;