@tutao/tutanota-utils 3.91.0 → 3.91.3

package/dist/Utils.d.ts

@@ -0,0 +1,125 @@
+export declare type lazy<T> = () => T;
+export declare type lazyAsync<T> = () => Promise<T>;
+export declare type Thunk = () => unknown;
+export declare type DeferredObject<T> = {
+    resolve: (arg0: T) => void;
+    reject: (arg0: Error) => void;
+    promise: Promise<T>;
+};
+export declare type DeferredObjectWithHandler<T, U> = {
+    resolve: (arg0: T) => void;
+    reject: (arg0: Error) => void;
+    promise: Promise<U>;
+};
+export declare function defer<T>(): DeferredObject<T>;
+export declare function deferWithHandler<T, U>(handler: (arg0: T) => U): DeferredObjectWithHandler<T, U>;
+export declare function asyncFind<T>(array: ReadonlyArray<T>, finder: (item: T, index: number, arrayLength: number) => Promise<boolean>): Promise<T | null | undefined>;
+export declare function asyncFindAndMap<T, R>(array: ReadonlyArray<T>, finder: (item: T, index: number, arrayLength: number) => Promise<R | null>): Promise<R | null | undefined>;
+/**
+ * Calls an executor function for slices of nbrOfElementsInGroup items of the given array until the executor function returns false.
+ */
+export declare function executeInGroups<T>(array: T[], nbrOfElementsInGroup: number, executor: (items: T[]) => Promise<boolean>): Promise<void>;
+export declare function neverNull<T>(object: T): NonNullable<T>;
+export declare function assertNotNull<T>(object: T | null | undefined, message?: string): T;
+export declare function isNotNull<T>(t: T | null | undefined): t is T;
+export declare function assert(assertion: MaybeLazy<boolean>, message: string): void;
+export declare function downcast<R = any>(object: any): R;
+export declare function clone<T>(instance: T): T;
+/**
+ * Function which accepts another function. On first invocation
+ * of this resulting function result will be remembered and returned
+ * on consequent invocations.
+ */
+export declare function lazyMemoized<T>(source: () => T): () => T;
+/**
+ * Returns a cached version of {@param fn}.
+ * Cached function checks that argument is the same (with ===) and if it is then it returns the cached result.
+ * If the cached argument has changed then {@param fn} will be called with new argument and result will be cached again.
+ * Only remembers the last argument.
+ */
+export declare function memoized<T, R>(fn: (arg0: T) => R): (arg0: T) => R;
+/**
+ * Function which returns what was passed into it
+ */
+export declare function identity<T>(t: T): T;
+/**
+ * Function which does nothing.
+ */
+export declare function noOp(): void;
+/**
+ * Return a function, which executed {@param toThrottle} only after it is not invoked for {@param timeout} ms.
+ * Executes function with the last passed arguments
+ * @return {Function}
+ */
+export declare function debounce<F extends (...args: any) => void>(timeout: number, toThrottle: F): F;
+/**
+ * Returns a debounced function. When invoked for the first time, will just invoke
+ * {@param toThrottle}. On subsequent invocations it will either invoke it right away
+ * (if {@param timeout} has passed) or will schedule it to be run after {@param timeout}.
+ * So the first and the last invocations in a series of invocations always take place
+ * but ones in the middle (which happen too often) are discarded.}
+ */
+export declare function debounceStart<F extends (...args: any) => void>(timeout: number, toThrottle: F): F;
+export declare function randomIntFromInterval(min: number, max: number): number;
+export declare function errorToString(error: Error): string;
+/**
+ * Like {@link Object.entries} but preserves the type of the key and value
+ */
+export declare function objectEntries<A extends string | symbol, B>(object: Record<A, B>): Array<[A, B]>;
+/**
+ * modified deepEquals from ospec is only needed as long as we use custom classes (TypeRef) and Date is not properly handled
+ */
+export declare function deepEqual(a: any, b: any): boolean;
+/**
+ * returns an array of top-level properties that are in both objA and objB, but differ in value
+ * does not handle functions or circular references
+ * treats undefined and null as equal
+ */
+export declare function getChangedProps(objA: any, objB: any): Array<string>;
+/**
+ * Disallow set, delete and clear on Map.
+ * Important: It is *not* a deep freeze.
+ * @param myMap
+ * @return {unknown}
+ */
+export declare function freezeMap<K, V>(myMap: Map<K, V>): Map<K, V>;
+export declare function addressDomain(senderAddress: string): string;
+/**
+ * Ignores the fact that Object.keys returns also not owned properties.
+ */
+export declare function typedKeys<K extends string, V>(obj: Record<K, V>): Array<K>;
+/**
+ * Ignores the fact that Object.keys returns also not owned properties.
+ */
+export declare function typedEntries<K extends string, V>(obj: Record<K, V>): Array<[K, V]>;
+/**
+ * Ignores the fact that Object.keys returns also not owned properties.
+ */
+export declare function typedValues<K extends string, V>(obj: Record<K, V>): Array<V>;
+export declare type MaybeLazy<T> = T | lazy<T>;
+export declare function resolveMaybeLazy<T>(maybe: MaybeLazy<T>): T;
+export declare function getAsLazy<T>(maybe: MaybeLazy<T>): lazy<T>;
+export declare function mapLazily<T, U>(maybe: MaybeLazy<T>, mapping: (arg0: T) => U): lazy<U>;
+/**
+ * Stricter version of parseInt() from MDN. parseInt() allows some arbitrary characters at the end of the string.
+ * Returns NaN in case there's anything non-number in the string.
+ */
+export declare function filterInt(value: string): number;
+interface Positioned {
+    x: number;
+    y: number;
+}
+interface Sized {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+export declare function insideRect(point: Positioned, rect: Sized): boolean;
+/**
+ * If val is non null, returns the result of val passed to action, else null
+ */
+export declare function mapNullable<T, U>(val: T | null | undefined, action: (arg0: T) => U | null | undefined): U | null;
+/** Helper to take instead of `typeof setTimeout` which is hellish to reproduce */
+export declare type TimeoutSetter = (fn: () => unknown, arg1: number) => ReturnType<typeof setTimeout>;
+export {};

package/dist/Utils.js

@@ -0,0 +1,359 @@
+import { TypeRef } from "./TypeRef.js";
+export function defer() {
+    let ret = {};
+    ret.promise = new Promise((resolve, reject) => {
+        ret.resolve = resolve;
+        ret.reject = reject;
+    });
+    return ret;
+}
+export function deferWithHandler(handler) {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    }).then(handler);
+    return deferred;
+}
+export async function asyncFind(array, finder) {
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        if (await finder(item, i, array.length)) {
+            return item;
+        }
+    }
+    return null;
+}
+export async function asyncFindAndMap(array, finder) {
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        const mapped = await finder(item, i, array.length);
+        if (mapped) {
+            return mapped;
+        }
+    }
+    return null;
+}
+/**
+ * Calls an executor function for slices of nbrOfElementsInGroup items of the given array until the executor function returns false.
+ */
+export function executeInGroups(array, nbrOfElementsInGroup, executor) {
+    if (array.length > 0) {
+        let nextSlice = Math.min(array.length, nbrOfElementsInGroup);
+        return executor(array.slice(0, nextSlice)).then(doContinue => {
+            if (doContinue) {
+                return executeInGroups(array.slice(nextSlice), nbrOfElementsInGroup, executor);
+            }
+        });
+    }
+    else {
+        return Promise.resolve();
+    }
+}
+export function neverNull(object) {
+    return object;
+}
+export function assertNotNull(object, message = "null") {
+    if (object == null) {
+        throw new Error("AssertNotNull failed : " + message);
+    }
+    return object;
+}
+export function isNotNull(t) {
+    return t != null;
+}
+export function assert(assertion, message) {
+    if (!resolveMaybeLazy(assertion)) {
+        throw new Error(`Assertion failed: ${message}`);
+    }
+}
+export function downcast(object) {
+    return object;
+}
+export function clone(instance) {
+    if (instance instanceof Uint8Array) {
+        return downcast(instance.slice());
+    }
+    else if (instance instanceof Array) {
+        return downcast(instance.map(i => clone(i)));
+    }
+    else if (instance instanceof Date) {
+        return new Date(instance.getTime());
+    }
+    else if (instance instanceof TypeRef) {
+        return instance;
+    }
+    else if (instance instanceof Object) {
+        // Can only pass null or Object, cannot pass undefined
+        const copy = Object.create(Object.getPrototypeOf(instance) || null);
+        Object.assign(copy, instance);
+        for (let key of Object.keys(copy)) {
+            copy[key] = clone(copy[key]);
+        }
+        return copy;
+    }
+    else {
+        return instance;
+    }
+}
+/**
+ * Function which accepts another function. On first invocation
+ * of this resulting function result will be remembered and returned
+ * on consequent invocations.
+ */
+export function lazyMemoized(source) {
+    // Using separate variable for tracking because value can be undefined and we want to the function call only once
+    let cached = false;
+    let value;
+    return () => {
+        if (cached) {
+            return value;
+        }
+        else {
+            cached = true;
+            return (value = source());
+        }
+    };
+}
+/**
+ * Returns a cached version of {@param fn}.
+ * Cached function checks that argument is the same (with ===) and if it is then it returns the cached result.
+ * If the cached argument has changed then {@param fn} will be called with new argument and result will be cached again.
+ * Only remembers the last argument.
+ */
+export function memoized(fn) {
+    let lastArg;
+    let lastResult;
+    let didCache = false;
+    return arg => {
+        if (!didCache || arg !== lastArg) {
+            lastArg = arg;
+            didCache = true;
+            lastResult = fn(arg);
+        }
+        return lastResult;
+    };
+}
+/**
+ * Function which returns what was passed into it
+ */
+export function identity(t) {
+    return t;
+}
+/**
+ * Function which does nothing.
+ */
+export function noOp() {
+}
+/**
+ * Return a function, which executed {@param toThrottle} only after it is not invoked for {@param timeout} ms.
+ * Executes function with the last passed arguments
+ * @return {Function}
+ */
+export function debounce(timeout, toThrottle) {
+    let timeoutId;
+    let toInvoke;
+    return downcast((...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        toInvoke = toThrottle.bind(null, ...args);
+        timeoutId = setTimeout(toInvoke, timeout);
+    });
+}
+/**
+ * Returns a debounced function. When invoked for the first time, will just invoke
+ * {@param toThrottle}. On subsequent invocations it will either invoke it right away
+ * (if {@param timeout} has passed) or will schedule it to be run after {@param timeout}.
+ * So the first and the last invocations in a series of invocations always take place
+ * but ones in the middle (which happen too often) are discarded.}
+ */
+export function debounceStart(timeout, toThrottle) {
+    let timeoutId;
+    let lastInvoked = 0;
+    return downcast((...args) => {
+        if (Date.now() - lastInvoked < timeout) {
+            timeoutId && clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                timeoutId = null;
+                toThrottle.apply(null, args);
+            }, timeout);
+        }
+        else {
+            toThrottle.apply(null, args);
+        }
+        lastInvoked = Date.now();
+    });
+}
+export function randomIntFromInterval(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+export function errorToString(error) {
+    let errorString = error.name ? error.name : "?";
+    if (error.message) {
+        errorString += `\n Error message: ${error.message}`;
+    }
+    if (error.stack) {
+        // the error id is included in the stacktrace
+        errorString += `\nStacktrace: \n${error.stack}`;
+    }
+    return errorString;
+}
+/**
+ * Like {@link Object.entries} but preserves the type of the key and value
+ */
+export function objectEntries(object) {
+    return downcast(Object.entries(object));
+}
+/**
+ * modified deepEquals from ospec is only needed as long as we use custom classes (TypeRef) and Date is not properly handled
+ */
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (xor(a === null, b === null) || xor(a === undefined, b === undefined))
+        return false;
+    if (typeof a === "object" && typeof b === "object") {
+        const aIsArgs = isArguments(a), bIsArgs = isArguments(b);
+        if (a.length === b.length && ((a instanceof Array && b instanceof Array) || (aIsArgs && bIsArgs))) {
+            const aKeys = Object.getOwnPropertyNames(a), bKeys = Object.getOwnPropertyNames(b);
+            if (aKeys.length !== bKeys.length)
+                return false;
+            for (let i = 0; i < aKeys.length; i++) {
+                if (!hasOwn.call(b, aKeys[i]) || !deepEqual(a[aKeys[i]], b[aKeys[i]]))
+                    return false;
+            }
+            return true;
+        }
+        if (a instanceof Date && b instanceof Date)
+            return a.getTime() === b.getTime();
+        if (a instanceof Object && b instanceof Object && !aIsArgs && !bIsArgs) {
+            for (let i in a) {
+                if (!(i in b) || !deepEqual(a[i], b[i]))
+                    return false;
+            }
+            for (let i in b) {
+                if (!(i in a))
+                    return false;
+            }
+            return true;
+        }
+        if (typeof Buffer === "function" && a instanceof Buffer && b instanceof Buffer) {
+            for (let i = 0; i < a.length; i++) {
+                if (a[i] !== b[i])
+                    return false;
+            }
+            return true;
+        }
+        if (a.valueOf() === b.valueOf())
+            return true;
+    }
+    return false;
+}
+function xor(a, b) {
+    const aBool = !!a;
+    const bBool = !!b;
+    return (aBool && !bBool) || (bBool && !aBool);
+}
+function isArguments(a) {
+    if ("callee" in a) {
+        for (let i in a)
+            if (i === "callee")
+                return false;
+        return true;
+    }
+}
+const hasOwn = {}.hasOwnProperty;
+/**
+ * returns an array of top-level properties that are in both objA and objB, but differ in value
+ * does not handle functions or circular references
+ * treats undefined and null as equal
+ */
+export function getChangedProps(objA, objB) {
+    if (objA == null || objB == null || objA === objB)
+        return [];
+    return Object.keys(objA)
+        .filter(k => Object.keys(objB).includes(k))
+        .filter(k => ![null, undefined].includes(objA[k]) || ![null, undefined].includes(objB[k]))
+        .filter(k => !deepEqual(objA[k], objB[k]));
+}
+/**
+ * Disallow set, delete and clear on Map.
+ * Important: It is *not* a deep freeze.
+ * @param myMap
+ * @return {unknown}
+ */
+export function freezeMap(myMap) {
+    function mapSet(key, value) {
+        throw new Error("Can't add property " + key + ", map is not extensible");
+    }
+    function mapDelete(key) {
+        throw new Error("Can't delete property " + key + ", map is frozen");
+    }
+    function mapClear() {
+        throw new Error("Can't clear map, map is frozen");
+    }
+    const anyMap = downcast(myMap);
+    anyMap.set = mapSet;
+    anyMap.delete = mapDelete;
+    anyMap.clear = mapClear;
+    Object.freeze(anyMap);
+    return anyMap;
+}
+export function addressDomain(senderAddress) {
+    return senderAddress.slice(senderAddress.lastIndexOf("@") + 1);
+}
+/**
+ * Ignores the fact that Object.keys returns also not owned properties.
+ */
+export function typedKeys(obj) {
+    return downcast(Object.keys(obj));
+}
+/**
+ * Ignores the fact that Object.keys returns also not owned properties.
+ */
+export function typedEntries(obj) {
+    return downcast(Object.entries(obj));
+}
+/**
+ * Ignores the fact that Object.keys returns also not owned properties.
+ */
+export function typedValues(obj) {
+    return downcast(Object.values(obj));
+}
+export function resolveMaybeLazy(maybe) {
+    return typeof maybe === "function" ? maybe() : maybe;
+}
+export function getAsLazy(maybe) {
+    return typeof maybe === "function" ? downcast(maybe) : () => maybe;
+}
+export function mapLazily(maybe, mapping) {
+    return () => mapping(resolveMaybeLazy(maybe));
+}
+/**
+ * Stricter version of parseInt() from MDN. parseInt() allows some arbitrary characters at the end of the string.
+ * Returns NaN in case there's anything non-number in the string.
+ */
+export function filterInt(value) {
+    if (/^\d+$/.test(value)) {
+        return parseInt(value, 10);
+    }
+    else {
+        return NaN;
+    }
+}
+export function insideRect(point, rect) {
+    return point.x >= rect.left && point.x < rect.right && point.y >= rect.top && point.y < rect.bottom;
+}
+/**
+ * If val is non null, returns the result of val passed to action, else null
+ */
+export function mapNullable(val, action) {
+    if (val != null) {
+        const result = action(val);
+        if (result != null) {
+            return result;
+        }
+    }
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { concat, numberRange, arrayEquals, arrayEqualsWithPredicate, arrayHash, remove, findAll, findAndRemove, findAllAndRemove, replace, mapAndFilterNull, filterNull, last, isEmpty, lastThrow, firstThrow, first, findLast, findLastIndex, contains, addAll, removeAll, groupByAndMapUniquely, groupByAndMap, groupBy, splitInChunks, flat, flatMap, insertIntoSortedArray, zip, deduplicate, binarySearch, lastIndex, union, difference, symmetricDifference, partition, } from "./ArrayUtils.js";
+export { AsyncResult } from "./AsyncResult.js";
+export { intersection } from "./CollectionUtils.js";
+export { DAY_IN_MILLIS, getStartOfNextDay, getEndOfDay, getStartOfDay, getHourOfDay, isStartOfDay, isToday, isSameDay, getDayShifted, incrementDate, incrementMonth, isSameDayOfDate, formatSortableDate, formatSortableDateTime, sortableTimestamp, isValidDate, millisToDays, daysToMillis, } from "./DateUtils.js";
+export { uint8ArrayToArrayBuffer, hexToBase64, base64ToHex, base64ToBase64Url, base64ToBase64Ext, base64ExtToBase64, base64UrlToBase64, stringToUtf8Uint8Array, utf8Uint8ArrayToString, hexToUint8Array, uint8ArrayToHex, uint8ArrayToBase64, int8ArrayToBase64, base64ToUint8Array, uint8ArrayToString, decodeQuotedPrintable, decodeBase64, stringToBase64, } from "./Encoding.js";
+export type { Base64, Base64Ext, Base64Url, Hex } from "./Encoding.js";
+export { LazyLoaded } from "./LazyLoaded.js";
+export { mergeMaps, getFromMap, addMapEntry, deleteMapEntry } from "./MapUtils.js";
+export { pMap } from "./PromiseMap.js";
+export type { Mapper } from "./PromiseMap.js";
+export { mapInCallContext, promiseMap, promiseMapCompat, PromisableWrapper, delay, tap, ofClass, promiseFilter, } from "./PromiseUtils.js";
+export type { PromiseMapFn, $Promisable } from "./PromiseUtils.js";
+export { SortedArray } from "./SortedArray.js";
+export type { CompareFn } from "./SortedArray.js";
+export { pad, startsWith, capitalizeFirstLetter, endsWith, lazyStringValue, repeat, cleanMatch, NBSP, splitAt, toLowerCase, localeCompare, byteLength, replaceAll, } from "./StringUtils.js";
+export { TypeRef, isSameTypeRefByAttr, isSameTypeRef } from "./TypeRef.js";
+export { defer, deferWithHandler, asyncFind, asyncFindAndMap, executeInGroups, neverNull, assertNotNull, assert, isNotNull, downcast, clone, lazyMemoized, memoized, identity, noOp, debounce, debounceStart, randomIntFromInterval, errorToString, objectEntries, deepEqual, getChangedProps, freezeMap, addressDomain, typedKeys, typedEntries, typedValues, resolveMaybeLazy, getAsLazy, mapLazily, filterInt, insideRect, mapNullable, } from "./Utils.js";
+export type { DeferredObject, lazy, lazyAsync, Thunk, DeferredObjectWithHandler, MaybeLazy, TimeoutSetter } from "./Utils.js";
+export { mod, clamp } from "./MathUtils.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+export { concat, numberRange, arrayEquals, arrayEqualsWithPredicate, arrayHash, remove, findAll, findAndRemove, findAllAndRemove, replace, mapAndFilterNull, filterNull, last, isEmpty, lastThrow, firstThrow, first, findLast, findLastIndex, contains, addAll, removeAll, groupByAndMapUniquely, groupByAndMap, groupBy, splitInChunks, flat, flatMap, insertIntoSortedArray, zip, deduplicate, binarySearch, lastIndex, union, difference, symmetricDifference, partition, } from "./ArrayUtils.js";
+export { AsyncResult } from "./AsyncResult.js";
+export { intersection } from "./CollectionUtils.js";
+export { DAY_IN_MILLIS, getStartOfNextDay, getEndOfDay, getStartOfDay, getHourOfDay, isStartOfDay, isToday, isSameDay, getDayShifted, incrementDate, incrementMonth, isSameDayOfDate, formatSortableDate, formatSortableDateTime, sortableTimestamp, isValidDate, millisToDays, daysToMillis, } from "./DateUtils.js";
+export { uint8ArrayToArrayBuffer, hexToBase64, base64ToHex, base64ToBase64Url, base64ToBase64Ext, base64ExtToBase64, base64UrlToBase64, stringToUtf8Uint8Array, utf8Uint8ArrayToString, hexToUint8Array, uint8ArrayToHex, uint8ArrayToBase64, int8ArrayToBase64, base64ToUint8Array, uint8ArrayToString, decodeQuotedPrintable, decodeBase64, stringToBase64, } from "./Encoding.js";
+export { LazyLoaded } from "./LazyLoaded.js";
+export { mergeMaps, getFromMap, addMapEntry, deleteMapEntry } from "./MapUtils.js";
+export { pMap } from "./PromiseMap.js";
+export { mapInCallContext, promiseMap, promiseMapCompat, PromisableWrapper, delay, tap, ofClass, promiseFilter, } from "./PromiseUtils.js";
+export { SortedArray } from "./SortedArray.js";
+export { pad, startsWith, capitalizeFirstLetter, endsWith, lazyStringValue, repeat, cleanMatch, NBSP, splitAt, toLowerCase, localeCompare, byteLength, replaceAll, } from "./StringUtils.js";
+export { TypeRef, isSameTypeRefByAttr, isSameTypeRef } from "./TypeRef.js";
+export { defer, deferWithHandler, asyncFind, asyncFindAndMap, executeInGroups, neverNull, assertNotNull, assert, isNotNull, downcast, clone, lazyMemoized, memoized, identity, noOp, debounce, debounceStart, randomIntFromInterval, errorToString, objectEntries, deepEqual, getChangedProps, freezeMap, addressDomain, typedKeys, typedEntries, typedValues, resolveMaybeLazy, getAsLazy, mapLazily, filterInt, insideRect, mapNullable, } from "./Utils.js";
+export { mod, clamp } from "./MathUtils.js";

package/package.json

@@ -1,35 +1,27 @@
 {
 	"name": "@tutao/tutanota-utils",
-	"version": "3.91.0",
+	"version": "3.91.3",
 	"license": "GPL-3.0",
-	"main": "./lib/index.js",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/tutao/tutanota.git",
 		"directory": "packages/tutanota-utils"
 	},
 	"scripts": {
-		"flow": "flow; test $? -eq 0 -o $? -eq 2",
-		"test": "rollup --config rollup_test.config.js && node 'build/test/Suite.js'"
+		"test": "rm -r build; tsc --project test/tsconfig.json && cd build/test && node 'Suite.js'",
+		"build": "rm -r dist; tsc"
 	},
 	"type": "module",
 	"files": [
-		"lib/*",
+		"dist/*",
 		"README.md",
 		"LICENSE.txt"
 	],
 	"devDependencies": {
-		"@babel/core": "7.14.6",
-		"@babel/plugin-proposal-class-properties": "7.14.5",
-		"@babel/plugin-transform-flow-strip-types": "7.4.4",
-		"@babel/plugin-proposal-nullish-coalescing-operator": "7.14.5",
-		"@babel/plugin-proposal-optional-chaining": "7.14.5",
-		"@rollup/plugin-commonjs": "21.0.1",
-		"@rollup/plugin-babel": "5.2.2",
-		"@rollup/plugin-node-resolve": "11.0.1",
-		"flow-bin": "0.152.0",
-		"rollup": "2.55.1",
-		"@tutao/tutanota-test-utils": "3.91.0",
+		"@tutao/tutanota-test-utils": "3.91.3",
+		"typescript": "4.5.4",
 		"ospec": "https://github.com/tutao/ospec.git#0472107629ede33be4c4d19e89f237a6d7b0cb11"
 	}
 }