@tutao/tutanota-utils 3.93.5 → 3.94.0

package/dist/ArrayUtils.d.ts

@@ -1,8 +1,8 @@
-export declare function concat(...arrays: Uint8Array[]): Uint8Array;
+export declare function concat(...arrays: Uint8Array[]): Uint8Array
 /**
  * Create an array filled with the numbers min..max (inclusive)
  */
-export declare function numberRange(min: number, max: number): Array<number>;
+export declare function numberRange(min: number, max: number): Array<number>
 /**
  * Compares two arrays for equality based on ===.
  * @param {Array} a1 The first array.
@@ -11,7 +11,7 @@ export declare function numberRange(min: number, max: number): Array<number>;
  *
  * It is valid to compare Uint8Array to Array<T>, don't restrict it to be one type
  */
-export declare function arrayEquals<T, A extends Uint8Array | Array<T>>(a1: A, a2: A): boolean;
+export declare function arrayEquals<T, A extends Uint8Array | Array<T>>(a1: A, a2: A): boolean
 /**
  * Compares two arrays for equality based on a predicate
  * @param a1
@@ -19,51 +19,51 @@ export declare function arrayEquals<T, A extends Uint8Array | Array<T>>(a1: A, a
  * @param predicate
  * @returns {boolean}
  */
-export declare function arrayEqualsWithPredicate<T>(a1: ReadonlyArray<T>, a2: ReadonlyArray<T>, predicate: (arg0: T, arg1: T) => boolean): boolean;
-export declare function arrayHash(array: Uint8Array): number;
+export declare function arrayEqualsWithPredicate<T>(a1: ReadonlyArray<T>, a2: ReadonlyArray<T>, predicate: (arg0: T, arg1: T) => boolean): boolean
+export declare function arrayHash(array: Uint8Array): number
 /**
  * Remove the element from theArray if it is contained in the array.
  * @param theArray The array to remove the element from.
  * @param elementToRemove The element to remove from the array.
  * @return True if the element was removed, false otherwise.
  */
-export declare function remove<T>(theArray: Array<T>, elementToRemove: T): boolean;
+export declare function remove<T>(theArray: Array<T>, elementToRemove: T): boolean
 /**
  * Find all items in an array that pass the given predicate
  */
-export declare function findAll<T>(theArray: Array<T>, finder: (arg0: T) => boolean): Array<T>;
+export declare function findAll<T>(theArray: Array<T>, finder: (arg0: T) => boolean): Array<T>
 /**
  * @param theArray
  * @param finder
  * @return {boolean} if the element was found
  */
-export declare function findAndRemove<T>(theArray: Array<T>, finder: (arg0: T) => boolean): boolean;
-export declare function findAllAndRemove<T>(theArray: Array<T>, finder: (arg0: T) => boolean, startIndex?: number): boolean;
-export declare function replace(theArray: Array<any>, oldElement: any, newElement: any): boolean;
+export declare function findAndRemove<T>(theArray: Array<T>, finder: (arg0: T) => boolean): boolean
+export declare function findAllAndRemove<T>(theArray: Array<T>, finder: (arg0: T) => boolean, startIndex?: number): boolean
+export declare function replace(theArray: Array<any>, oldElement: any, newElement: any): boolean
 /**
  * Same as filterMap in some languages. Apply mapper and then only include non-nullable items.
  */
-export declare function mapAndFilterNull<T, R>(array: ReadonlyArray<T>, mapper: (arg0: T) => R | null | undefined): Array<R>;
-export declare function filterNull<T>(array: ReadonlyArray<T | null | undefined>): Array<T>;
+export declare function mapAndFilterNull<T, R>(array: ReadonlyArray<T>, mapper: (arg0: T) => R | null | undefined): Array<R>
+export declare function filterNull<T>(array: ReadonlyArray<T | null | undefined>): Array<T>
 /**
  * Provides the last element of the given array.
  * @param theArray The array.
  * @return The last element of the array.
  */
-export declare function last<T>(theArray: ReadonlyArray<T>): T | null | undefined;
-export declare function isEmpty<T>(array: ReadonlyArray<T>): boolean;
-export declare function lastThrow<T>(array: ReadonlyArray<T>): T;
-export declare function firstThrow<T>(array: ReadonlyArray<T>): T;
-export declare function first<T>(array: ReadonlyArray<T>): T | null;
-export declare function findLast<T>(array: Array<T>, predicate: (arg0: T) => boolean): T | null | undefined;
-export declare function findLastIndex<T>(array: Array<T>, predicate: (arg0: T) => boolean): number;
-export declare function contains(theArray: Array<any>, elementToCheck: any): boolean;
-export declare function addAll(array: Array<any>, elements: Array<any>): void;
-export declare function removeAll(array: Array<any>, elements: Array<any>): void;
+export declare function last<T>(theArray: ReadonlyArray<T>): T | null | undefined
+export declare function isEmpty<T>(array: ReadonlyArray<T>): boolean
+export declare function lastThrow<T>(array: ReadonlyArray<T>): T
+export declare function firstThrow<T>(array: ReadonlyArray<T>): T
+export declare function first<T>(array: ReadonlyArray<T>): T | null
+export declare function findLast<T>(array: Array<T>, predicate: (arg0: T) => boolean): T | null | undefined
+export declare function findLastIndex<T>(array: Array<T>, predicate: (arg0: T) => boolean): number
+export declare function contains(theArray: Array<any>, elementToCheck: any): boolean
+export declare function addAll(array: Array<any>, elements: Array<any>): void
+export declare function removeAll(array: Array<any>, elements: Array<any>): void
 /**
  * Group an array based on the given discriminator, but each group will have only unique items
  */
-export declare function groupByAndMapUniquely<T, R, E>(iterable: Iterable<T>, discriminator: (arg0: T) => R, mapper: (arg0: T) => E): Map<R, Set<E>>;
+export declare function groupByAndMapUniquely<T, R, E>(iterable: Iterable<T>, discriminator: (arg0: T) => R, mapper: (arg0: T) => E): Map<R, Set<E>>
 /**
  * convert an Array of T's into a Map of Arrays of E's by
  * * grouping them based on a discriminator
@@ -73,14 +73,14 @@ export declare function groupByAndMapUniquely<T, R, E>(iterable: Iterable<T>, di
  * @param mapper a function that maps the array elements before they get added to the group
  * @returns {Map<R, Array<E>>}
  */
-export declare function groupByAndMap<T, R, E>(iterable: Iterable<T>, discriminator: (arg0: T) => R, mapper: (arg0: T) => E): Map<R, Array<E>>;
+export declare function groupByAndMap<T, R, E>(iterable: Iterable<T>, discriminator: (arg0: T) => R, mapper: (arg0: T) => E): Map<R, Array<E>>
 /**
  * Group array elements based on keys produced by a discriminator
  * @param iterable the array to split into groups
  * @param discriminator a function that produces the keys to group the elements by
  * @returns {NodeJS.Global.Map<R, Array<T>>}
  */
-export declare function groupBy<T, R>(iterable: Iterable<T>, discriminator: (arg0: T) => R): Map<R, Array<T>>;
+export declare function groupBy<T, R>(iterable: Iterable<T>, discriminator: (arg0: T) => R): Map<R, Array<T>>
 /**
  * split an array into chunks of a given size.
  * the last chunk will be smaller if there are less than chunkSize elements left.
@@ -88,15 +88,15 @@ export declare function groupBy<T, R>(iterable: Iterable<T>, discriminator: (arg
  * @param array
  * @returns {Array<Array<T>>}
  */
-export declare function splitInChunks<T>(chunkSize: number, array: Array<T>): Array<Array<T>>;
-export declare function flat<T>(arrays: ReadonlyArray<ReadonlyArray<T>>): Array<T>;
+export declare function splitInChunks<T>(chunkSize: number, array: Array<T>): Array<Array<T>>
+export declare function flat<T>(arrays: ReadonlyArray<ReadonlyArray<T>>): Array<T>
 /**
  * Maps an array into a nested array and then flattens it
  * @param array
  * @param mapper
  * @returns {T|*[]}
  */
-export declare function flatMap<T, U>(array: ReadonlyArray<T>, mapper: (arg0: T) => Array<U>): Array<U>;
+export declare function flatMap<T, U>(array: ReadonlyArray<T>, mapper: (arg0: T) => Array<U>): Array<U>
 /**
  * Inserts element into the sorted array. Will find <b>the last</b> matching position.
  * Might add or replace element based on {@param replaceIf} identity check.
@@ -106,9 +106,14 @@ export declare function flatMap<T, U>(array: ReadonlyArray<T>, mapper: (arg0: T)
  * @param comparator for sorting
  * @param replaceIf identity comparison for replacement
  */
-export declare function insertIntoSortedArray<T>(element: T, array: Array<T>, comparator: (left: T, right: T) => number, replaceIf?: (newElement: T, existing: T) => boolean): void;
-export declare function zip<A, B>(arr1: Array<A>, arr2: Array<B>): Array<[A, B]>;
-export declare function deduplicate<T>(arr: Array<T>, comp?: (arg0: T, arg1: T) => boolean): Array<T>;
+export declare function insertIntoSortedArray<T>(
+	element: T,
+	array: Array<T>,
+	comparator: (left: T, right: T) => number,
+	replaceIf?: (newElement: T, existing: T) => boolean,
+): void
+export declare function zip<A, B>(arr1: Array<A>, arr2: Array<B>): Array<[A, B]>
+export declare function deduplicate<T>(arr: Array<T>, comp?: (arg0: T, arg1: T) => boolean): Array<T>
 /**
  * http://jsfiddle.net/aryzhov/pkfst550/
  * Binary search in JavaScript.
@@ -123,12 +128,12 @@ export declare function deduplicate<T>(arr: Array<T>, comp?: (arg0: T, arg1: T)
  * The array may contain duplicate elements. If there are more than one equal elements in the array,
  * the returned value can be the index of any one of the equal elements.
  */
-export declare function binarySearch<T>(ar: Array<T>, el: T, compare_fn: (arg0: T, arg1: T) => number): number;
-export declare function lastIndex<T>(array: ReadonlyArray<T>): number;
+export declare function binarySearch<T>(ar: Array<T>, el: T, compare_fn: (arg0: T, arg1: T) => number): number
+export declare function lastIndex<T>(array: ReadonlyArray<T>): number
 /**
  * All of the elements in all of the arguments combined, and deduplicated
  */
-export declare function union<T>(...iterables: Array<Iterable<T>>): Set<T>;
+export declare function union<T>(...iterables: Array<Iterable<T>>): Set<T>
 /**
  * return a new array containing every item from array1 that isn't in array2
  * @param array1
@@ -136,27 +141,27 @@ export declare function union<T>(...iterables: Array<Iterable<T>>): Set<T>;
  * @param compare: compare items in the array for equality
  * @returns {Array<$NonMaybeType<T>>|Array<T>}
  */
-export declare function difference<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, compare?: (arg0: T, arg1: T) => boolean): Array<T>;
+export declare function difference<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, compare?: (arg0: T, arg1: T) => boolean): Array<T>
 /**
  * Returns a set with elements that are *not* in both sets.
  *
  * {a, b, c} △ {b, c, d} == {a, d}
  */
-export declare function symmetricDifference<T>(set1: ReadonlySet<T>, set2: ReadonlySet<T>): Set<T>;
+export declare function symmetricDifference<T>(set1: ReadonlySet<T>, set2: ReadonlySet<T>): Set<T>
 /**
  * Splits an array into two based on a predicate, where elements that match the predicate go into the left side
  * @param array
  * @param predicate
  */
-export declare function partition<T>(array: Array<T>, predicate: (arg0: T) => boolean): [Array<T>, Array<T>];
+export declare function partition<T>(array: Array<T>, predicate: (arg0: T) => boolean): [Array<T>, Array<T>]
 /**
  * like partition(), but async
  * rejects if any of the predicates reject.
  * @param array
  * @param predicate
  */
-export declare function partitionAsync<T>(array: Array<T>, predicate: (arg0: T) => Promise<boolean>): Promise<[Array<T>, Array<T>]>;
+export declare function partitionAsync<T>(array: Array<T>, predicate: (arg0: T) => Promise<boolean>): Promise<[Array<T>, Array<T>]>
 /**
  * Create an array with n elements by calling the provided factory
  */
-export declare function arrayOf<T>(n: number, factory: (idx: number) => T): Array<T>;
+export declare function arrayOf<T>(n: number, factory: (idx: number) => T): Array<T>