@tutao/tutanota-utils 3.94.0 → 3.94.1

package/dist/Encoding.js

@@ -1,10 +1,11 @@
 // TODO rename methods according to their JAVA counterparts (e.g. Uint8Array == bytes, Utf8Uint8Array == bytes...)
 export function uint8ArrayToArrayBuffer(uint8Array) {
-	if (uint8Array.byteLength === uint8Array.buffer.byteLength) {
-		return uint8Array.buffer
-	} else {
-		return new Uint8Array(uint8Array).buffer // create a new instance with the correct length, if uint8Array is only a DataView on a longer Array.buffer
-	}
+    if (uint8Array.byteLength === uint8Array.buffer.byteLength) {
+        return uint8Array.buffer;
+    }
+    else {
+        return new Uint8Array(uint8Array).buffer; // create a new instance with the correct length, if uint8Array is only a DataView on a longer Array.buffer
+    }
 }
 /**
  * Converts a hex coded string into a base64 coded string.
@@ -13,7 +14,7 @@ export function uint8ArrayToArrayBuffer(uint8Array) {
  * @return A base64 encoded string.
  */
 export function hexToBase64(hex) {
-	return uint8ArrayToBase64(hexToUint8Array(hex))
+    return uint8ArrayToBase64(hexToUint8Array(hex));
 }
 /**
  * Converts a base64 coded string into a hex coded string.
@@ -22,7 +23,7 @@ export function hexToBase64(hex) {
  * @return A hex encoded string.
  */
 export function base64ToHex(base64) {
-	return uint8ArrayToHex(base64ToUint8Array(base64))
+    return uint8ArrayToHex(base64ToUint8Array(base64));
 }
 /**
  * Converts a base64 string to a url-conform base64 string. This is used for
@@ -32,22 +33,22 @@ export function base64ToHex(base64) {
  * @return The base64url string.
  */
 export function base64ToBase64Url(base64) {
-	let base64url = base64.replace(/\+/g, "-")
-	base64url = base64url.replace(/\//g, "_")
-	base64url = base64url.replace(/=/g, "")
-	return base64url
+    let base64url = base64.replace(/\+/g, "-");
+    base64url = base64url.replace(/\//g, "_");
+    base64url = base64url.replace(/=/g, "");
+    return base64url;
 }
 function makeLookup(str) {
-	const lookup = {}
-	for (let i = 0; i < str.length; i++) {
-		lookup[str.charAt(i)] = i
-	}
-	return lookup
+    const lookup = {};
+    for (let i = 0; i < str.length; i++) {
+        lookup[str.charAt(i)] = i;
+    }
+    return lookup;
 }
-const base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-const base64Lookup = makeLookup(base64Alphabet)
-const base64extAlphabet = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
-const base64ExtLookup = makeLookup(base64extAlphabet)
+const base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const base64Lookup = makeLookup(base64Alphabet);
+const base64extAlphabet = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+const base64ExtLookup = makeLookup(base64extAlphabet);
 /**
  * Converts a base64 string to a base64ext string. Base64ext uses another character set than base64 in order to make it sortable.
  *
@@ -56,13 +57,13 @@ const base64ExtLookup = makeLookup(base64extAlphabet)
  * @return The base64Ext string.
  */
 export function base64ToBase64Ext(base64) {
-	base64 = base64.replace(/=/g, "")
-	let base64ext = ""
-	for (let i = 0; i < base64.length; i++) {
-		let index = base64Lookup[base64.charAt(i)]
-		base64ext += base64extAlphabet[index]
-	}
-	return base64ext
+    base64 = base64.replace(/=/g, "");
+    let base64ext = "";
+    for (let i = 0; i < base64.length; i++) {
+        let index = base64Lookup[base64.charAt(i)];
+        base64ext += base64extAlphabet[index];
+    }
+    return base64ext;
 }
 /**
  * Converts a Base64Ext string to a Base64 string and appends the padding if needed.
@@ -70,20 +71,22 @@ export function base64ToBase64Ext(base64) {
  * @returns The base64 string
  */
 export function base64ExtToBase64(base64ext) {
-	let base64 = ""
-	for (let i = 0; i < base64ext.length; i++) {
-		const index = base64ExtLookup[base64ext.charAt(i)]
-		base64 += base64Alphabet[index]
-	}
-	let padding
-	if (base64.length % 4 === 2) {
-		padding = "=="
-	} else if (base64.length % 4 === 3) {
-		padding = "="
-	} else {
-		padding = ""
-	}
-	return base64 + padding
+    let base64 = "";
+    for (let i = 0; i < base64ext.length; i++) {
+        const index = base64ExtLookup[base64ext.charAt(i)];
+        base64 += base64Alphabet[index];
+    }
+    let padding;
+    if (base64.length % 4 === 2) {
+        padding = "==";
+    }
+    else if (base64.length % 4 === 3) {
+        padding = "=";
+    }
+    else {
+        padding = "";
+    }
+    return base64 + padding;
 }
 /**
  * Converts a base64 url string to a "normal" base64 string. This is used for
@@ -93,77 +96,82 @@ export function base64ExtToBase64(base64ext) {
  * @return The base64 string.
  */
 export function base64UrlToBase64(base64url) {
-	let base64 = base64url.replace(/-/g, "+")
-	base64 = base64.replace(/_/g, "/")
-	let nbrOfRemainingChars = base64.length % 4
-	if (nbrOfRemainingChars === 0) {
-		return base64
-	} else if (nbrOfRemainingChars === 2) {
-		return base64 + "=="
-	} else if (nbrOfRemainingChars === 3) {
-		return base64 + "="
-	}
-	throw new Error("Illegal base64 string.")
+    let base64 = base64url.replace(/-/g, "+");
+    base64 = base64.replace(/_/g, "/");
+    let nbrOfRemainingChars = base64.length % 4;
+    if (nbrOfRemainingChars === 0) {
+        return base64;
+    }
+    else if (nbrOfRemainingChars === 2) {
+        return base64 + "==";
+    }
+    else if (nbrOfRemainingChars === 3) {
+        return base64 + "=";
+    }
+    throw new Error("Illegal base64 string.");
 }
 // just for edge, as it does not support TextEncoder yet
 export function _stringToUtf8Uint8ArrayLegacy(string) {
-	let fixedString
-	try {
-		fixedString = encodeURIComponent(string)
-	} catch (e) {
-		fixedString = encodeURIComponent(_replaceLoneSurrogates(string)) // we filter lone surrogates as trigger URIErrors, otherwise (see https://github.com/tutao/tutanota/issues/618)
-	}
-	let utf8 = unescape(fixedString)
-	let uint8Array = new Uint8Array(utf8.length)
-	for (let i = 0; i < utf8.length; i++) {
-		uint8Array[i] = utf8.charCodeAt(i)
-	}
-	return uint8Array
+    let fixedString;
+    try {
+        fixedString = encodeURIComponent(string);
+    }
+    catch (e) {
+        fixedString = encodeURIComponent(_replaceLoneSurrogates(string)); // we filter lone surrogates as trigger URIErrors, otherwise (see https://github.com/tutao/tutanota/issues/618)
+    }
+    let utf8 = unescape(fixedString);
+    let uint8Array = new Uint8Array(utf8.length);
+    for (let i = 0; i < utf8.length; i++) {
+        uint8Array[i] = utf8.charCodeAt(i);
+    }
+    return uint8Array;
 }
-const REPLACEMENT_CHAR = "\uFFFD"
+const REPLACEMENT_CHAR = "\uFFFD";
 export function _replaceLoneSurrogates(s) {
-	if (s == null) {
-		return ""
-	}
-	let result = []
-	for (let i = 0; i < s.length; i++) {
-		let code = s.charCodeAt(i)
-		let char = s.charAt(i)
-		if (0xd800 <= code && code <= 0xdbff) {
-			if (s.length === i) {
-				// replace high surrogate without following low surrogate
-				result.push(REPLACEMENT_CHAR)
-			} else {
-				let next = s.charCodeAt(i + 1)
-				if (0xdc00 <= next && next <= 0xdfff) {
-					result.push(char)
-					result.push(s.charAt(i + 1))
-					i++ // valid high and low surrogate, skip next low surrogate check
-				} else {
-					result.push(REPLACEMENT_CHAR)
-				}
-			}
-		} else if (0xdc00 <= code && code <= 0xdfff) {
-			// replace low surrogate without preceding high surrogate
-			result.push(REPLACEMENT_CHAR)
-		} else {
-			result.push(char)
-		}
-	}
-	return result.join("")
+    if (s == null) {
+        return "";
+    }
+    let result = [];
+    for (let i = 0; i < s.length; i++) {
+        let code = s.charCodeAt(i);
+        let char = s.charAt(i);
+        if (0xd800 <= code && code <= 0xdbff) {
+            if (s.length === i) {
+                // replace high surrogate without following low surrogate
+                result.push(REPLACEMENT_CHAR);
+            }
+            else {
+                let next = s.charCodeAt(i + 1);
+                if (0xdc00 <= next && next <= 0xdfff) {
+                    result.push(char);
+                    result.push(s.charAt(i + 1));
+                    i++; // valid high and low surrogate, skip next low surrogate check
+                }
+                else {
+                    result.push(REPLACEMENT_CHAR);
+                }
+            }
+        }
+        else if (0xdc00 <= code && code <= 0xdfff) {
+            // replace low surrogate without preceding high surrogate
+            result.push(REPLACEMENT_CHAR);
+        }
+        else {
+            result.push(char);
+        }
+    }
+    return result.join("");
 }
-const encoder =
-	typeof TextEncoder == "function"
-		? new TextEncoder()
-		: {
-				encode: _stringToUtf8Uint8ArrayLegacy,
-		  }
-const decoder =
-	typeof TextDecoder == "function"
-		? new TextDecoder()
-		: {
-				decode: _utf8Uint8ArrayToStringLegacy,
-		  }
+const encoder = typeof TextEncoder == "function"
+    ? new TextEncoder()
+    : {
+        encode: _stringToUtf8Uint8ArrayLegacy,
+    };
+const decoder = typeof TextDecoder == "function"
+    ? new TextDecoder()
+    : {
+        decode: _utf8Uint8ArrayToStringLegacy,
+    };
 /**
  * Converts a string to a Uint8Array containing a UTF-8 string data.
  *
@@ -171,16 +179,16 @@ const decoder =
  * @return The array.
  */
 export function stringToUtf8Uint8Array(string) {
-	return encoder.encode(string)
+    return encoder.encode(string);
 }
 // just for edge, as it does not support TextDecoder yet
 export function _utf8Uint8ArrayToStringLegacy(uint8Array) {
-	let stringArray = []
-	stringArray.length = uint8Array.length
-	for (let i = 0; i < uint8Array.length; i++) {
-		stringArray[i] = String.fromCharCode(uint8Array[i])
-	}
-	return decodeURIComponent(escape(stringArray.join("")))
+    let stringArray = [];
+    stringArray.length = uint8Array.length;
+    for (let i = 0; i < uint8Array.length; i++) {
+        stringArray[i] = String.fromCharCode(uint8Array[i]);
+    }
+    return decodeURIComponent(escape(stringArray.join("")));
 }
 /**
  * Converts an Uint8Array containing UTF-8 string data into a string.
@@ -189,23 +197,23 @@ export function _utf8Uint8ArrayToStringLegacy(uint8Array) {
  * @return The string.
  */
 export function utf8Uint8ArrayToString(uint8Array) {
-	return decoder.decode(uint8Array)
+    return decoder.decode(uint8Array);
 }
 export function hexToUint8Array(hex) {
-	let bufView = new Uint8Array(hex.length / 2)
-	for (let i = 0; i < bufView.byteLength; i++) {
-		bufView[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16)
-	}
-	return bufView
+    let bufView = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bufView.byteLength; i++) {
+        bufView[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bufView;
 }
-const hexDigits = "0123456789abcdef"
+const hexDigits = "0123456789abcdef";
 export function uint8ArrayToHex(uint8Array) {
-	let hex = ""
-	for (let i = 0; i < uint8Array.byteLength; i++) {
-		let value = uint8Array[i]
-		hex += hexDigits[value >> 4] + hexDigits[value & 15]
-	}
-	return hex
+    let hex = "";
+    for (let i = 0; i < uint8Array.byteLength; i++) {
+        let value = uint8Array[i];
+        hex += hexDigits[value >> 4] + hexDigits[value & 15];
+    }
+    return hex;
 }
 /**
  * Converts an Uint8Array to a Base64 encoded string.
@@ -214,23 +222,23 @@ export function uint8ArrayToHex(uint8Array) {
  * @return The Base64 encoded string.
  */
 export function uint8ArrayToBase64(bytes) {
-	if (bytes.length < 512) {
-		// Apply fails on big arrays fairly often. We tried it with 60000 but if you're already
-		// deep in the stack than we cannot allocate such a big argument array.
-		return btoa(String.fromCharCode(...bytes))
-	}
-	let binary = ""
-	const len = bytes.byteLength
-	for (let i = 0; i < len; i++) {
-		binary += String.fromCharCode(bytes[i])
-	}
-	return btoa(binary)
+    if (bytes.length < 512) {
+        // Apply fails on big arrays fairly often. We tried it with 60000 but if you're already
+        // deep in the stack than we cannot allocate such a big argument array.
+        return btoa(String.fromCharCode(...bytes));
+    }
+    let binary = "";
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
 }
 export function int8ArrayToBase64(bytes) {
-	// Values 0 to 127 are the same for signed and unsigned bytes
-	// and -128 to -1 are mapped to the same chars as 128 to 255.
-	let converted = new Uint8Array(bytes)
-	return uint8ArrayToBase64(converted)
+    // Values 0 to 127 are the same for signed and unsigned bytes
+    // and -128 to -1 are mapped to the same chars as 128 to 255.
+    let converted = new Uint8Array(bytes);
+    return uint8ArrayToBase64(converted);
 }
 /**
  * Converts a base64 encoded string to a Uint8Array.
@@ -239,15 +247,15 @@ export function int8ArrayToBase64(bytes) {
  * @return The bytes.
  */
 export function base64ToUint8Array(base64) {
-	if (base64.length % 4 !== 0) {
-		throw new Error(`invalid base64 length: ${base64} (${base64.length})`)
-	}
-	const binaryString = atob(base64)
-	const result = new Uint8Array(binaryString.length)
-	for (let i = 0; i < binaryString.length; i++) {
-		result[i] = binaryString.charCodeAt(i)
-	}
-	return result
+    if (base64.length % 4 !== 0) {
+        throw new Error(`invalid base64 length: ${base64} (${base64.length})`);
+    }
+    const binaryString = atob(base64);
+    const result = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        result[i] = binaryString.charCodeAt(i);
+    }
+    return result;
 }
 /**
  * Converts a Uint8Array containing string data into a string, given the charset the data is in.
@@ -257,8 +265,8 @@ export function base64ToUint8Array(base64) {
  * @return The string
  */
 export function uint8ArrayToString(charset, bytes) {
-	const decoder = new TextDecoder(charset)
-	return decoder.decode(bytes)
+    const decoder = new TextDecoder(charset);
+    return decoder.decode(bytes);
 }
 /**
  * Decodes a quoted-printable piece of text in a given charset.
@@ -270,31 +278,29 @@ export function uint8ArrayToString(charset, bytes) {
  * @returns The text as a JavaScript string
  */
 export function decodeQuotedPrintable(charset, input) {
-	return (
-		input // https://tools.ietf.org/html/rfc2045#section-6.7, rule 3:
-			// “Therefore, when decoding a `Quoted-Printable` body, any trailing white
-			// space on a line must be deleted, as it will necessarily have been added
-			// by intermediate transport agents.”
-			.replace(/[\t\x20]$/gm, "") // Remove hard line breaks preceded by `=`. Proper `Quoted-Printable`-
-			// encoded data only contains CRLF line  endings, but for compatibility
-			// reasons we support separate CR and LF too.
-			.replace(/=(?:\r\n?|\n|$)/g, "") // Decode escape sequences of the form `=XX` where `XX` is any
-			// combination of two hexidecimal digits. For optimal compatibility,
-			// lowercase hexadecimal digits are supported as well. See
-			// https://tools.ietf.org/html/rfc2045#section-6.7, note 1.
-			.replace(/(=([a-fA-F0-9]{2}))+/g, match => {
-				const hexValues = match.split(/=/)
-				// splitting on '=' is convenient, but adds an empty string at the start due to the first byte
-				hexValues.shift()
-				const intArray = hexValues.map(char => parseInt(char, 16))
-				const bytes = Uint8Array.from(intArray)
-				return uint8ArrayToString(charset, bytes)
-			})
-	)
+    return (input // https://tools.ietf.org/html/rfc2045#section-6.7, rule 3:
+        // “Therefore, when decoding a `Quoted-Printable` body, any trailing white
+        // space on a line must be deleted, as it will necessarily have been added
+        // by intermediate transport agents.”
+        .replace(/[\t\x20]$/gm, "") // Remove hard line breaks preceded by `=`. Proper `Quoted-Printable`-
+        // encoded data only contains CRLF line  endings, but for compatibility
+        // reasons we support separate CR and LF too.
+        .replace(/=(?:\r\n?|\n|$)/g, "") // Decode escape sequences of the form `=XX` where `XX` is any
+        // combination of two hexidecimal digits. For optimal compatibility,
+        // lowercase hexadecimal digits are supported as well. See
+        // https://tools.ietf.org/html/rfc2045#section-6.7, note 1.
+        .replace(/(=([a-fA-F0-9]{2}))+/g, match => {
+        const hexValues = match.split(/=/);
+        // splitting on '=' is convenient, but adds an empty string at the start due to the first byte
+        hexValues.shift();
+        const intArray = hexValues.map(char => parseInt(char, 16));
+        const bytes = Uint8Array.from(intArray);
+        return uint8ArrayToString(charset, bytes);
+    }));
 }
 export function decodeBase64(charset, input) {
-	return uint8ArrayToString(charset, base64ToUint8Array(input))
+    return uint8ArrayToString(charset, base64ToUint8Array(input));
 }
 export function stringToBase64(str) {
-	return uint8ArrayToBase64(stringToUtf8Uint8Array(str))
+    return uint8ArrayToBase64(stringToUtf8Uint8Array(str));
 }

package/dist/LazyLoaded.d.ts

@@ -1,38 +1,38 @@
-import type { lazyAsync } from "./Utils.js"
+import type { lazyAsync } from "./Utils.js";
 /**
  * A wrapper for an object that shall be lazy loaded asynchronously. If loading the object is triggered in parallel (getAsync()) the object is actually only loaded once but returned to all calls of getAsync().
  * If the object was loaded once it is not loaded again.
  */
 export declare class LazyLoaded<T> {
-	_isLoaded: boolean
-	_loadingPromise: Promise<T> | null
-	_loadedObject: T | null
-	_loadFunction: lazyAsync<T>
-	/**
-	 * @param loadFunction The function that actually loads the object as soon as getAsync() is called the first time.
-	 * @param defaultValue The value that shall be returned by getSync() or getLoaded() as long as the object is not loaded yet.
-	 */
-	constructor(loadFunction: lazyAsync<T>, defaultValue?: T)
-	load(): this
-	isLoaded(): boolean
-	/**
-	 * Loads the object if it is not loaded yet. May be called in parallel and takes care that the load function is only called once.
-	 */
-	getAsync(): Promise<T>
-	/**
-	 * Returns null if the object is not loaded yet.
-	 */
-	getSync(): T | null
-	/**
-	 * Only call this function if you know that the object is already loaded.
-	 */
-	getLoaded(): T
-	/**
-	 * Removes the currently loaded object, so it will be loaded again with the next getAsync() call. Does not set any default value.
-	 */
-	reset(): void
-	/**
-	 * Loads the object again and replaces the current one
-	 */
-	reload(): Promise<T>
+    _isLoaded: boolean;
+    _loadingPromise: Promise<T> | null;
+    _loadedObject: T | null;
+    _loadFunction: lazyAsync<T>;
+    /**
+     * @param loadFunction The function that actually loads the object as soon as getAsync() is called the first time.
+     * @param defaultValue The value that shall be returned by getSync() or getLoaded() as long as the object is not loaded yet.
+     */
+    constructor(loadFunction: lazyAsync<T>, defaultValue?: T);
+    load(): this;
+    isLoaded(): boolean;
+    /**
+     * Loads the object if it is not loaded yet. May be called in parallel and takes care that the load function is only called once.
+     */
+    getAsync(): Promise<T>;
+    /**
+     * Returns null if the object is not loaded yet.
+     */
+    getSync(): T | null;
+    /**
+     * Only call this function if you know that the object is already loaded.
+     */
+    getLoaded(): T;
+    /**
+     * Removes the currently loaded object, so it will be loaded again with the next getAsync() call. Does not set any default value.
+     */
+    reset(): void;
+    /**
+     * Loads the object again and replaces the current one
+     */
+    reload(): Promise<T>;
 }