@pdfme/pdf-lib 6.0.3 → 6.0.5-dev.1

package/src/utils/elements/Rectangle.ts

@@ -1,65 +0,0 @@
-import GraphElement from './GraphElement';
-import Point from './Point';
-import Segment from './Segment';
-
-export default class Rectangle extends GraphElement {
-  static type = 'Rectangle';
-  start: Point;
-  end: Point;
-  constructor(start: Point = new Point(), end: Point = new Point()) {
-    super();
-    this.start = start;
-    this.end = end;
-  }
-
-  getSize() {
-    const start = this.start.toCoords();
-    const end = this.end.toCoords();
-    return {
-      width: Math.abs(start.x - end.x),
-      height: Math.abs(start.y - end.y),
-    };
-  }
-
-  getCoords() {
-    const start = this.start.toCoords();
-    const end = this.end.toCoords();
-    return {
-      x: Math.min(start.x, end.x),
-      y: Math.max(start.y, end.y),
-    };
-  }
-
-  getStart() {
-    const start = new Point(this.getCoords());
-    return start;
-  }
-
-  getEnd() {
-    const { width, height } = this.getSize();
-    const end = new Point(this.getStart()).plus({ x: width, y: -height });
-    return end;
-  }
-
-  center() {
-    const center = new Segment(this.getStart(), this.getEnd()).middle();
-    return center;
-  }
-
-  isEqual(element: GraphElement): boolean {
-    return (
-      element instanceof Rectangle &&
-      this.getStart().isEqual(element.getStart()) &&
-      this.getEnd().isEqual(element.getEnd())
-    );
-  }
-
-  orthoProjection(P: Point) {
-    const { x, y } = this.getCoords();
-    const end = this.getEnd().toCoords();
-    const { x: Px, y: Py } = P.toCoords();
-    const Hx = Px < x ? x : Px > end.x ? end.x : Px;
-    const Hy = Py > y ? y : Py < end.y ? end.y : Py;
-    return new Point({ x: Hx, y: Hy });
-  }
-}

package/src/utils/elements/Segment.ts

@@ -1,81 +0,0 @@
-import { distance, isColinear, norm, scalar, vector, plus, times } from '../maths';
-
-import GraphElement from './GraphElement';
-import Line from './Line';
-import Point from './Point';
-
-export default class Segment extends GraphElement {
-  static type = 'Segment';
-  A: Point;
-  B: Point;
-  constructor(A: Point = new Point(), B: Point = new Point()) {
-    super();
-    this.A = A;
-    this.B = B;
-  }
-
-  origin(): Point {
-    return this.A;
-  }
-
-  destination(): Point {
-    return this.B;
-  }
-
-  dirVect() {
-    return vector(this.origin(), this.destination());
-  }
-
-  length() {
-    return distance(this.destination(), this.origin());
-  }
-
-  isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Segment)) return false;
-    const o = this.origin();
-    const dest = this.destination();
-    const oE = element.origin();
-    const destE = element.destination();
-    return (
-      element instanceof Segment &&
-      ((o.isEqual(oE) && dest.isEqual(destE)) || (o.isEqual(destE) && dest.isEqual(oE)))
-    );
-  }
-
-  /** Returns an equivalent line object */
-  getLine() {
-    const line = new Line(this.origin(), this.destination());
-    return line;
-  }
-
-  includes(P: Point) {
-    const vect = this.dirVect();
-    const otherVect = vector(this.origin(), P);
-    // The vectors are not even colinear
-    if (!isColinear(vect, otherVect)) return false;
-    // The point is behind the origin
-    else if (scalar(vect, otherVect) < 0) return false;
-    // The point is after the destination
-    else if (norm(vect) < norm(otherVect)) return false;
-    else return true;
-  }
-
-  middle() {
-    const mid = new Point(plus(this.origin().toCoords(), times(this.dirVect(), 0.5)));
-    return mid;
-  }
-
-  orthoProjection(P: Point) {
-    const H = this.getLine().orthoProjection(P);
-    const vect = this.dirVect();
-    const origin = this.origin().toCoords();
-    const destination = this.destination().toCoords();
-    const otherVect = vector(this.origin(), H);
-    // The point is before the origin
-    if (scalar(vect, otherVect) < 0) return new Point(origin);
-    // The point is after the destination
-    else if (norm(vect) < norm(otherVect)) return new Point(destination);
-    // The point is within the segment
-    else return H;
-  }
-}

package/src/utils/errors.ts

@@ -1,3 +0,0 @@
-export const error = (msg: string) => {
-  throw new Error(msg);
-};

package/src/utils/intersections.ts

@@ -1,237 +0,0 @@
-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 function 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 function intersection(A: GraphicElement, B: GraphicElement): Coordinates | undefined {
-  return intersections(A, B)[0];
-}
-
-function 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;
-}
-
-function 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;
-}
-
-function 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 delta = b ** 2 - (x ** 2 * b ** 2) / a ** 2;
-    if (delta < 0) return [];
-    else if (delta === 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 function 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 }];
-  }
-}
-
-function 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;
-}
-
-function 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 function 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 function 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))));
-  }
-}
-
-function 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 function 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

@@ -1,96 +0,0 @@
-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/numbers.ts

@@ -1,55 +0,0 @@
-// tslint:disable radix
-
-/**
- * Converts a number to its string representation in decimal. This function
- * differs from simply converting a number to a string with `.toString()`
- * because this function's output string will **not** contain exponential
- * notation.
- *
- * Credit: https://stackoverflow.com/a/46545519
- */
-export const numberToString = (num: number) => {
-  let numStr = String(num);
-
-  if (Math.abs(num) < 1.0) {
-    const e = parseInt(num.toString().split('e-')[1]);
-    if (e) {
-      const negative = num < 0;
-      if (negative) num *= -1;
-      num *= Math.pow(10, e - 1);
-      numStr = '0.' + Array(e).join('0') + num.toString().substring(2);
-      if (negative) numStr = '-' + numStr;
-    }
-  } else {
-    let e = parseInt(num.toString().split('+')[1]);
-    if (e > 20) {
-      e -= 20;
-      num /= Math.pow(10, e);
-      numStr = num.toString() + Array(e + 1).join('0');
-    }
-  }
-
-  return numStr;
-};
-
-export const sizeInBytes = (n: number) => Math.ceil(n.toString(2).length / 8);
-
-/**
- * Converts a number into its constituent bytes and returns them as
- * a number[].
- *
- * Returns most significant byte as first element in array. It may be necessary
- * to call .reverse() to get the bits in the desired order.
- *
- * Example:
- *   bytesFor(0x02A41E) => [ 0b10, 0b10100100, 0b11110 ]
- *
- * Credit for algorithm: https://stackoverflow.com/a/1936865
- */
-export const bytesFor = (n: number) => {
-  const bytes = new Uint8Array(sizeInBytes(n));
-  for (let i = 1; i <= bytes.length; i++) {
-    bytes[i - 1] = n >> ((bytes.length - i) * 8);
-  }
-  return bytes;
-};

package/src/utils/objects.ts

@@ -1,13 +0,0 @@
-import { FontNames } from '@pdf-lib/standard-fonts';
-
-export const values = (obj: any) => Object.keys(obj).map((k) => obj[k]);
-
-export const StandardFontValues = values(FontNames);
-
-export const isStandardFont = (input: any): input is FontNames =>
-  StandardFontValues.includes(input);
-
-export const rectanglesAreEqual = (
-  a: { x: number; y: number; width: number; height: number },
-  b: { x: number; y: number; width: number; height: number },
-) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;

package/src/utils/pdfDocEncoding.ts

@@ -1,69 +0,0 @@
-import { toCharCode } from './strings';
-
-// Mapping from PDFDocEncoding to Unicode code point
-const pdfDocEncodingToUnicode = new Uint16Array(256);
-
-// Initialize the code points which are the same
-for (let idx = 0; idx < 256; idx++) {
-  pdfDocEncodingToUnicode[idx] = idx;
-}
-
-// Set differences (see "Table D.2 – PDFDocEncoding Character Set" of the PDF spec)
-pdfDocEncodingToUnicode[0x16] = toCharCode('\u0017'); // SYNCRONOUS IDLE
-pdfDocEncodingToUnicode[0x18] = toCharCode('\u02D8'); // BREVE
-pdfDocEncodingToUnicode[0x19] = toCharCode('\u02C7'); // CARON
-pdfDocEncodingToUnicode[0x1a] = toCharCode('\u02C6'); // MODIFIER LETTER CIRCUMFLEX ACCENT
-pdfDocEncodingToUnicode[0x1b] = toCharCode('\u02D9'); // DOT ABOVE
-pdfDocEncodingToUnicode[0x1c] = toCharCode('\u02DD'); // DOUBLE ACUTE ACCENT
-pdfDocEncodingToUnicode[0x1d] = toCharCode('\u02DB'); // OGONEK
-pdfDocEncodingToUnicode[0x1e] = toCharCode('\u02DA'); // RING ABOVE
-pdfDocEncodingToUnicode[0x1f] = toCharCode('\u02DC'); // SMALL TILDE
-pdfDocEncodingToUnicode[0x7f] = toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
-pdfDocEncodingToUnicode[0x80] = toCharCode('\u2022'); // BULLET
-pdfDocEncodingToUnicode[0x81] = toCharCode('\u2020'); // DAGGER
-pdfDocEncodingToUnicode[0x82] = toCharCode('\u2021'); // DOUBLE DAGGER
-pdfDocEncodingToUnicode[0x83] = toCharCode('\u2026'); // HORIZONTAL ELLIPSIS
-pdfDocEncodingToUnicode[0x84] = toCharCode('\u2014'); // EM DASH
-pdfDocEncodingToUnicode[0x85] = toCharCode('\u2013'); // EN DASH
-pdfDocEncodingToUnicode[0x86] = toCharCode('\u0192'); // LATIN SMALL LETTER SCRIPT F
-pdfDocEncodingToUnicode[0x87] = toCharCode('\u2044'); // FRACTION SLASH (solidus)
-pdfDocEncodingToUnicode[0x88] = toCharCode('\u2039'); // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
-pdfDocEncodingToUnicode[0x89] = toCharCode('\u203A'); // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
-pdfDocEncodingToUnicode[0x8a] = toCharCode('\u2212'); // MINUS SIGN
-pdfDocEncodingToUnicode[0x8b] = toCharCode('\u2030'); // PER MILLE SIGN
-pdfDocEncodingToUnicode[0x8c] = toCharCode('\u201E'); // DOUBLE LOW-9 QUOTATION MARK (quotedblbase)
-pdfDocEncodingToUnicode[0x8d] = toCharCode('\u201C'); // LEFT DOUBLE QUOTATION MARK (quotedblleft)
-pdfDocEncodingToUnicode[0x8e] = toCharCode('\u201D'); // RIGHT DOUBLE QUOTATION MARK (quotedblright)
-pdfDocEncodingToUnicode[0x8f] = toCharCode('\u2018'); // LEFT SINGLE QUOTATION MARK (quoteleft)
-pdfDocEncodingToUnicode[0x90] = toCharCode('\u2019'); // RIGHT SINGLE QUOTATION MARK (quoteright)
-pdfDocEncodingToUnicode[0x91] = toCharCode('\u201A'); // SINGLE LOW-9 QUOTATION MARK (quotesinglbase)
-pdfDocEncodingToUnicode[0x92] = toCharCode('\u2122'); // TRADE MARK SIGN
-pdfDocEncodingToUnicode[0x93] = toCharCode('\uFB01'); // LATIN SMALL LIGATURE FI
-pdfDocEncodingToUnicode[0x94] = toCharCode('\uFB02'); // LATIN SMALL LIGATURE FL
-pdfDocEncodingToUnicode[0x95] = toCharCode('\u0141'); // LATIN CAPITAL LETTER L WITH STROKE
-pdfDocEncodingToUnicode[0x96] = toCharCode('\u0152'); // LATIN CAPITAL LIGATURE OE
-pdfDocEncodingToUnicode[0x97] = toCharCode('\u0160'); // LATIN CAPITAL LETTER S WITH CARON
-pdfDocEncodingToUnicode[0x98] = toCharCode('\u0178'); // LATIN CAPITAL LETTER Y WITH DIAERESIS
-pdfDocEncodingToUnicode[0x99] = toCharCode('\u017D'); // LATIN CAPITAL LETTER Z WITH CARON
-pdfDocEncodingToUnicode[0x9a] = toCharCode('\u0131'); // LATIN SMALL LETTER DOTLESS I
-pdfDocEncodingToUnicode[0x9b] = toCharCode('\u0142'); // LATIN SMALL LETTER L WITH STROKE
-pdfDocEncodingToUnicode[0x9c] = toCharCode('\u0153'); // LATIN SMALL LIGATURE OE
-pdfDocEncodingToUnicode[0x9d] = toCharCode('\u0161'); // LATIN SMALL LETTER S WITH CARON
-pdfDocEncodingToUnicode[0x9e] = toCharCode('\u017E'); // LATIN SMALL LETTER Z WITH CARON
-pdfDocEncodingToUnicode[0x9f] = toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
-pdfDocEncodingToUnicode[0xa0] = toCharCode('\u20AC'); // EURO SIGN
-pdfDocEncodingToUnicode[0xad] = toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
-
-/**
- * Decode a byte array into a string using PDFDocEncoding.
- *
- * @param bytes a byte array (decimal representation) containing a string
- *              encoded with PDFDocEncoding.
- */
-export const pdfDocEncodingDecode = (bytes: Uint8Array): string => {
-  const codePoints = Array<number>(bytes.length);
-  for (let idx = 0, len = bytes.length; idx < len; idx++) {
-    codePoints[idx] = pdfDocEncodingToUnicode[bytes[idx]];
-  }
-  return String.fromCodePoint(...codePoints);
-};