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

package/src/core/streams/Ascii85Stream.ts

@@ -9,8 +9,7 @@
 import DecodeStream from './DecodeStream';
 import { StreamType } from './Stream';
 
-const isSpace = (ch: number) =>
-  ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
+const isSpace = (ch: number) => ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
 
 class Ascii85Stream extends DecodeStream {
   private stream: StreamType;

package/src/core/streams/DecryptStream.ts

@@ -3,10 +3,7 @@ import { StreamType } from './Stream';
 
 const chunkSize = 512;
 
-type DecryptFnType = (
-  arg1: Uint8Array | Uint8ClampedArray,
-  arg2: boolean,
-) => Uint8Array;
+type DecryptFnType = (arg1: Uint8Array | Uint8ClampedArray, arg2: boolean) => Uint8Array;
 
 class DecryptStream extends DecodeStream {
   private stream: StreamType;
@@ -14,11 +11,7 @@ class DecryptStream extends DecodeStream {
   private nextChunk: Uint8Array | Uint8ClampedArray | null;
   private decrypt: DecryptFnType;
 
-  constructor(
-    stream: StreamType,
-    decrypt: DecryptFnType,
-    maybeLength?: number,
-  ) {
+  constructor(stream: StreamType, decrypt: DecryptFnType, maybeLength?: number) {
     super(maybeLength);
 
     this.stream = stream;

package/src/core/streams/FlateStream.ts

@@ -131,9 +131,7 @@ class FlateStream extends DecodeStream {
       throw new Error(`Invalid header in flate stream: ${cmf}, ${flg}`);
     }
     if ((cmf & 0x0f) !== 0x08) {
-      throw new Error(
-        `Unknown compression method in flate stream: ${cmf}, ${flg}`,
-      );
+      throw new Error(`Unknown compression method in flate stream: ${cmf}, ${flg}`);
     }
     if (((cmf << 8) + flg) % 31 !== 0) {
       throw new Error(`Bad FCHECK in flate stream: ${cmf}, ${flg}`);
@@ -259,12 +257,8 @@ class FlateStream extends DecodeStream {
         }
       }
 
-      litCodeTable = this.generateHuffmanTable(
-        codeLengths.subarray(0, numLitCodes),
-      );
-      distCodeTable = this.generateHuffmanTable(
-        codeLengths.subarray(numLitCodes, codes),
-      );
+      litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
+      distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
     } else {
       throw new Error('Unknown block type in flate stream');
     }
@@ -376,11 +370,7 @@ class FlateStream extends DecodeStream {
     // build the table
     const size = 1 << maxLen;
     const codes = new Int32Array(size);
-    for (
-      let len = 1, code = 0, skip = 2;
-      len <= maxLen;
-      ++len, code <<= 1, skip <<= 1
-    ) {
+    for (let len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
       for (let val = 0; val < n; ++val) {
         if (lengths[val] === len) {
           // bit-reverse the code

package/src/core/streams/LZWStream.ts

@@ -25,11 +25,7 @@ class LZWStream extends DecodeStream {
     prevCode?: number | null;
   };
 
-  constructor(
-    stream: StreamType,
-    maybeLength: number | undefined,
-    earlyChange: 0 | 1,
-  ) {
+  constructor(stream: StreamType, maybeLength: number | undefined, earlyChange: 0 | 1) {
     super(maybeLength);
 
     this.stream = stream;
@@ -117,10 +113,7 @@ class LZWStream extends DecodeStream {
         codeLength =
           (nextCode + earlyChange) & (nextCode + earlyChange - 1)
             ? codeLength
-            : Math.min(
-                Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1,
-                12,
-              ) | 0;
+            : Math.min(Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1, 12) | 0;
       }
       prevCode = code;
 

package/src/core/streams/Stream.ts

@@ -11,15 +11,9 @@ export interface StreamType {
   getByte(): number;
   getUint16(): number;
   getInt32(): number;
-  getBytes(
-    length: number,
-    forceClamped?: boolean,
-  ): Uint8Array | Uint8ClampedArray;
+  getBytes(length: number, forceClamped?: boolean): Uint8Array | Uint8ClampedArray;
   peekByte(): number;
-  peekBytes(
-    length: number,
-    forceClamped?: boolean,
-  ): Uint8Array | Uint8ClampedArray;
+  peekBytes(length: number, forceClamped?: boolean): Uint8Array | Uint8ClampedArray;
   skip(n: number): void;
   reset(): void;
   makeSubStream(start: number, length: number): StreamType;

package/src/core/streams/decode.ts

@@ -42,11 +42,7 @@ const decodeStream = (
   throw new UnsupportedEncodingError(encoding.asString());
 };
 
-export const decodePDFRawStream = ({
-  dict,
-  contents,
-  transform,
-}: PDFRawStream) => {
+export const decodePDFRawStream = ({ dict, contents, transform }: PDFRawStream) => {
   let stream: StreamType = new Stream(contents);
 
   if (transform) {
@@ -57,11 +53,7 @@ export const decodePDFRawStream = ({
   const DecodeParms = dict.lookup(PDFName.of('DecodeParms'));
 
   if (Filter instanceof PDFName) {
-    stream = decodeStream(
-      stream,
-      Filter,
-      DecodeParms as PDFDict | typeof PDFNull | undefined,
-    );
+    stream = decodeStream(stream, Filter, DecodeParms as PDFDict | typeof PDFNull | undefined);
   } else if (Filter instanceof PDFArray) {
     for (let idx = 0, len = Filter.size(); idx < len; idx++) {
       stream = decodeStream(

package/src/core/structures/PDFCatalog.ts

@@ -7,18 +7,14 @@ import { PDFAcroForm } from '../acroform';
 import ViewerPreferences from '../interactive/ViewerPreferences';
 
 class PDFCatalog extends PDFDict {
-  static withContextAndPages = (
-    context: PDFContext,
-    pages: PDFPageTree | PDFRef,
-  ) => {
+  static withContextAndPages = (context: PDFContext, pages: PDFPageTree | PDFRef) => {
     const dict = new Map();
     dict.set(PDFName.of('Type'), PDFName.of('Catalog'));
     dict.set(PDFName.of('Pages'), pages);
     return new PDFCatalog(dict, context);
   };
 
-  static fromMapWithContext = (map: DictMap, context: PDFContext) =>
-    new PDFCatalog(map, context);
+  static fromMapWithContext = (map: DictMap, context: PDFContext) => new PDFCatalog(map, context);
 
   Pages(): PDFPageTree {
     return this.lookup(PDFName.of('Pages'), PDFDict) as PDFPageTree;

package/src/core/structures/PDFCrossRefStream.ts

@@ -102,11 +102,7 @@ class PDFCrossRefStream extends PDFFlateStream {
     const byteWidths = this.maxByteWidthsCache.access();
     let value = '';
 
-    for (
-      let entryIdx = 0, entriesLen = entryTuples.length;
-      entryIdx < entriesLen;
-      entryIdx++
-    ) {
+    for (let entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) {
       const [first, second, third] = entryTuples[entryIdx];
 
       const firstBytes = reverseArray(bytesFor(first));
@@ -133,11 +129,7 @@ class PDFCrossRefStream extends PDFFlateStream {
     const buffer = new Uint8Array(this.getUnencodedContentsSize());
 
     let offset = 0;
-    for (
-      let entryIdx = 0, entriesLen = entryTuples.length;
-      entryIdx < entriesLen;
-      entryIdx++
-    ) {
+    for (let entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) {
       const [first, second, third] = entryTuples[entryIdx];
 
       const firstBytes = reverseArray(bytesFor(first));

package/src/core/structures/PDFFlateStream.ts

@@ -33,10 +33,7 @@ class PDFFlateStream extends PDFStream {
   }
 
   getUnencodedContents(): Uint8Array {
-    throw new MethodNotImplementedError(
-      this.constructor.name,
-      'getUnencodedContents',
-    );
+    throw new MethodNotImplementedError(this.constructor.name, 'getUnencodedContents');
   }
 }
 

package/src/core/structures/PDFObjectStream.ts

@@ -10,21 +10,14 @@ import { copyStringIntoBuffer, last } from '../../utils';
 export type IndirectObject = [PDFRef, PDFObject];
 
 class PDFObjectStream extends PDFFlateStream {
-  static withContextAndObjects = (
-    context: PDFContext,
-    objects: IndirectObject[],
-    encode = true,
-  ) => new PDFObjectStream(context, objects, encode);
+  static withContextAndObjects = (context: PDFContext, objects: IndirectObject[], encode = true) =>
+    new PDFObjectStream(context, objects, encode);
 
   private readonly objects: IndirectObject[];
   private readonly offsets: [number, number][];
   private readonly offsetsString: string;
 
-  private constructor(
-    context: PDFContext,
-    objects: IndirectObject[],
-    encode = true,
-  ) {
+  private constructor(context: PDFContext, objects: IndirectObject[], encode = true) {
     super(context.obj({}), encode);
 
     this.objects = objects;
@@ -70,10 +63,7 @@ class PDFObjectStream extends PDFFlateStream {
 
   getUnencodedContentsSize(): number {
     return (
-      this.offsetsString.length +
-      last(this.offsets)[1] +
-      last(this.objects)[1].sizeInBytes() +
-      1
+      this.offsetsString.length + last(this.offsets)[1] + last(this.objects)[1].sizeInBytes() + 1
     );
   }
 

package/src/core/structures/PDFPageLeaf.ts

@@ -9,12 +9,7 @@ import PDFContext from '../PDFContext';
 import PDFPageTree from './PDFPageTree';
 
 class PDFPageLeaf extends PDFDict {
-  static readonly InheritableEntries = [
-    'Resources',
-    'MediaBox',
-    'CropBox',
-    'Rotate',
-  ];
+  static readonly InheritableEntries = ['Resources', 'MediaBox', 'CropBox', 'Rotate'];
 
   static withContextAndParent = (context: PDFContext, parent: PDFRef) => {
     const dict = new Map();
@@ -25,20 +20,13 @@ class PDFPageLeaf extends PDFDict {
     return new PDFPageLeaf(dict, context, false);
   };
 
-  static fromMapWithContext = (
-    map: DictMap,
-    context: PDFContext,
-    autoNormalizeCTM = true,
-  ) => new PDFPageLeaf(map, context, autoNormalizeCTM);
+  static fromMapWithContext = (map: DictMap, context: PDFContext, autoNormalizeCTM = true) =>
+    new PDFPageLeaf(map, context, autoNormalizeCTM);
 
   private normalized = false;
   private readonly autoNormalizeCTM: boolean;
 
-  private constructor(
-    map: DictMap,
-    context: PDFContext,
-    autoNormalizeCTM = true,
-  ) {
+  private constructor(map: DictMap, context: PDFContext, autoNormalizeCTM = true) {
     super(map, context);
     this.autoNormalizeCTM = autoNormalizeCTM;
   }
@@ -62,10 +50,7 @@ class PDFPageLeaf extends PDFDict {
   }
 
   Contents(): PDFStream | PDFArray | undefined {
-    return this.lookup(PDFName.of('Contents')) as
-      | PDFStream
-      | PDFArray
-      | undefined;
+    return this.lookup(PDFName.of('Contents')) as PDFStream | PDFArray | undefined;
   }
 
   Annots(): PDFArray | undefined {
@@ -219,23 +204,19 @@ class PDFPageLeaf extends PDFDict {
 
     // TODO: Clone `Resources` if it is inherited
     const dictOrRef = this.getInheritableAttribute(PDFName.Resources);
-    const Resources =
-      context.lookupMaybe(dictOrRef, PDFDict) || context.obj({});
+    const Resources = context.lookupMaybe(dictOrRef, PDFDict) || context.obj({});
     this.set(PDFName.Resources, Resources);
 
     // TODO: Clone `Font` if it is inherited
-    const Font =
-      Resources.lookupMaybe(PDFName.Font, PDFDict) || context.obj({});
+    const Font = Resources.lookupMaybe(PDFName.Font, PDFDict) || context.obj({});
     Resources.set(PDFName.Font, Font);
 
     // TODO: Clone `XObject` if it is inherited
-    const XObject =
-      Resources.lookupMaybe(PDFName.XObject, PDFDict) || context.obj({});
+    const XObject = Resources.lookupMaybe(PDFName.XObject, PDFDict) || context.obj({});
     Resources.set(PDFName.XObject, XObject);
 
     // TODO: Clone `ExtGState` if it is inherited
-    const ExtGState =
-      Resources.lookupMaybe(PDFName.ExtGState, PDFDict) || context.obj({});
+    const ExtGState = Resources.lookupMaybe(PDFName.ExtGState, PDFDict) || context.obj({});
     Resources.set(PDFName.ExtGState, ExtGState);
 
     const Annots = this.Annots() || context.obj([]);

package/src/core/structures/PDFPageTree.ts

@@ -19,8 +19,7 @@ class PDFPageTree extends PDFDict {
     return new PDFPageTree(dict, context);
   };
 
-  static fromMapWithContext = (map: DictMap, context: PDFContext) =>
-    new PDFPageTree(map, context);
+  static fromMapWithContext = (map: DictMap, context: PDFContext) => new PDFPageTree(map, context);
 
   Parent(): PDFPageTree | undefined {
     return this.lookup(PDFName.of('Parent')) as PDFPageTree | undefined;
@@ -75,9 +74,7 @@ class PDFPageTree extends PDFDict {
       if (kid instanceof PDFPageTree) {
         if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
           // Dig in
-          return (
-            kid.insertLeafNode(leafRef, leafsRemainingUntilTarget) || kidRef
-          );
+          return kid.insertLeafNode(leafRef, leafsRemainingUntilTarget) || kidRef;
         } else {
           // Move on
           leafsRemainingUntilTarget -= kid.Count().asNumber();

package/src/core/syntax/Keywords.ts

@@ -2,14 +2,7 @@ import CharCodes from './CharCodes';
 
 const { Space, CarriageReturn, Newline } = CharCodes;
 
-const stream = [
-  CharCodes.s,
-  CharCodes.t,
-  CharCodes.r,
-  CharCodes.e,
-  CharCodes.a,
-  CharCodes.m,
-];
+const stream = [CharCodes.s, CharCodes.t, CharCodes.r, CharCodes.e, CharCodes.a, CharCodes.m];
 
 const endstream = [
   CharCodes.e,
@@ -24,29 +17,10 @@ const endstream = [
 ];
 
 export const Keywords = {
-  header: [
-    CharCodes.Percent,
-    CharCodes.P,
-    CharCodes.D,
-    CharCodes.F,
-    CharCodes.Dash,
-  ],
-  eof: [
-    CharCodes.Percent,
-    CharCodes.Percent,
-    CharCodes.E,
-    CharCodes.O,
-    CharCodes.F,
-  ],
+  header: [CharCodes.Percent, CharCodes.P, CharCodes.D, CharCodes.F, CharCodes.Dash],
+  eof: [CharCodes.Percent, CharCodes.Percent, CharCodes.E, CharCodes.O, CharCodes.F],
   obj: [CharCodes.o, CharCodes.b, CharCodes.j],
-  endobj: [
-    CharCodes.e,
-    CharCodes.n,
-    CharCodes.d,
-    CharCodes.o,
-    CharCodes.b,
-    CharCodes.j,
-  ],
+  endobj: [CharCodes.e, CharCodes.n, CharCodes.d, CharCodes.o, CharCodes.b, CharCodes.j],
   xref: [CharCodes.x, CharCodes.r, CharCodes.e, CharCodes.f],
   trailer: [
     CharCodes.t,

package/src/core/writers/PDFStreamWriter.ts

@@ -18,13 +18,7 @@ class PDFStreamWriter extends PDFWriter {
     objectsPerTick: number,
     encodeStreams = true,
     objectsPerStream = 50,
-  ) =>
-    new PDFStreamWriter(
-      context,
-      objectsPerTick,
-      encodeStreams,
-      objectsPerStream,
-    );
+  ) => new PDFStreamWriter(context, objectsPerTick, encodeStreams, objectsPerStream);
 
   private readonly encodeStreams: boolean;
   private readonly objectsPerStream: number;
@@ -48,10 +42,7 @@ class PDFStreamWriter extends PDFWriter {
 
     let size = header.sizeInBytes() + 2;
 
-    const xrefStream = PDFCrossRefStream.create(
-      this.createTrailerDict(),
-      this.encodeStreams,
-    );
+    const xrefStream = PDFCrossRefStream.create(this.createTrailerDict(), this.encodeStreams);
 
     const uncompressedObjects: [PDFRef, PDFObject][] = [];
     const compressedObjects: [PDFRef, PDFObject][][] = [];

package/src/core/writers/PDFWriter.ts

@@ -72,8 +72,7 @@ class PDFWriter {
       buffer[offset++] = CharCodes.Newline;
       buffer[offset++] = CharCodes.Newline;
 
-      const n =
-        object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
+      const n = object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
       if (this.shouldWaitForTick(n)) await waitForTick();
     }
 
@@ -93,10 +92,7 @@ class PDFWriter {
     return buffer;
   }
 
-  protected computeIndirectObjectSize([ref, object]: [
-    PDFRef,
-    PDFObject,
-  ]): number {
+  protected computeIndirectObjectSize([ref, object]: [PDFRef, PDFObject]): number {
     const refSize = ref.sizeInBytes() + 3; // 'R' -> 'obj\n'
     const objectSize = object.sizeInBytes() + 9; // '\nendobj\n\n'
     return refSize + objectSize;

package/src/types/fontkit.ts

@@ -54,14 +54,7 @@ export interface Path {
    * Adds a bezier curve to the path from the current point to the
    * given x, y coordinates using cp1x, cp1y and cp2x, cp2y as control points.
    */
-  bezierCurveTo(
-    cp1x: number,
-    cp1y: number,
-    cp2x: number,
-    cp2y: number,
-    x: number,
-    y: number,
-  ): void;
+  bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
 
   /**
    * Closes the current sub-path by drawing a straight line back to the
@@ -222,10 +215,7 @@ export interface GlyphRun {
 }
 
 export interface SubsetStream {
-  on: (
-    eventType: 'data' | 'end',
-    callback: (data: Uint8Array) => any,
-  ) => SubsetStream;
+  on: (eventType: 'data' | 'end', callback: (data: Uint8Array) => any) => SubsetStream;
 }
 
 export type Subset = {
@@ -631,10 +621,7 @@ export interface Font {
    * in addition to the default set. If this is an AAT font, the OpenType
    * feature tags are mapped to AAT features.
    */
-  layout(
-    str: string,
-    features?: TypeFeatures | (keyof TypeFeatures)[],
-  ): GlyphRun;
+  layout(str: string, features?: TypeFeatures | (keyof TypeFeatures)[]): GlyphRun;
 
   // Other Methods
 

package/src/types/index.ts

@@ -18,21 +18,13 @@ export type Coordinates = {
   y: number;
 };
 
-export type GraphicElement =
-  | Arc
-  | Circle
-  | Ellipse
-  | Line
-  | Plot
-  | Point
-  | Rectangle
-  | Segment;
+export type GraphicElement = Arc | Circle | Ellipse | Line | Plot | Point | Rectangle | Segment;
 
 export type Space = {
-  topLeft: Coordinates
-  topRight: Coordinates
-  bottomRight: Coordinates
-  bottomLeft: Coordinates
- };
+  topLeft: Coordinates;
+  topRight: Coordinates;
+  bottomRight: Coordinates;
+  bottomLeft: Coordinates;
+};
 
 export type LinkElement = Rectangle | Ellipse;

package/src/types/matrix.ts

@@ -17,13 +17,6 @@
  *   * Skew shall be specified by `[1 tan(a) tan(b) 1 0 0]`, which skews the
  *     x-axis by an angle `a` and the y axis by an angle `b`.
  */
-export type TransformationMatrix = [
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-];
+export type TransformationMatrix = [number, number, number, number, number, number];
 
 export const identityMatrix: TransformationMatrix = [1, 0, 0, 1, 0, 0];

package/src/utils/arrays.ts

@@ -22,8 +22,7 @@ export const mergeIntoTypedArray = (...arrays: (string | Uint8Array)[]) => {
   const typedArrays: Uint8Array[] = [];
   for (let idx = 0; idx < arrayCount; idx++) {
     const element = arrays[idx];
-    typedArrays[idx] =
-      element instanceof Uint8Array ? element : typedArrayFor(element);
+    typedArrays[idx] = element instanceof Uint8Array ? element : typedArrayFor(element);
   }
 
   let totalSize = 0;
@@ -139,9 +138,7 @@ export const pluckIndices = <T>(arr: T[], indices: number[]) => {
 export const canBeConvertedToUint8Array = (
   input: any,
 ): input is string | ArrayBuffer | Uint8Array =>
-  input instanceof Uint8Array ||
-  input instanceof ArrayBuffer ||
-  typeof input === 'string';
+  input instanceof Uint8Array || input instanceof ArrayBuffer || typeof input === 'string';
 
 export const toUint8Array = (input: string | ArrayBuffer | Uint8Array) => {
   if (typeof input === 'string') {
@@ -151,8 +148,6 @@ export const toUint8Array = (input: string | ArrayBuffer | Uint8Array) => {
   } else if (input instanceof Uint8Array) {
     return input;
   } else {
-    throw new TypeError(
-      '`input` must be one of `string | ArrayBuffer | Uint8Array`',
-    );
+    throw new TypeError('`input` must be one of `string | ArrayBuffer | Uint8Array`');
   }
 };

package/src/utils/base64.ts

@@ -10,8 +10,7 @@
  *
  */
 
-const chars =
-  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
 // Use a lookup table to find the index.
 const lookup = new Uint8Array(256);
@@ -73,8 +72,7 @@ export const decodeFromBase64 = (base64: string): Uint8Array => {
 
 // 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;
+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

package/src/utils/elements/Arc.ts

@@ -37,12 +37,7 @@ export default class Arc extends GraphElement {
   }
 
   sweep() {
-    this.lastSweep = angleABC(
-      this.origin(),
-      this.center(),
-      this.destination(),
-      this.lastSweep,
-    );
+    this.lastSweep = angleABC(this.origin(), this.center(), this.destination(), this.lastSweep);
     return this.lastSweep;
   }
 
@@ -58,8 +53,7 @@ export default class Arc extends GraphElement {
     const eO = element.origin();
     return (
       this.getCircle().isEqual(element.getCircle()) &&
-      ((dest.isEqual(eDest) && o.isEqual(eO)) ||
-        (dest.isEqual(eO) && o.isEqual(eDest)))
+      ((dest.isEqual(eDest) && o.isEqual(eO)) || (dest.isEqual(eO) && o.isEqual(eDest)))
     );
   }
 
@@ -74,9 +68,7 @@ export default class Arc extends GraphElement {
 
   middle() {
     const halfSweep = this.sweep() / 2;
-    const mid = this.center().plus(
-      rotate(vector(this.center(), this.origin()), halfSweep),
-    );
+    const mid = this.center().plus(rotate(vector(this.center(), this.origin()), halfSweep));
     return mid;
   }
 
@@ -84,8 +76,7 @@ export default class Arc extends GraphElement {
     // As angles are returned between -π and π, we need the middle of the arc
     return (
       this.getCircle().includes(P) &&
-      Math.abs(angleABC(this.middle(), this.center(), P)) <=
-        Math.abs(this.sweep() / 2)
+      Math.abs(angleABC(this.middle(), this.center(), P)) <= Math.abs(this.sweep() / 2)
     );
   }
 
@@ -97,8 +88,7 @@ export default class Arc extends GraphElement {
       const destination = this.destination().toCoords();
       // Returns the closest between origin and destination
       const coords =
-        distanceCoords(H.toCoords(), origin) <
-        distanceCoords(H.toCoords(), destination)
+        distanceCoords(H.toCoords(), origin) < distanceCoords(H.toCoords(), destination)
           ? origin
           : destination;
       return new Point(coords);

package/src/utils/elements/Circle.ts

@@ -1,12 +1,4 @@
-import {
-  distance,
-  distanceCoords,
-  isEqual,
-  minus,
-  plus,
-  times,
-  unitVector,
-} from '../maths';
+import { distance, distanceCoords, isEqual, minus, plus, times, unitVector } from '../maths';
 
 import GraphElement from './GraphElement';
 import Point from './Point';