@adnsistemas/pdf-lib 1.18.0 → 2.4.2

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

@@ -1,16 +1,20 @@
-import { DocumentSnapshot } from "../../api/snapshot";
-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 { DocumentSnapshot } from 'src/api/snapshot';
+import PDFCrossRefSection from 'src/core/document/PDFCrossRefSection';
+import PDFHeader from 'src/core/document/PDFHeader';
+import PDFTrailer from 'src/core/document/PDFTrailer';
+import PDFTrailerDict from 'src/core/document/PDFTrailerDict';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/PDFContext';
+import PDFSecurity from 'src/core/security/PDFSecurity';
 export interface SerializationInfo {
     size: number;
     header: PDFHeader;
-    indirectObjects: [PDFRef, PDFObject][];
+    indirectObjects: [
+        PDFRef,
+        PDFObject
+    ][];
     xref?: PDFCrossRefSection;
     trailerDict?: PDFTrailerDict;
     trailer: PDFTrailer;
@@ -24,9 +28,13 @@ declare class PDFWriter {
     private parsedObjects;
     protected constructor(context: PDFContext, objectsPerTick: number, snapshot: DocumentSnapshot);
     serializeToBuffer(): Promise<Uint8Array>;
-    protected computeIndirectObjectSize([ref, object]: [PDFRef, PDFObject]): number;
+    protected computeIndirectObjectSize([ref, object]: [
+        PDFRef,
+        PDFObject
+    ]): number;
     protected createTrailerDict(prevStartXRef?: number): PDFDict;
     protected computeBufferSize(incremental: boolean): Promise<SerializationInfo>;
+    protected encrypt(ref: PDFRef, object: PDFObject, security: PDFSecurity): void;
     protected shouldWaitForTick: (n: number) => boolean;
 }
 export default PDFWriter;

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 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;
 //# sourceMappingURL=index.d.ts.map

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

@@ -17,6 +17,13 @@
  *   * 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 declare type TransformationMatrix = [number, number, number, number, number, number];
+export type TransformationMatrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
 export declare const identityMatrix: TransformationMatrix;
 //# sourceMappingURL=matrix.d.ts.map

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

@@ -7,10 +7,12 @@ 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;
+export declare const byteArrayToHexString: (array: Uint8Array) => string;
 //# 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 const intersections: (A: GraphicElement, B: GraphicElement) => Coordinates[];
+export declare const intersection: (A: GraphicElement, B: GraphicElement) => Coordinates | undefined;
+export declare const intersectionLine: (A: Line, B: Line) => Coordinates[];
+export declare const intersectionCircleLine: (A: Circle, B: Line) => Coordinates[];
+export declare const intersectionCircle: (A: Circle, B: Circle) => Coordinates[];
+export declare const 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;
@@ -14,7 +15,10 @@ export declare const newlineChars: string[];
 export declare const isNewlineChar: (text: string) => boolean;
 export declare const lineSplit: (text: string) => string[];
 export declare const mergeLines: (text: string) => string;
-export declare const charAtIndex: (text: string, index: number) => [string, number];
+export declare const charAtIndex: (text: string, index: number) => [
+    string,
+    number
+];
 export declare const charSplit: (text: string) => string[];
 export declare const breakTextIntoLines: (text: string, wordBreaks: string[], maxWidth: number, computeWidthOfText: (t: string) => number) => string[];
 export declare const parseDate: (dateStr: string) => Date | undefined;

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

@@ -1,6 +1,6 @@
 export declare const backtick: (val: any) => string;
 export declare const singleQuote: (val: any) => string;
-declare type Primitive = string | number | boolean | undefined | null;
+type Primitive = string | number | boolean | undefined | null;
 export declare const createValueErrorMsg: (value: any, valueName: string, values: Primitive[]) => string;
 export declare const assertIsOneOf: (value: any, valueName: string, allowedValues: Primitive[] | {
     [key: string]: Primitive;
@@ -12,7 +12,10 @@ export declare const assertIsSubset: (values: any[], valueName: string, allowedV
     [key: string]: Primitive;
 }) => void;
 export declare const getType: (val: any) => any;
-export declare type TypeDescriptor = 'null' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint' | DateConstructor | ArrayConstructor | Uint8ArrayConstructor | ArrayBufferConstructor | FunctionConstructor | [Function, string];
+export type TypeDescriptor = 'null' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint' | DateConstructor | ArrayConstructor | Uint8ArrayConstructor | ArrayBufferConstructor | FunctionConstructor | [
+    Function,
+    string
+];
 export declare const isType: (value: any, type: TypeDescriptor) => boolean;
 export declare const createTypeErrorMsg: (value: any, valueName: string, types: TypeDescriptor[]) => string;
 export declare const assertIs: (value: any, valueName: string, types: TypeDescriptor[]) => void;