@pdfme/pdf-lib 5.4.0-dev.63 → 5.4.0-dev.66

package/src/utils/elements/Ellipse.ts

@@ -19,11 +19,7 @@ export default class Ellipse extends GraphElement {
   B: Point;
   C: Point;
 
-  constructor(
-    A: Point = new Point(),
-    B: Point = new Point(),
-    C: Point = new Point(),
-  ) {
+  constructor(A: Point = new Point(), B: Point = new Point(), C: Point = new Point()) {
     super();
     this.A = A;
     this.B = B;
@@ -75,10 +71,7 @@ export default class Ellipse extends GraphElement {
       return (
         isEqual(eltA, a) &&
         isEqual(eltB, b) &&
-        isEqual(
-          rotation + (Math.PI % Math.PI),
-          eltRotation + (Math.PI % Math.PI),
-        )
+        isEqual(rotation + (Math.PI % Math.PI), eltRotation + (Math.PI % Math.PI))
       );
     }
     // If the small axis is different
@@ -87,10 +80,7 @@ export default class Ellipse extends GraphElement {
       return (
         isEqual(eltA, b) &&
         isEqual(eltB, a) &&
-        isEqual(
-          rotation + (Math.PI % Math.PI),
-          eltRotation + (((3 * Math.PI) / 2) % Math.PI),
-        )
+        isEqual(rotation + (Math.PI % Math.PI), eltRotation + (((3 * Math.PI) / 2) % Math.PI))
       );
     }
   }
@@ -100,14 +90,8 @@ export default class Ellipse extends GraphElement {
     const { x: cx, y: cy } = this.center().toCoords();
     const teta = this.rotation();
     return isEqual(
-      Math.pow(
-        ((x - cx) * Math.cos(teta) + (y - cy) * Math.sin(teta)) / this.a(),
-        2,
-      ) +
-        Math.pow(
-          ((x - cx) * Math.sin(teta) - (y - cy) * Math.cos(teta)) / this.b(),
-          2,
-        ),
+      Math.pow(((x - cx) * Math.cos(teta) + (y - cy) * Math.sin(teta)) / this.a(), 2) +
+        Math.pow(((x - cx) * Math.sin(teta) - (y - cy) * Math.cos(teta)) / this.b(), 2),
       1,
     );
   }
@@ -128,8 +112,6 @@ export default class Ellipse extends GraphElement {
     const a = this.a();
     const b = this.b();
     const excentricity = Math.sqrt(Math.abs(a * a - b * b)) / Math.max(a, b);
-    return (
-      Math.min(a, b) / Math.sqrt(1 - Math.pow(excentricity * Math.cos(teta), 2))
-    );
+    return Math.min(a, b) / Math.sqrt(1 - Math.pow(excentricity * Math.cos(teta), 2));
   }
 }

package/src/utils/elements/Line.ts

@@ -64,9 +64,7 @@ export default class Line extends GraphElement {
   includes(P: Point) {
     const { x, y } = P.toCoords();
     const vect = this.dirVect();
-    return isEqual(vect.x, 0)
-      ? isEqual(this.origin().toCoords().x, x)
-      : isEqual(this.y(x), y);
+    return isEqual(vect.x, 0) ? isEqual(this.origin().toCoords().x, x) : isEqual(this.y(x), y);
   }
 
   /** This is used to standarsize type Segment | HalfLine | Line */

package/src/utils/elements/Segment.ts

@@ -1,12 +1,4 @@
-import {
-  distance,
-  isColinear,
-  norm,
-  scalar,
-  vector,
-  plus,
-  times,
-} from '../maths';
+import { distance, isColinear, norm, scalar, vector, plus, times } from '../maths';
 
 import GraphElement from './GraphElement';
 import Line from './Line';
@@ -46,8 +38,7 @@ export default class Segment extends GraphElement {
     const destE = element.destination();
     return (
       element instanceof Segment &&
-      ((o.isEqual(oE) && dest.isEqual(destE)) ||
-        (o.isEqual(destE) && dest.isEqual(oE)))
+      ((o.isEqual(oE) && dest.isEqual(destE)) || (o.isEqual(destE) && dest.isEqual(oE)))
     );
   }
 
@@ -70,9 +61,7 @@ export default class Segment extends GraphElement {
   }
 
   middle() {
-    const mid = new Point(
-      plus(this.origin().toCoords(), times(this.dirVect(), 0.5)),
-    );
+    const mid = new Point(plus(this.origin().toCoords(), times(this.dirVect(), 0.5)));
     return mid;
   }
 

package/src/utils/intersections.ts

@@ -19,66 +19,44 @@ import {
   rotate,
 } from './maths';
 
-export function intersections(
-  A: GraphicElement,
-  B: GraphicElement,
-): Coordinates[] {
+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)),
-    );
+    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)),
-    );
+    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 {
+export function intersection(A: GraphicElement, B: GraphicElement): Coordinates | undefined {
   return intersections(A, B)[0];
 }
 
-function intersectionsLine(
-  A: Line,
-  B: Exclude<GraphicElement, Text | Point>,
-): Coordinates[] {
+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)),
-    );
+    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)),
-    );
+    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[] {
+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)),
-    );
+    return intersectionsEllipse(A, B.getLine()).filter((P) => B.includes(new Point(P)));
   }
   // TODO:
   // else if (B instanceof Circle) return intersectionEllipseCircle(B, A)
@@ -87,9 +65,7 @@ function intersectionsEllipse(
   // 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)),
-    );
+    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;
@@ -112,17 +88,10 @@ function intersectionsLineAndEllipse(A: Ellipse, B: Line): Coordinates[] {
   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 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 angular = (p1Normalized.y - p2Normalized.y) / (p1Normalized.x - p2Normalized.x);
   const linear = p1Normalized.y - angular * p1Normalized.x;
 
   const lineY = (x: number) => angular * x + linear;
@@ -184,10 +153,8 @@ export function intersectionLine(A: Line, B: Line): Coordinates[] {
     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);
+    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 }];
   }
 }
@@ -195,18 +162,13 @@ export function intersectionLine(A: Line, B: Line): Coordinates[] {
 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),
-  );
+  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[] {
+function intersectionsRectangle(A: Rectangle, B: GraphicElement): Coordinates[] {
   const P1 = A.getCoords();
   const P3 = A.getEnd();
   const P2 = { x: P1.x, y: P3.y };
@@ -251,20 +213,13 @@ export function intersectionCircle(A: Circle, B: Circle): Coordinates[] {
   }
 }
 
-function intersectionsCircle(
-  A: Circle,
-  B: Exclude<GraphicElement, Text | Point>,
-): Coordinates[] {
+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)),
-    );
+    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)),
-    );
+    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);

package/src/utils/maths.ts

@@ -7,12 +7,10 @@ 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));
+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);
+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 => ({
@@ -21,10 +19,8 @@ export const orthogonal = ({ x, y }: Coordinates): Coordinates => ({
 });
 
 /** 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);
+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 =>
@@ -35,10 +31,8 @@ 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;
+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 = (
@@ -53,12 +47,10 @@ export const times = ({ x, y }: Coordinates, k = 1): Coordinates => ({
 });
 
 /** Calculate the difference of 2 vectors */
-export const minus = (u: Coordinates, v: Coordinates): Coordinates =>
-  plus(u, times(v, -1));
+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());
+export const vector = (A: Point, B: Point): Coordinates => minus(B.toCoords(), A.toCoords());
 
 /**
  * Returns the angle between the vector and the horizontal axis (Ox).
@@ -92,12 +84,8 @@ export const angle = (u: Coordinates, v: Coordinates, previousAngle = 0) => {
 /** 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);
+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 => {

package/src/utils/strings.ts

@@ -25,11 +25,7 @@ export const stringAsByteArray = (str: string): Uint8Array => {
   return buffer;
 };
 
-export const copyStringIntoBuffer = (
-  str: string,
-  buffer: Uint8Array,
-  offset: number,
-): number => {
+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);
@@ -40,8 +36,7 @@ export const copyStringIntoBuffer = (
 export const addRandomSuffix = (prefix: string, suffixLength = 4) =>
   `${prefix}-${Math.floor(Math.random() * 10 ** suffixLength)}`;
 
-export const escapeRegExp = (str: string) =>
-  str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export const escapeRegExp = (str: string) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
 export const cleanText = (text: string) =>
   text.replace(/\t|\u0085|\u2028|\u2029/g, '    ').replace(/[\b\v]/g, '');
@@ -54,8 +49,7 @@ 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, ' ');
+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
@@ -145,8 +139,7 @@ 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);
@@ -167,11 +160,8 @@ export const parseDate = (dateStr: string): Date | undefined => {
   ] = 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}`,
-  );
+  const tzOffset = offsetSign === 'Z' ? 'Z' : `${offsetSign}${offsetHours}:${offsetMins}`;
+  const date = new Date(`${year}-${month}-${day}T${hours}:${mins}:${secs}${tzOffset}`);
 
   return date;
 };

package/src/utils/unicode.ts

@@ -200,10 +200,7 @@ export const utf8Encode = (input: string, byteOrderMark = true): Uint8Array => {
  *   - [3] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
  *
  */
-export const utf16Encode = (
-  input: string,
-  byteOrderMark = true,
-): Uint16Array => {
+export const utf16Encode = (input: string, byteOrderMark = true): Uint16Array => {
   const encoded = [];
 
   if (byteOrderMark) encoded.push(0xfeff);
@@ -238,8 +235,7 @@ export const utf16Encode = (
  *
  * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
  */
-export const isWithinBMP = (codePoint: number) =>
-  codePoint >= 0 && codePoint <= 0xffff;
+export const isWithinBMP = (codePoint: number) => codePoint >= 0 && codePoint <= 0xffff;
 
 /**
  * Returns `true` if the given `codePoint` is valid and must be represented
@@ -248,8 +244,7 @@ export const isWithinBMP = (codePoint: number) =>
  *
  * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
  */
-export const hasSurrogates = (codePoint: number) =>
-  codePoint >= 0x010000 && codePoint <= 0x10ffff;
+export const hasSurrogates = (codePoint: number) => codePoint >= 0x010000 && codePoint <= 0x10ffff;
 
 // From Unicode 3.0 spec, section 3.7:
 //   http://unicode.org/versions/Unicode3.0.0/ch03.pdf
@@ -258,8 +253,7 @@ export const highSurrogate = (codePoint: number) =>
 
 // From Unicode 3.0 spec, section 3.7:
 //   http://unicode.org/versions/Unicode3.0.0/ch03.pdf
-export const lowSurrogate = (codePoint: number) =>
-  ((codePoint - 0x10000) % 0x400) + 0xdc00;
+export const lowSurrogate = (codePoint: number) => ((codePoint - 0x10000) % 0x400) + 0xdc00;
 
 enum ByteOrder {
   BigEndian = 'BigEndian',
@@ -280,10 +274,7 @@ const REPLACEMENT = '�'.codePointAt(0)!;
  *                      at the start of the encoding. (default `true`)
  * @returns The decoded string.
  */
-export const utf16Decode = (
-  input: Uint8Array,
-  byteOrderMark = true,
-): string => {
+export const utf16Decode = (input: Uint8Array, byteOrderMark = true): string => {
   // Need at least 2 bytes of data in UTF-16 encodings
   if (input.length <= 1) return String.fromCodePoint(REPLACEMENT);
 
@@ -332,8 +323,7 @@ export const utf16Decode = (
  *
  * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
  */
-const isHighSurrogate = (codePoint: number) =>
-  codePoint >= 0xd800 && codePoint <= 0xdbff;
+const isHighSurrogate = (codePoint: number) => codePoint >= 0xd800 && codePoint <= 0xdbff;
 
 /**
  * Returns `true` if the given `codePoint` is a low surrogate.
@@ -341,8 +331,7 @@ const isHighSurrogate = (codePoint: number) =>
  *
  * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
  */
-const isLowSurrogate = (codePoint: number) =>
-  codePoint >= 0xdc00 && codePoint <= 0xdfff;
+const isLowSurrogate = (codePoint: number) => codePoint >= 0xdc00 && codePoint <= 0xdfff;
 
 /**
  * Decodes the given utf-16 values first and second using the specified
@@ -376,11 +365,9 @@ const readBOM = (bytes: Uint8Array): ByteOrder => (
   : ByteOrder.BigEndian
 );
 
-const hasUtf16BigEndianBOM = (bytes: Uint8Array) =>
-  bytes[0] === 0xfe && bytes[1] === 0xff;
+const hasUtf16BigEndianBOM = (bytes: Uint8Array) => bytes[0] === 0xfe && bytes[1] === 0xff;
 
-const hasUtf16LittleEndianBOM = (bytes: Uint8Array) =>
-  bytes[0] === 0xff && bytes[1] === 0xfe;
+const hasUtf16LittleEndianBOM = (bytes: Uint8Array) => bytes[0] === 0xff && bytes[1] === 0xfe;
 
 export const hasUtf16BOM = (bytes: Uint8Array) =>
   hasUtf16BigEndianBOM(bytes) || hasUtf16LittleEndianBOM(bytes);

package/src/utils/validators.ts

@@ -15,11 +15,7 @@ const formatValue = (value: any) => {
   else return value;
 };
 
-export const createValueErrorMsg = (
-  value: any,
-  valueName: string,
-  values: Primitive[],
-) => {
+export const createValueErrorMsg = (value: any, valueName: string, values: Primitive[]) => {
   const allowedValues = new Array(values.length);
 
   for (let idx = 0, len = values.length; idx < len; idx++) {
@@ -117,11 +113,7 @@ export const isType = (value: any, type: TypeDescriptor) => {
   return value instanceof (type as [Function, string])[0];
 };
 
-export const createTypeErrorMsg = (
-  value: any,
-  valueName: string,
-  types: TypeDescriptor[],
-) => {
+export const createTypeErrorMsg = (value: any, valueName: string, types: TypeDescriptor[]) => {
   const allowedTypes = new Array(types.length);
 
   for (let idx = 0, len = types.length; idx < len; idx++) {
@@ -145,41 +137,24 @@ export const createTypeErrorMsg = (
   return `${backtick(valueName)} must be of type ${joinedTypes}, but was actually of type ${backtick(getType(value))}`;
 };
 
-export const assertIs = (
-  value: any,
-  valueName: string,
-  types: TypeDescriptor[],
-) => {
+export const assertIs = (value: any, valueName: string, types: TypeDescriptor[]) => {
   for (let idx = 0, len = types.length; idx < len; idx++) {
     if (isType(value, types[idx])) return;
   }
   throw new TypeError(createTypeErrorMsg(value, valueName, types));
 };
 
-export const assertOrUndefined = (
-  value: any,
-  valueName: string,
-  types: TypeDescriptor[],
-) => {
+export const assertOrUndefined = (value: any, valueName: string, types: TypeDescriptor[]) => {
   assertIs(value, valueName, types.concat('undefined'));
 };
 
-export const assertEachIs = (
-  values: any[],
-  valueName: string,
-  types: TypeDescriptor[],
-) => {
+export const assertEachIs = (values: any[], valueName: string, types: TypeDescriptor[]) => {
   for (let idx = 0, len = values.length; idx < len; idx++) {
     assertIs(values[idx], valueName, types);
   }
 };
 
-export const assertRange = (
-  value: any,
-  valueName: string,
-  min: number,
-  max: number,
-) => {
+export const assertRange = (value: any, valueName: string, min: number, max: number) => {
   assertIs(value, valueName, ['number']);
   assertIs(min, 'min', ['number']);
   assertIs(max, 'max', ['number']);
@@ -190,21 +165,12 @@ export const assertRange = (
   }
 };
 
-export const assertRangeOrUndefined = (
-  value: any,
-  valueName: string,
-  min: number,
-  max: number,
-) => {
+export const assertRangeOrUndefined = (value: any, valueName: string, min: number, max: number) => {
   assertIs(value, valueName, ['number', 'undefined']);
   if (typeof value === 'number') assertRange(value, valueName, min, max);
 };
 
-export const assertMultiple = (
-  value: any,
-  valueName: string,
-  multiplier: number,
-) => {
+export const assertMultiple = (value: any, valueName: string, multiplier: number) => {
   assertIs(value, valueName, ['number']);
   if (value % multiplier !== 0) {
     // prettier-ignore
@@ -214,9 +180,7 @@ export const assertMultiple = (
 
 export const assertInteger = (value: any, valueName: string) => {
   if (!Number.isInteger(value)) {
-    throw new Error(
-      `${backtick(valueName)} must be an integer, but was actually ${value}`,
-    );
+    throw new Error(`${backtick(valueName)} must be an integer, but was actually ${value}`);
   }
 };