@adnsistemas/pdf-lib 1.18.0 → 2.4.2

package/src/utils/intersections.ts

@@ -0,0 +1,280 @@
+import Arc from './elements/Arc';
+import Circle from './elements/Circle';
+import Ellipse from './elements/Ellipse';
+import Line from './elements/Line';
+import Plot from './elements/Plot';
+import Point from './elements/Point';
+import Rectangle from './elements/Rectangle';
+import Segment from './elements/Segment';
+import { Coordinates, GraphicElement } from '../types';
+import {
+  distance,
+  isColinear,
+  isEqual,
+  norm,
+  orthogonal,
+  times,
+  unitVector,
+  vector,
+  rotate,
+} from './maths';
+
+export const intersections = (
+  A: GraphicElement,
+  B: GraphicElement,
+): Coordinates[] => {
+  if (A instanceof Point || B instanceof Point) return [];
+  else if (A instanceof Text || B instanceof Text) return [];
+  else if (A instanceof Image || B instanceof Image) return [];
+  // TODO: calculate the coords of the intersection: https://www.emathzone.com/tutorials/geometry/intersection-of-line-and-ellipse.html
+  else if (A instanceof Line) return intersectionsLine(A, B);
+  else if (A instanceof Segment) {
+    return intersectionsLine(A.getLine(), B).filter((P) =>
+      A.includes(new Point(P)),
+    );
+  } else if (A instanceof Circle) return intersectionsCircle(A, B);
+  else if (A instanceof Arc) {
+    return intersectionsCircle(A.getCircle(), B).filter((P) =>
+      A.includes(new Point(P)),
+    );
+  } else if (A instanceof Plot) return intersectionsPlot(A, B);
+  else if (A instanceof Rectangle) return intersectionsRectangle(A, B);
+  else if (A instanceof Ellipse) return intersectionsEllipse(A, B);
+  return A;
+};
+
+export const intersection = (
+  A: GraphicElement,
+  B: GraphicElement,
+): Coordinates | undefined => intersections(A, B)[0];
+
+const intersectionsLine = (
+  A: Line,
+  B: Exclude<GraphicElement, Text | Point>,
+): Coordinates[] => {
+  if (B instanceof Line) return intersectionLine(A, B);
+  else if (B instanceof Segment) {
+    return intersectionLine(A, B.getLine()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Circle) return intersectionCircleLine(B, A);
+  else if (B instanceof Arc) {
+    return intersectionsCircle(B.getCircle(), A).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Plot) return intersectionsPlot(B, A);
+  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
+  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
+  return B;
+};
+
+const intersectionsEllipse = (
+  A: Ellipse,
+  B: Exclude<GraphicElement, Text | Point>,
+): Coordinates[] => {
+  if (B instanceof Line) return intersectionsLineAndEllipse(A, B);
+  else if (B instanceof Segment) {
+    return intersectionsEllipse(A, B.getLine()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  }
+  // TODO:
+  // else if (B instanceof Circle) return intersectionEllipseCircle(B, A)
+  else if (B instanceof Circle) return [];
+  // TODO:
+  // else if (B instanceof Ellipse) return intersectionEllipseEllipse(B, A)
+  else if (B instanceof Ellipse) return [];
+  else if (B instanceof Arc) {
+    return intersectionsEllipse(A, B.getCircle()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Plot) return intersectionsPlot(B, A);
+  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
+  return B;
+};
+
+const intersectionsLineAndEllipse = (A: Ellipse, B: Line): Coordinates[] => {
+  const center = A.center().toCoords();
+  const a = A.a();
+  const b = A.b();
+  const rotation = A.rotation();
+  const isLineParallel2YAxis = isEqual(B.dirVect().x, 0);
+
+  // this is a dummy value to represent a point on the line
+  const p1Y = isLineParallel2YAxis ? 1 : B.y(1);
+  const p1X = isLineParallel2YAxis ? B.origin().toCoords().x : 1;
+  const p1 = { x: p1X, y: p1Y };
+
+  // this is a dummy value to represent a point on the line
+  const p2Y = isLineParallel2YAxis ? 2 : B.y(2);
+  const p2X = isLineParallel2YAxis ? B.origin().toCoords().x : 2;
+  const p2 = { x: p2X, y: p2Y };
+
+  const p1Normalized = rotate(
+    { x: p1.x - center.x, y: p1.y - center.y },
+    -rotation,
+  );
+  const p2Normalized = rotate(
+    { x: p2.x - center.x, y: p2.y - center.y },
+    -rotation,
+  );
+
+  const angular =
+    (p1Normalized.y - p2Normalized.y) / (p1Normalized.x - p2Normalized.x);
+  const linear = p1Normalized.y - angular * p1Normalized.x;
+
+  const lineY = (x: number) => angular * x + linear;
+  const denormalize = (coord: Coordinates) => {
+    const rotated = rotate(coord, rotation);
+    return {
+      x: rotated.x + center.x,
+      y: rotated.y + center.y,
+    };
+  };
+
+  // Intersection with vertical line
+  if (isEqual(p1Normalized.x - p2Normalized.x, 0)) {
+    const x = p1Normalized.x;
+    const vDelta = b ** 2 - (x ** 2 * b ** 2) / a ** 2;
+    if (vDelta < 0) return [];
+    else if (vDelta === 0) {
+      return [{ x, y: 0 }].map(denormalize);
+    } else {
+      const y1 = Math.sqrt((b ** 2 * (a ** 2 - x ** 2)) / a ** 2);
+      const y2 = -y1;
+      return [
+        { x, y: y1 },
+        { x, y: y2 },
+      ].map(denormalize);
+    }
+  }
+
+  // Intersection with any line
+
+  // the quadratic equation is:
+  // alpha * x ** 2 + beta * x + gamma = 0
+  const alpha = a ** 2 * angular ** 2 + b ** 2;
+  const beta = 2 * a ** 2 * (angular * linear);
+  const gamma = a ** 2 * (linear ** 2 - b ** 2);
+
+  const delta = beta ** 2 - 4 * alpha * gamma;
+  if (delta < 0) return [];
+  else if (delta === 0) {
+    const x = -(beta ** 2) / (2 * alpha);
+    const y = lineY(x);
+    return [{ x, y }].map(denormalize);
+  } else {
+    const x1 = (-beta + Math.sqrt(delta)) / (2 * alpha);
+    const y1 = lineY(x1);
+    const x2 = (-beta - Math.sqrt(delta)) / (2 * alpha);
+    const y2 = lineY(x2);
+    return [
+      { x: x1, y: y1 },
+      { x: x2, y: y2 },
+    ].map(denormalize);
+  }
+};
+
+export const intersectionLine = (A: Line, B: Line): Coordinates[] => {
+  if (isColinear(A.dirVect(), B.dirVect())) return [];
+  else {
+    const { x: ux, y: uy } = A.dirVect();
+    const { x: vx, y: vy } = B.dirVect();
+    const { x: xA, y: yA } = A.origin().toCoords();
+    const { x: xB, y: yB } = B.origin().toCoords();
+    const x =
+      (ux * (vx * (yA - yB) + vy * xB) - uy * vx * xA) / (ux * vy - uy * vx);
+    const y =
+      (uy * (vy * (xA - xB) + vx * yB) - ux * vy * yA) / (uy * vx - ux * vy);
+    return [{ x, y }];
+  }
+};
+
+const intersectionsPlot = (A: Plot, B: GraphicElement): Coordinates[] => {
+  const points = A.getPoints().map((pt) => new Point(pt));
+  const head = points.pop();
+  const segments = points.map(
+    (pt, i) => new Segment(pt, points[i + 1] || head),
+  );
+  // @ts-ignore
+  const inters = segments.map((s) => intersections(s, B)).flat();
+  return inters;
+};
+
+const intersectionsRectangle = (
+  A: Rectangle,
+  B: GraphicElement,
+): Coordinates[] => {
+  const P1 = A.getCoords();
+  const P3 = A.getEnd();
+  const P2 = { x: P1.x, y: P3.y };
+  const P4 = { x: P3.x, y: P1.y };
+  return intersections(new Plot([P1, P2, P3, P4, P1]), B);
+};
+
+export const intersectionCircleLine = (A: Circle, B: Line): Coordinates[] => {
+  const rA = A.ray();
+  const O = A.center();
+  const H = B.orthoProjection(O);
+  const OH = distance(O, H);
+  // The line is tangeant
+  if (isEqual(OH, rA)) return [H];
+  // The line is too far from the circle
+  else if (OH > A.ray()) return [];
+  // The line cut the circle in 2 points
+  else {
+    // Pythagore
+    const HP = Math.sqrt(rA * rA - OH * OH);
+    const vect = unitVector(B.dirVect());
+    return [H.plus(times(vect, HP)), H.plus(times(vect, -HP))];
+  }
+};
+
+export const intersectionCircle = (A: Circle, B: Circle): Coordinates[] => {
+  const oA = A.center();
+  const oB = B.center();
+  const rA = A.ray();
+  const rB = B.ray();
+  const axis = vector(oA, oB);
+  const CC = norm(axis);
+  // The circles are tangeant
+  if (isEqual(CC, rA + rB)) return [A.orthoProjection(oB).toCoords()];
+  // The circles are too far from eachother
+  else if (CC > rA + rB) return [];
+  // The intersections belong to an orthogonal axis
+  else {
+    const ratio = 1 / 2 + (rA * rA - rB * rB) / (CC * CC) / 2;
+    const H = oA.plus(times(axis, ratio));
+    return intersectionCircleLine(A, new Line(H, H.plus(orthogonal(axis))));
+  }
+};
+
+const intersectionsCircle = (
+  A: Circle,
+  B: Exclude<GraphicElement, Text | Point>,
+): Coordinates[] => {
+  if (B instanceof Circle) return intersectionCircle(A, B);
+  else if (B instanceof Line) return intersectionCircleLine(A, B);
+  else if (B instanceof Segment) {
+    return intersectionCircleLine(A, B.getLine()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Arc) {
+    return intersectionCircle(A, B.getCircle()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Plot) return intersectionsPlot(B, A);
+  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
+  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
+  return B;
+};
+
+export const getIntersections = (elements: GraphicElement[]) => {
+  const checked: GraphicElement[] = [];
+  const inters: Coordinates[] = [];
+  elements.forEach((elt) => {
+    checked.forEach((e) => inters.push(...intersections(e, elt)));
+    checked.push(elt);
+  });
+  return inters;
+};

package/src/utils/maths.ts

@@ -0,0 +1,108 @@
+import Point from './elements/Point';
+import { Coordinates } from '../types';
+
+/** This value represents the precision we accept for float values */
+export const FLOAT_APPROXIMATION = 0.000001;
+
+/** Calculates the distance between 2 points */
+export const distance = (A: Point, B: Point) => norm(vector(A, B));
+
+export const distanceCoords = (A: Coordinates, B: Coordinates) =>
+  norm(minus(B, A));
+
+/** Calculates the distance denoted by a vector */
+export const norm = (vect: Coordinates) =>
+  Math.sqrt(vect.x * vect.x + vect.y * vect.y);
+
+/** Calculates the orthogonal vector of provided vector */
+export const orthogonal = ({ x, y }: Coordinates): Coordinates => ({
+  x: -y,
+  y: x,
+});
+
+/** Check if 2 vectors are proportional */
+export const isColinear = (
+  { x: ux, y: uy }: Coordinates,
+  { x: vx, y: vy }: Coordinates,
+): boolean => isEqual(ux * vy, uy * vx);
+
+/** Check if 2 floating values can be considered equals */
+export const isEqual = (a: number, b: number): boolean =>
+  Math.round(Math.abs(a - b) / FLOAT_APPROXIMATION) === 0;
+
+/** Return true if a is proportional to b: (a = kb), considering float imprecision */
+export const isProportional = (a: number, b: number): boolean =>
+  isEqual((Math.abs(a) + FLOAT_APPROXIMATION / 10) % b, 0);
+
+/** Calculate the scalar product between 2 vectors */
+export const scalar = (
+  { x: ux, y: uy }: Coordinates,
+  { x: vx, y: vy }: Coordinates,
+): number => ux * vx + uy * vy;
+
+/** Calculate the sum of 2 vectors */
+export const plus = (
+  { x: ux, y: uy }: Coordinates,
+  { x: vx, y: vy }: Coordinates,
+): Coordinates => ({ x: ux + vx, y: uy + vy });
+
+/** Calculate the vector multiplied by a scalar */
+export const times = ({ x, y }: Coordinates, k = 1): Coordinates => ({
+  x: k * x,
+  y: k * y,
+});
+
+/** Calculate the difference of 2 vectors */
+export const minus = (u: Coordinates, v: Coordinates): Coordinates =>
+  plus(u, times(v, -1));
+
+/** Returns the vector between 2 points. */
+export const vector = (A: Point, B: Point): Coordinates =>
+  minus(B.toCoords(), A.toCoords());
+
+/**
+ * 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 const orientation = ({ x, y }: Coordinates): number => {
+  const alpha = Math.acos(x / Math.sqrt(x * x + y * y));
+  return y > 0 ? alpha : -alpha;
+};
+
+/** Returns the unit vector associated to the provided vector,
+ * or the Null vector (0, 0) if the vector is null
+ */
+export const unitVector = (u: Coordinates): Coordinates => {
+  const l = norm(u);
+  return l > 0 ? times(u, 1 / l) : u;
+};
+
+/** Returns the angle from u to v in radian */
+export const angle = (u: Coordinates, v: Coordinates, previousAngle = 0) => {
+  let sweep = orientation(v) - orientation(u);
+  // If the angle has the same sign as the arc orientation, we return the angle as is
+  // Otherwise, we need to correct the value, adding or removing 2π
+  while (Math.abs(previousAngle - sweep) > Math.PI) {
+    sweep += Math.sign(previousAngle - sweep) * 2 * Math.PI;
+  }
+  return sweep;
+};
+
+/** Returns the angle between the lines (BA) and (BC) in radian
+ * @returns {number} the angle in radian, between -Pi and Pi
+ */
+export const angleABC = (
+  A: Point,
+  B: Point,
+  C: Point,
+  previousAngle = 0,
+): number => angle(vector(B, A), vector(B, C), previousAngle);
+
+/** Rotate the vector by an angle in radian */
+export const rotate = (vect: Coordinates, teta: number): Coordinates => {
+  const { x, y } = vect;
+  const nx = x * Math.cos(teta) - y * Math.sin(teta);
+  const ny = y * Math.cos(teta) + x * Math.sin(teta);
+  return { x: nx, y: ny };
+};

package/src/utils/pdfDocEncoding.ts

@@ -1,4 +1,4 @@
-import { toCharCode } from 'src/utils/strings';
+import { toCharCode } from './strings';
 
 // Mapping from PDFDocEncoding to Unicode code point
 const pdfDocEncodingToUnicode = new Uint16Array(256);

package/src/utils/png.ts

@@ -51,7 +51,7 @@ export class PNG {
     const upng = UPNG.decode(pngData);
     const frames = UPNG.toRGBA8(upng);
 
-    if (frames.length > 1) throw new Error(`Animated PNGs are not supported`);
+    if (frames.length > 1) throw new Error('Animated PNGs are not supported');
 
     const frame = new Uint8Array(frames[0]);
     const { rgbChannel, alphaChannel } = splitAlphaChannel(frame);

package/src/utils/strings.ts

@@ -19,6 +19,12 @@ export const padStart = (value: string, length: number, padChar: string) => {
   return padding + value;
 };
 
+export const stringAsByteArray = (str: string): Uint8Array => {
+  const buffer = new Uint8Array(str.length);
+  copyStringIntoBuffer(str, buffer, 0);
+  return buffer;
+};
+
 export const copyStringIntoBuffer = (
   str: string,
   buffer: Uint8Array,
@@ -44,11 +50,14 @@ export const escapedNewlineChars = ['\\n', '\\f', '\\r', '\\u000B'];
 
 export const newlineChars = ['\n', '\f', '\r', '\u000B'];
 
+// eslint-disable-next-line no-control-regex
 export const isNewlineChar = (text: string) => /^[\n\f\r\u000B]$/.test(text);
 
+// eslint-disable-next-line no-control-regex
 export const lineSplit = (text: string) => text.split(/[\n\f\r\u000B]/);
 
 export const mergeLines = (text: string) =>
+  // eslint-disable-next-line no-control-regex
   text.replace(/[\n\f\r\u000B]/g, ' ');
 
 // JavaScript's String.charAt() method doesn work on strings containing UTF-16
@@ -139,7 +148,8 @@ export const breakTextIntoLines = (
 };
 
 // See section "7.9.4 Dates" of the PDF specification
-const dateRegex = /^D:(\d\d\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([+\-Z])?(\d\d)?'?(\d\d)?'?$/;
+const dateRegex =
+  /^D:(\d\d\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([+\-Z])?(\d\d)?'?(\d\d)?'?$/;
 
 export const parseDate = (dateStr: string): Date | undefined => {
   const match = dateStr.match(dateRegex);

package/src/utils/unicode.ts

@@ -1,4 +1,4 @@
-import { toHexString } from 'src/utils/strings';
+import { toHexString } from './strings';
 
 /**
  * Encodes a string to UTF-8.

package/src/utils/validators.ts

@@ -1,6 +1,6 @@
 /* tslint:disable:ban-types */
 
-import { values as objectValues } from 'src/utils/objects';
+import { values as objectValues } from './objects';
 
 export const backtick = (val: any) => `\`${val}\``;
 export const singleQuote = (val: any) => `'${val}'`;

package/ts3.4/cjs/api/PDFDocument.d.ts

@@ -1,15 +1,27 @@
-import PDFEmbeddedPage from "./PDFEmbeddedPage";
-import PDFFont from "./PDFFont";
-import PDFImage from "./PDFImage";
-import PDFPage from "./PDFPage";
-import PDFForm from "./form/PDFForm";
-import { StandardFonts } from "./StandardFonts";
-import { PageBoundingBox, PDFCatalog, PDFContext } from "../core";
-import { AttachmentOptions, SaveOptions, Base64SaveOptions, LoadOptions, CreateOptions, EmbedFontOptions, SetTitleOptions, IncrementalSaveOptions } from "./PDFDocumentOptions";
-import PDFRef from "../core/objects/PDFRef";
-import { Fontkit } from "../types/fontkit";
-import { TransformationMatrix } from "../types/matrix";
+import PDFEmbeddedPage from './PDFEmbeddedPage';
+import PDFFont from './PDFFont';
+import PDFImage from './PDFImage';
+import PDFPage from './PDFPage';
+import PDFForm from './form/PDFForm';
+import { StandardFonts } from './StandardFonts';
+import { PageBoundingBox, PDFCatalog, PDFContext } from '../core';
+import { AttachmentOptions, SaveOptions, Base64SaveOptions, LoadOptions, CreateOptions, EmbedFontOptions, SetTitleOptions, IncrementalSaveOptions } from 'src/api/PDFDocumentOptions';
+import PDFRef from 'src/core/objects/PDFRef';
+import { Fontkit } from 'src/types/fontkit';
+import { TransformationMatrix } from 'src/types/matrix';
+import { AFRelationship } from 'src/core/embedders/FileEmbedder';
+import PDFSvg from './PDFSvg';
+import { SecurityOptions } from '../core/security/PDFSecurity';
 import { DocumentSnapshot } from './snapshot';
+export type PDFAttachment = {
+    name: string;
+    data: Uint8Array;
+    mimeType: string | undefined;
+    afRelationship: AFRelationship | undefined;
+    description: string | undefined;
+    creationDate: Date | undefined;
+    modificationDate: Date | undefined;
+};
 /**
  * Represents a PDF document.
  */
@@ -179,6 +191,16 @@ export default class PDFDocument {
      * @returns A string containing the producer of this document, if it has one.
      */
     getProducer(): string | undefined;
+    /**
+     * Get this document's language metadata. The language appears in the
+     * "Document Properties" section of most PDF readers. For example:
+     * ```js
+     * const language = pdfDoc.getLanguage()
+     * ```
+     * @returns A string containing the RFC 3066 _Language-Tag_ of this document,
+     *          if it has one.
+     */
+    getLanguage(): string | undefined;
     /**
      * Get this document's creation date metadata. The creation date appears in
      * the "Document Properties" section of most PDF readers. For example:
@@ -383,7 +405,10 @@ export default class PDFDocument {
      * @param page Optionally, the desired dimensions or existing page.
      * @returns The newly created (or existing) page.
      */
-    addPage(page?: PDFPage | [number, number]): PDFPage;
+    addPage(page?: PDFPage | [
+        number,
+        number
+    ]): PDFPage;
     /**
      * Insert a page at a given index within this document. This method accepts
      * three different value types for the `page` parameter:
@@ -416,7 +441,10 @@ export default class PDFDocument {
      * @param page Optionally, the desired dimensions or existing page.
      * @returns The newly created (or existing) page.
      */
-    insertPage(index: number, page?: PDFPage | [number, number]): PDFPage;
+    insertPage(index: number, page?: PDFPage | [
+        number,
+        number
+    ]): PDFPage;
     /**
      * Copy pages from a source document into this document. Allows pages to be
      * copied between different [[PDFDocument]] instances. For example:
@@ -532,6 +560,15 @@ export default class PDFDocument {
      * @returns Resolves when the attachment is complete.
      */
     attach(attachment: string | Uint8Array | ArrayBuffer, name: string, options?: AttachmentOptions): Promise<void>;
+    private getRawAttachments;
+    private getSavedAttachments;
+    private getUnsavedAttachments;
+    /**
+     * Get all attachments that are embedded in this document.
+     *
+     * @returns Array of attachments with name and data
+     */
+    getAttachments(): PDFAttachment[];
     /**
      * Embed a font into this document. The input data can be provided in multiple
      * formats:
@@ -642,6 +679,7 @@ export default class PDFDocument {
      * @returns Resolves with the embedded image.
      */
     embedPng(png: string | Uint8Array | ArrayBuffer): Promise<PDFImage>;
+    embedSvg(svg: string): Promise<PDFSvg>;
     /**
      * Embed one or more PDF pages into this document.
      *
@@ -725,6 +763,7 @@ export default class PDFDocument {
      * @returns Resolves with an array of the embedded pdf pages.
      */
     embedPages(pages: PDFPage[], boundingBoxes?: (PageBoundingBox | undefined)[], transformationMatrices?: (TransformationMatrix | undefined)[]): Promise<PDFEmbeddedPage[]>;
+    encrypt(options: SecurityOptions): void;
     /**
      * > **NOTE:** You shouldn't need to call this method directly. The [[save]]
      * > and [[saveAsBase64]] methods will automatically ensure that all embedded

package/ts3.4/cjs/api/PDFDocumentOptions.d.ts

@@ -1,5 +1,5 @@
-import { EmbeddedFileOptions } from "../core/embedders/FileEmbedder";
-import { TypeFeatures } from "../types/fontkit";
+import { EmbeddedFileOptions } from '../core/embedders/FileEmbedder';
+import { TypeFeatures } from '../types/fontkit';
 export declare enum ParseSpeeds {
     Fastest = Infinity,
     Fast = 1500,
@@ -25,8 +25,10 @@ export interface LoadOptions {
     ignoreEncryption?: boolean;
     parseSpeed?: ParseSpeeds | number;
     throwOnInvalidObject?: boolean;
+    warnOnInvalidObjects?: boolean;
     updateMetadata?: boolean;
     capNumbers?: boolean;
+    password?: string;
     forIncrementalUpdate?: boolean;
 }
 export interface CreateOptions {

package/ts3.4/cjs/api/PDFEmbeddedFile.d.ts

@@ -1,7 +1,7 @@
-import Embeddable from "./Embeddable";
-import PDFDocument from "./PDFDocument";
-import FileEmbedder from "../core/embedders/FileEmbedder";
-import { PDFRef } from "../core";
+import Embeddable from './Embeddable';
+import PDFDocument from './PDFDocument';
+import FileEmbedder from '../core/embedders/FileEmbedder';
+import { PDFRef } from '../core';
 /**
  * Represents a file that has been embedded in a [[PDFDocument]].
  */
@@ -35,5 +35,10 @@ export default class PDFEmbeddedFile implements Embeddable {
      * @returns Resolves when the embedding is complete.
      */
     embed(): Promise<void>;
+    /**
+     * Get the embedder used to embed the file.
+     * @returns the embedder.
+     */
+    getEmbedder(): FileEmbedder;
 }
 //# sourceMappingURL=PDFEmbeddedFile.d.ts.map

package/ts3.4/cjs/api/PDFEmbeddedPage.d.ts

@@ -1,6 +1,6 @@
-import Embeddable from "./Embeddable";
-import PDFDocument from "./PDFDocument";
-import { PDFPageEmbedder, PDFRef } from "../core";
+import Embeddable from './Embeddable';
+import PDFDocument from './PDFDocument';
+import { PDFPageEmbedder, PDFRef } from '../core';
 /**
  * Represents a PDF page that has been embedded in a [[PDFDocument]].
  */

package/ts3.4/cjs/api/PDFFont.d.ts

@@ -1,7 +1,7 @@
-import Embeddable from "./Embeddable";
-import PDFDocument from "./PDFDocument";
-import { CustomFontEmbedder, PDFHexString, PDFRef, StandardFontEmbedder } from "../core";
-export declare type FontEmbedder = CustomFontEmbedder | StandardFontEmbedder;
+import Embeddable from './Embeddable';
+import PDFDocument from './PDFDocument';
+import { CustomFontEmbedder, PDFHexString, PDFRef, StandardFontEmbedder } from '../core';
+export type FontEmbedder = CustomFontEmbedder | StandardFontEmbedder;
 /**
  * Represents a font that has been embedded in a [[PDFDocument]].
  */

package/ts3.4/cjs/api/PDFImage.d.ts

@@ -1,7 +1,7 @@
-import Embeddable from "./Embeddable";
-import PDFDocument from "./PDFDocument";
-import { JpegEmbedder, PDFRef, PngEmbedder } from "../core";
-export declare type ImageEmbedder = JpegEmbedder | PngEmbedder;
+import Embeddable from './Embeddable';
+import PDFDocument from './PDFDocument';
+import { JpegEmbedder, PDFRef, PngEmbedder } from '../core';
+export type ImageEmbedder = JpegEmbedder | PngEmbedder;
 /**
  * Represents an image that has been embedded in a [[PDFDocument]].
  */

package/ts3.4/cjs/api/PDFJavaScript.d.ts

@@ -1,7 +1,7 @@
-import Embeddable from "./Embeddable";
-import PDFDocument from "./PDFDocument";
-import JavaScriptEmbedder from "../core/embedders/JavaScriptEmbedder";
-import { PDFRef } from "../core";
+import Embeddable from './Embeddable';
+import PDFDocument from './PDFDocument';
+import JavaScriptEmbedder from '../core/embedders/JavaScriptEmbedder';
+import { PDFRef } from '../core';
 /**
  * Represents JavaScript that has been embedded in a [[PDFDocument]].
  */