@adnsistemas/pdf-lib 1.18.0

package/src/utils/arrays.ts

@@ -0,0 +1,146 @@
+import { decodeFromBase64DataUri } from 'src/utils/base64';
+import { charFromCode } from 'src/utils/strings';
+
+export const last = <T>(array: T[]): T => array[array.length - 1];
+
+// export const dropLast = <T>(array: T[]): T[] =>
+// array.slice(0, array.length - 1);
+
+export const typedArrayFor = (value: string | Uint8Array): Uint8Array => {
+  if (value instanceof Uint8Array) return value;
+  const length = value.length;
+  const typedArray = new Uint8Array(length);
+  for (let idx = 0; idx < length; idx++) {
+    typedArray[idx] = value.charCodeAt(idx);
+  }
+  return typedArray;
+};
+
+export const mergeIntoTypedArray = (...arrays: (string | Uint8Array)[]) => {
+  const arrayCount = arrays.length;
+
+  const typedArrays: Uint8Array[] = [];
+  for (let idx = 0; idx < arrayCount; idx++) {
+    const element = arrays[idx];
+    typedArrays[idx] =
+      element instanceof Uint8Array ? element : typedArrayFor(element);
+  }
+
+  let totalSize = 0;
+  for (let idx = 0; idx < arrayCount; idx++) {
+    totalSize += arrays[idx].length;
+  }
+
+  const merged = new Uint8Array(totalSize);
+  let offset = 0;
+  for (let arrIdx = 0; arrIdx < arrayCount; arrIdx++) {
+    const arr = typedArrays[arrIdx];
+    for (let byteIdx = 0, arrLen = arr.length; byteIdx < arrLen; byteIdx++) {
+      merged[offset++] = arr[byteIdx];
+    }
+  }
+
+  return merged;
+};
+
+export const mergeUint8Arrays = (arrays: Uint8Array[]): Uint8Array => {
+  let totalSize = 0;
+  for (let idx = 0, len = arrays.length; idx < len; idx++) {
+    totalSize += arrays[idx].length;
+  }
+
+  const mergedBuffer = new Uint8Array(totalSize);
+  let offset = 0;
+  for (let idx = 0, len = arrays.length; idx < len; idx++) {
+    const array = arrays[idx];
+    mergedBuffer.set(array, offset);
+    offset += array.length;
+  }
+
+  return mergedBuffer;
+};
+
+export const arrayAsString = (array: Uint8Array | number[]): string => {
+  let str = '';
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    str += charFromCode(array[idx]);
+  }
+  return str;
+};
+
+export const byAscendingId = <T extends { id: any }>(a: T, b: T) => a.id - b.id;
+
+export const sortedUniq = <T>(array: T[], indexer: (elem: T) => any): T[] => {
+  const uniq: T[] = [];
+
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    const curr = array[idx];
+    const prev = array[idx - 1];
+    if (idx === 0 || indexer(curr) !== indexer(prev)) {
+      uniq.push(curr);
+    }
+  }
+
+  return uniq;
+};
+
+// Arrays and TypedArrays in JS both have .reverse() methods, which would seem
+// to negate the need for this function. However, not all runtimes support this
+// method (e.g. React Native). This function compensates for that fact.
+export const reverseArray = (array: Uint8Array) => {
+  const arrayLen = array.length;
+  for (let idx = 0, len = Math.floor(arrayLen / 2); idx < len; idx++) {
+    const leftIdx = idx;
+    const rightIdx = arrayLen - idx - 1;
+    const temp = array[idx];
+
+    array[leftIdx] = array[rightIdx];
+    array[rightIdx] = temp;
+  }
+  return array;
+};
+
+export const sum = (array: number[] | Uint8Array): number => {
+  let total = 0;
+  for (let idx = 0, len = array.length; idx < len; idx++) {
+    total += array[idx];
+  }
+  return total;
+};
+
+export const range = (start: number, end: number): number[] => {
+  const arr = new Array(end - start);
+  for (let idx = 0, len = arr.length; idx < len; idx++) {
+    arr[idx] = start + idx;
+  }
+  return arr;
+};
+
+export const pluckIndices = <T>(arr: T[], indices: number[]) => {
+  const plucked = new Array<T>(indices.length);
+  for (let idx = 0, len = indices.length; idx < len; idx++) {
+    plucked[idx] = arr[indices[idx]];
+  }
+  return plucked;
+};
+
+export const canBeConvertedToUint8Array = (
+  input: any,
+): input is string | ArrayBuffer | Uint8Array =>
+  input instanceof Uint8Array ||
+  input instanceof ArrayBuffer ||
+  typeof input === 'string';
+
+export const toUint8Array = (input: string | ArrayBuffer | Uint8Array) => {
+  if (typeof input === 'string') {
+    return decodeFromBase64DataUri(input);
+  } else if (input instanceof ArrayBuffer) {
+    return new Uint8Array(input);
+  } else if (input instanceof Uint8Array) {
+    return input;
+  } else {
+    throw new TypeError(
+      '`input` must be one of `string | ArrayBuffer | Uint8Array`',
+    );
+  }
+};

package/src/utils/async.ts

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

package/src/utils/base64.ts

@@ -0,0 +1,99 @@
+/*
+ * The `chars`, `lookup`, `encode`, and `decode` members of this file are
+ * licensed under the following:
+ *
+ *     base64-arraybuffer
+ *     https://github.com/niklasvh/base64-arraybuffer
+ *
+ *     Copyright (c) 2012 Niklas von Hertzen
+ *     Licensed under the MIT license.
+ *
+ */
+
+const chars =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+// Use a lookup table to find the index.
+const lookup = new Uint8Array(256);
+for (let i = 0; i < chars.length; i++) {
+  lookup[chars.charCodeAt(i)] = i;
+}
+
+export const encodeToBase64 = (bytes: Uint8Array): string => {
+  let base64 = '';
+  const len = bytes.length;
+  for (let i = 0; i < len; i += 3) {
+    base64 += chars[bytes[i] >> 2];
+    base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
+    base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
+    base64 += chars[bytes[i + 2] & 63];
+  }
+
+  if (len % 3 === 2) {
+    base64 = base64.substring(0, base64.length - 1) + '=';
+  } else if (len % 3 === 1) {
+    base64 = base64.substring(0, base64.length - 2) + '==';
+  }
+
+  return base64;
+};
+
+export const decodeFromBase64 = (base64: string): Uint8Array => {
+  let bufferLength = base64.length * 0.75;
+  const len = base64.length;
+  let i;
+  let p = 0;
+  let encoded1;
+  let encoded2;
+  let encoded3;
+  let encoded4;
+
+  if (base64[base64.length - 1] === '=') {
+    bufferLength--;
+    if (base64[base64.length - 2] === '=') {
+      bufferLength--;
+    }
+  }
+
+  const bytes = new Uint8Array(bufferLength);
+
+  for (i = 0; i < len; i += 4) {
+    encoded1 = lookup[base64.charCodeAt(i)];
+    encoded2 = lookup[base64.charCodeAt(i + 1)];
+    encoded3 = lookup[base64.charCodeAt(i + 2)];
+    encoded4 = lookup[base64.charCodeAt(i + 3)];
+
+    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+  }
+
+  return bytes;
+};
+
+// This regex is designed to be as flexible as possible. It will parse certain
+// invalid data URIs.
+const DATA_URI_PREFIX_REGEX = /^(data)?:?([\w\/\+]+)?;?(charset=[\w-]+|base64)?.*,/i;
+
+/**
+ * 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 const decodeFromBase64DataUri = (dataUri: string): Uint8Array => {
+  const trimmedUri = dataUri.trim();
+
+  const prefix = trimmedUri.substring(0, 100);
+  const res = prefix.match(DATA_URI_PREFIX_REGEX);
+
+  // Assume it's not a data URI - just a plain base64 string
+  if (!res) return decodeFromBase64(trimmedUri);
+
+  // Remove the data URI prefix and parse the remainder as a base64 string
+  const [fullMatch] = res;
+  const data = trimmedUri.substring(fullMatch.length);
+
+  return decodeFromBase64(data);
+};

package/src/utils/errors.ts

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

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+export * from 'src/utils/arrays';
+export * from 'src/utils/async';
+export * from 'src/utils/strings';
+export * from 'src/utils/unicode';
+export * from 'src/utils/numbers';
+export * from 'src/utils/errors';
+export * from 'src/utils/base64';
+export * from 'src/utils/objects';
+export * from 'src/utils/validators';
+export * from 'src/utils/pdfDocEncoding';
+export { default as Cache } from 'src/utils/Cache';

package/src/utils/numbers.ts

@@ -0,0 +1,55 @@
+// 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.' + new 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() + new 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,69 @@
+import { toCharCode } from 'src/utils/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 = new Array(bytes.length);
+  for (let idx = 0, len = bytes.length; idx < len; idx++) {
+    codePoints[idx] = pdfDocEncodingToUnicode[bytes[idx]];
+  }
+  return String.fromCodePoint(...codePoints);
+};

package/src/utils/png.ts

@@ -0,0 +1,70 @@
+import UPNG from '@pdf-lib/upng';
+
+const getImageType = (ctype: number) => {
+  if (ctype === 0) return PngType.Greyscale;
+  if (ctype === 2) return PngType.Truecolour;
+  if (ctype === 3) return PngType.IndexedColour;
+  if (ctype === 4) return PngType.GreyscaleWithAlpha;
+  if (ctype === 6) return PngType.TruecolourWithAlpha;
+  throw new Error(`Unknown color type: ${ctype}`);
+};
+
+const splitAlphaChannel = (rgbaChannel: Uint8Array) => {
+  const pixelCount = Math.floor(rgbaChannel.length / 4);
+
+  const rgbChannel = new Uint8Array(pixelCount * 3);
+  const alphaChannel = new Uint8Array(pixelCount * 1);
+
+  let rgbaOffset = 0;
+  let rgbOffset = 0;
+  let alphaOffset = 0;
+
+  while (rgbaOffset < rgbaChannel.length) {
+    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
+    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
+    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
+    alphaChannel[alphaOffset++] = rgbaChannel[rgbaOffset++];
+  }
+
+  return { rgbChannel, alphaChannel };
+};
+
+export enum PngType {
+  Greyscale = 'Greyscale',
+  Truecolour = 'Truecolour',
+  IndexedColour = 'IndexedColour',
+  GreyscaleWithAlpha = 'GreyscaleWithAlpha',
+  TruecolourWithAlpha = 'TruecolourWithAlpha',
+}
+
+export class PNG {
+  static load = (pngData: Uint8Array) => new PNG(pngData);
+
+  readonly rgbChannel: Uint8Array;
+  readonly alphaChannel?: Uint8Array;
+  readonly type: PngType;
+  readonly width: number;
+  readonly height: number;
+  readonly bitsPerComponent: number;
+
+  private constructor(pngData: Uint8Array) {
+    const upng = UPNG.decode(pngData);
+    const frames = UPNG.toRGBA8(upng);
+
+    if (frames.length > 1) throw new Error(`Animated PNGs are not supported`);
+
+    const frame = new Uint8Array(frames[0]);
+    const { rgbChannel, alphaChannel } = splitAlphaChannel(frame);
+
+    this.rgbChannel = rgbChannel;
+
+    const hasAlphaValues = alphaChannel.some((a) => a < 255);
+    if (hasAlphaValues) this.alphaChannel = alphaChannel;
+
+    this.type = getImageType(upng.ctype);
+
+    this.width = upng.width;
+    this.height = upng.height;
+    this.bitsPerComponent = 8;
+  }
+}

package/src/utils/rng.ts

@@ -0,0 +1,21 @@
+/**
+ * Generates a pseudo random number. Although it is not cryptographically secure
+ * and uniformly distributed, it is not a concern for the intended use-case,
+ * which is to generate distinct numbers.
+ *
+ * Credit: https://stackoverflow.com/a/19303725/10254049
+ */
+export class SimpleRNG {
+  static withSeed = (seed: number) => new SimpleRNG(seed);
+
+  private seed: number;
+
+  private constructor(seed: number) {
+    this.seed = seed;
+  }
+
+  nextInt(): number {
+    const x = Math.sin(this.seed++) * 10000;
+    return x - Math.floor(x);
+  }
+}

package/src/utils/strings.ts

@@ -0,0 +1,182 @@
+export const toCharCode = (character: string) => character.charCodeAt(0);
+
+export const toCodePoint = (character: string) => character.codePointAt(0);
+
+export const toHexStringOfMinLength = (num: number, minLength: number) =>
+  padStart(num.toString(16), minLength, '0').toUpperCase();
+
+export const toHexString = (num: number) => toHexStringOfMinLength(num, 2);
+
+export const charFromCode = (code: number) => String.fromCharCode(code);
+
+export const charFromHexCode = (hex: string) => charFromCode(parseInt(hex, 16));
+
+export const padStart = (value: string, length: number, padChar: string) => {
+  let padding = '';
+  for (let idx = 0, len = length - value.length; idx < len; idx++) {
+    padding += padChar;
+  }
+  return padding + value;
+};
+
+export const copyStringIntoBuffer = (
+  str: string,
+  buffer: Uint8Array,
+  offset: number,
+): number => {
+  const length = str.length;
+  for (let idx = 0; idx < length; idx++) {
+    buffer[offset++] = str.charCodeAt(idx);
+  }
+  return length;
+};
+
+export const addRandomSuffix = (prefix: string, suffixLength = 4) =>
+  `${prefix}-${Math.floor(Math.random() * 10 ** suffixLength)}`;
+
+export const escapeRegExp = (str: string) =>
+  str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+export const cleanText = (text: string) =>
+  text.replace(/\t|\u0085|\u2028|\u2029/g, '    ').replace(/[\b\v]/g, '');
+
+export const escapedNewlineChars = ['\\n', '\\f', '\\r', '\\u000B'];
+
+export const newlineChars = ['\n', '\f', '\r', '\u000B'];
+
+export const isNewlineChar = (text: string) => /^[\n\f\r\u000B]$/.test(text);
+
+export const lineSplit = (text: string) => text.split(/[\n\f\r\u000B]/);
+
+export const mergeLines = (text: string) =>
+  text.replace(/[\n\f\r\u000B]/g, ' ');
+
+// JavaScript's String.charAt() method doesn work on strings containing UTF-16
+// characters (with high and low surrogate pairs), such as 💩 (poo emoji). This
+// `charAtIndex()` function does.
+//
+// Credit: https://github.com/mathiasbynens/String.prototype.at/blob/master/at.js#L14-L48
+export const charAtIndex = (text: string, index: number): [string, number] => {
+  // Get the first code unit and code unit value
+  const cuFirst = text.charCodeAt(index);
+  let cuSecond: number;
+  const nextIndex = index + 1;
+  let length = 1;
+  if (
+    // Check if it's the start of a surrogate pair.
+    cuFirst >= 0xd800 &&
+    cuFirst <= 0xdbff && // high surrogate
+    text.length > nextIndex // there is a next code unit
+  ) {
+    cuSecond = text.charCodeAt(nextIndex);
+    if (cuSecond >= 0xdc00 && cuSecond <= 0xdfff) length = 2; // low surrogate
+  }
+  return [text.slice(index, index + length), length];
+};
+
+export const charSplit = (text: string) => {
+  const chars: string[] = [];
+
+  for (let idx = 0, len = text.length; idx < len; ) {
+    const [c, cLen] = charAtIndex(text, idx);
+    chars.push(c);
+    idx += cLen;
+  }
+
+  return chars;
+};
+
+const buildWordBreakRegex = (wordBreaks: string[]) => {
+  const newlineCharUnion = escapedNewlineChars.join('|');
+
+  const escapedRules: string[] = ['$'];
+  for (let idx = 0, len = wordBreaks.length; idx < len; idx++) {
+    const wordBreak = wordBreaks[idx];
+    if (isNewlineChar(wordBreak)) {
+      throw new TypeError(`\`wordBreak\` must not include ${newlineCharUnion}`);
+    }
+    escapedRules.push(wordBreak === '' ? '.' : escapeRegExp(wordBreak));
+  }
+
+  const breakRules = escapedRules.join('|');
+  return new RegExp(`(${newlineCharUnion})|((.*?)(${breakRules}))`, 'gm');
+};
+
+export const breakTextIntoLines = (
+  text: string,
+  wordBreaks: string[],
+  maxWidth: number,
+  computeWidthOfText: (t: string) => number,
+): string[] => {
+  const regex = buildWordBreakRegex(wordBreaks);
+
+  const words = cleanText(text).match(regex)!;
+
+  let currLine = '';
+  let currWidth = 0;
+  const lines: string[] = [];
+
+  const pushCurrLine = () => {
+    if (currLine !== '') lines.push(currLine);
+    currLine = '';
+    currWidth = 0;
+  };
+
+  for (let idx = 0, len = words.length; idx < len; idx++) {
+    const word = words[idx];
+    if (isNewlineChar(word)) {
+      pushCurrLine();
+    } else {
+      const width = computeWidthOfText(word);
+      if (currWidth + width > maxWidth) pushCurrLine();
+      currLine += word;
+      currWidth += width;
+    }
+  }
+  pushCurrLine();
+
+  return lines;
+};
+
+// 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)?'?$/;
+
+export const parseDate = (dateStr: string): Date | undefined => {
+  const match = dateStr.match(dateRegex);
+
+  if (!match) return undefined;
+
+  const [
+    ,
+    year,
+    month = '01',
+    day = '01',
+    hours = '00',
+    mins = '00',
+    secs = '00',
+    offsetSign = 'Z',
+    offsetHours = '00',
+    offsetMins = '00',
+  ] = match;
+
+  // http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15
+  const tzOffset =
+    offsetSign === 'Z' ? 'Z' : `${offsetSign}${offsetHours}:${offsetMins}`;
+  const date = new Date(
+    `${year}-${month}-${day}T${hours}:${mins}:${secs}${tzOffset}`,
+  );
+
+  return date;
+};
+
+export const findLastMatch = (value: string, regex: RegExp) => {
+  let position = 0;
+  let lastMatch: RegExpMatchArray | undefined;
+  while (position < value.length) {
+    const match = value.substring(position).match(regex);
+    if (!match) return { match: lastMatch, pos: position };
+    lastMatch = match;
+    position += (match.index ?? 0) + match[0].length;
+  }
+  return { match: lastMatch, pos: position };
+};