@tutao/tutanota-utils 3.91.1 → 3.91.4

package/dist/DateUtils.js

@@ -0,0 +1,114 @@
+/**
+ * @file DateUtils which do not use Luxon. Used in worker as well as in client parts.
+ * As functions here do not use Luxon it cannot be used for calculating things in different time zones, they
+ * are dependent on the system time zone.
+ */
+export const DAY_IN_MILLIS = 1000 * 60 * 60 * 24;
+/**
+ * Provides a date representing the beginning of the next day of the given date in local time.
+ */
+export function getStartOfNextDay(date) {
+    let d = new Date(date.getTime());
+    d.setDate(date.getDate() + 1);
+    d.setHours(0, 0, 0, 0); // sets the beginning of the day in local time
+    return d;
+}
+/**
+ * Provides a date representing the end of the given date in local time.
+ */
+export function getEndOfDay(date) {
+    let d = new Date(date.getTime());
+    d.setHours(23, 59, 59, 999);
+    return d;
+}
+/**
+ * Provides a date representing the beginning of the given date in local time.
+ */
+export function getStartOfDay(date) {
+    return getHourOfDay(date, 0);
+}
+/**
+ * Provides a date representing the day of the given date at the given hour in local time.
+ */
+export function getHourOfDay(date, hour) {
+    let d = new Date(date.getTime());
+    d.setHours(hour, 0, 0, 0);
+    return d;
+}
+export function isStartOfDay(date) {
+    return date.getHours() === 0 && date.getMinutes() === 0;
+}
+/**
+ * Returns true if the given date is today in local time.
+ */
+export function isToday(date) {
+    return new Date().toDateString() === date.toDateString();
+}
+/**
+ * Returns true if the given dates represent the same day (time of day is ignored).
+ */
+export function isSameDay(date1, date2) {
+    return date1.toDateString() === date2.toDateString();
+}
+/**
+ * Creates new date in with {@param days} added to it as if the days are just fixed
+ * periods of time and are not subject to daylight saving.
+ */
+export function getDayShifted(date, days) {
+    return new Date(date.getTime() + days * DAY_IN_MILLIS);
+}
+/**
+ * Increment the date in place and return it
+ */
+export function incrementDate(date, byValue) {
+    date.setDate(date.getDate() + byValue);
+    return date;
+}
+export function incrementMonth(d, byValue) {
+    const date = new Date(d);
+    date.setMonth(date.getMonth() + byValue);
+    return date;
+}
+export function isSameDayOfDate(date1, date2) {
+    return ((!date1 && !date2) ||
+        (date1 != null &&
+            date2 != null &&
+            date1.getFullYear() === date2.getFullYear() &&
+            date1.getMonth() === date2.getMonth() &&
+            date1.getDate() === date2.getDate()));
+}
+/**
+ * Formats as yyyy-mm-dd
+ */
+export function formatSortableDate(date) {
+    const month = ("0" + (date.getMonth() + 1)).slice(-2);
+    const day = ("0" + date.getDate()).slice(-2);
+    return `${date.getFullYear()}-${month}-${day}`;
+}
+/**
+ * Formats as yyyy-mm-dd-<hh>h-<mm>m-<ss>
+ */
+export function formatSortableDateTime(date) {
+    const hours = ("0" + date.getHours()).slice(-2);
+    const minutes = ("0" + date.getMinutes()).slice(-2);
+    const seconds = ("0" + date.getSeconds()).slice(-2);
+    return `${formatSortableDate(date)}-${hours}h${minutes}m${seconds}s`;
+}
+/**
+ * @returns {string} sortableDateTime of the current time
+ */
+export function sortableTimestamp() {
+    return formatSortableDateTime(new Date());
+}
+export function isValidDate(date) {
+    return !isNaN(date.getTime());
+}
+/**
+ * not interested in any fancy calendar edge cases, only use this where approximation is ok
+ */
+export function millisToDays(millis) {
+    return millis / DAY_IN_MILLIS;
+}
+export function daysToMillis(days) {
+    return days * DAY_IN_MILLIS;
+}

package/dist/Encoding.d.ts

@@ -0,0 +1,103 @@
+export declare type Base64 = string;
+export declare type Base64Ext = string;
+export declare type Base64Url = string;
+export declare type Hex = string;
+export declare function uint8ArrayToArrayBuffer(uint8Array: Uint8Array): ArrayBuffer;
+/**
+ * Converts a hex coded string into a base64 coded string.
+ *
+ * @param hex A hex encoded string.
+ * @return A base64 encoded string.
+ */
+export declare function hexToBase64(hex: Hex): Base64;
+/**
+ * Converts a base64 coded string into a hex coded string.
+ *
+ * @param base64 A base64 encoded string.
+ * @return A hex encoded string.
+ */
+export declare function base64ToHex(base64: Base64): Hex;
+/**
+ * Converts a base64 string to a url-conform base64 string. This is used for
+ * base64 coded url parameters.
+ *
+ * @param base64 The base64 string.
+ * @return The base64url string.
+ */
+export declare function base64ToBase64Url(base64: Base64): Base64Url;
+/**
+ * Converts a base64 string to a base64ext string. Base64ext uses another character set than base64 in order to make it sortable.
+ *
+ *
+ * @param base64 The base64 string.
+ * @return The base64Ext string.
+ */
+export declare function base64ToBase64Ext(base64: Base64): Base64Ext;
+/**
+ * Converts a Base64Ext string to a Base64 string and appends the padding if needed.
+ * @param base64ext The base64Ext string
+ * @returns The base64 string
+ */
+export declare function base64ExtToBase64(base64ext: Base64Ext): Base64;
+/**
+ * Converts a base64 url string to a "normal" base64 string. This is used for
+ * base64 coded url parameters.
+ *
+ * @param base64url The base64 url string.
+ * @return The base64 string.
+ */
+export declare function base64UrlToBase64(base64url: Base64Url): Base64;
+export declare function _stringToUtf8Uint8ArrayLegacy(string: string): Uint8Array;
+export declare function _replaceLoneSurrogates(s: string | null | undefined): string;
+/**
+ * Converts a string to a Uint8Array containing a UTF-8 string data.
+ *
+ * @param string The string to convert.
+ * @return The array.
+ */
+export declare function stringToUtf8Uint8Array(string: string): Uint8Array;
+export declare function _utf8Uint8ArrayToStringLegacy(uint8Array: Uint8Array): string;
+/**
+ * Converts an Uint8Array containing UTF-8 string data into a string.
+ *
+ * @param uint8Array The Uint8Array.
+ * @return The string.
+ */
+export declare function utf8Uint8ArrayToString(uint8Array: Uint8Array): string;
+export declare function hexToUint8Array(hex: Hex): Uint8Array;
+export declare function uint8ArrayToHex(uint8Array: Uint8Array): Hex;
+/**
+ * Converts an Uint8Array to a Base64 encoded string.
+ *
+ * @param bytes The bytes to convert.
+ * @return The Base64 encoded string.
+ */
+export declare function uint8ArrayToBase64(bytes: Uint8Array): Base64;
+export declare function int8ArrayToBase64(bytes: Int8Array): Base64;
+/**
+ * Converts a base64 encoded string to a Uint8Array.
+ *
+ * @param base64 The Base64 encoded string.
+ * @return The bytes.
+ */
+export declare function base64ToUint8Array(base64: Base64): Uint8Array;
+/**
+ * Converts a Uint8Array containing string data into a string, given the charset the data is in.
+ * @param charset The charset. Must be supported by TextDecoder.
+ * @param bytes The string data
+ * @trhows RangeError if the charset is not supported
+ * @return The string
+ */
+export declare function uint8ArrayToString(charset: string, bytes: Uint8Array): string;
+/**
+ * Decodes a quoted-printable piece of text in a given charset.
+ * This was copied and modified from https://github.com/mathiasbynens/quoted-printable/blob/master/src/quoted-printable.js (MIT licensed)
+ *
+ * @param charset Must be supported by TextEncoder
+ * @param input The encoded text
+ * @throws RangeError if the charset is not supported
+ * @returns The text as a JavaScript string
+ */
+export declare function decodeQuotedPrintable(charset: string, input: string): string;
+export declare function decodeBase64(charset: string, input: string): string;
+export declare function stringToBase64(str: string): string;

package/dist/Encoding.js

@@ -0,0 +1,306 @@
+// 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
+    }
+}
+/**
+ * Converts a hex coded string into a base64 coded string.
+ *
+ * @param hex A hex encoded string.
+ * @return A base64 encoded string.
+ */
+export function hexToBase64(hex) {
+    return uint8ArrayToBase64(hexToUint8Array(hex));
+}
+/**
+ * Converts a base64 coded string into a hex coded string.
+ *
+ * @param base64 A base64 encoded string.
+ * @return A hex encoded string.
+ */
+export function base64ToHex(base64) {
+    return uint8ArrayToHex(base64ToUint8Array(base64));
+}
+/**
+ * Converts a base64 string to a url-conform base64 string. This is used for
+ * base64 coded url parameters.
+ *
+ * @param base64 The base64 string.
+ * @return The base64url string.
+ */
+export function base64ToBase64Url(base64) {
+    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 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.
+ *
+ *
+ * @param base64 The base64 string.
+ * @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;
+}
+/**
+ * Converts a Base64Ext string to a Base64 string and appends the padding if needed.
+ * @param base64ext The base64Ext string
+ * @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;
+}
+/**
+ * Converts a base64 url string to a "normal" base64 string. This is used for
+ * base64 coded url parameters.
+ *
+ * @param base64url The base64 url string.
+ * @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.");
+}
+// 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;
+}
+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("");
+}
+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.
+ *
+ * @param string The string to convert.
+ * @return The array.
+ */
+export function stringToUtf8Uint8Array(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("")));
+}
+/**
+ * Converts an Uint8Array containing UTF-8 string data into a string.
+ *
+ * @param uint8Array The Uint8Array.
+ * @return The string.
+ */
+export function utf8Uint8ArrayToString(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;
+}
+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;
+}
+/**
+ * Converts an Uint8Array to a Base64 encoded string.
+ *
+ * @param bytes The bytes to convert.
+ * @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);
+}
+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);
+}
+/**
+ * Converts a base64 encoded string to a Uint8Array.
+ *
+ * @param base64 The Base64 encoded string.
+ * @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;
+}
+/**
+ * Converts a Uint8Array containing string data into a string, given the charset the data is in.
+ * @param charset The charset. Must be supported by TextDecoder.
+ * @param bytes The string data
+ * @trhows RangeError if the charset is not supported
+ * @return The string
+ */
+export function uint8ArrayToString(charset, bytes) {
+    const decoder = new TextDecoder(charset);
+    return decoder.decode(bytes);
+}
+/**
+ * Decodes a quoted-printable piece of text in a given charset.
+ * This was copied and modified from https://github.com/mathiasbynens/quoted-printable/blob/master/src/quoted-printable.js (MIT licensed)
+ *
+ * @param charset Must be supported by TextEncoder
+ * @param input The encoded text
+ * @throws RangeError if the charset is not supported
+ * @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);
+    }));
+}
+export function decodeBase64(charset, input) {
+    return uint8ArrayToString(charset, base64ToUint8Array(input));
+}
+export function stringToBase64(str) {
+    return uint8ArrayToBase64(stringToUtf8Uint8Array(str));
+}

package/dist/LazyLoaded.d.ts

@@ -0,0 +1,38 @@
+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>;
+}

package/dist/LazyLoaded.js

@@ -0,0 +1,72 @@
+import { neverNull } 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 class LazyLoaded {
+    /**
+     * @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, defaultValue) {
+        this._isLoaded = false;
+        this._loadFunction = loadFunction;
+        this._loadingPromise = null;
+        this._loadedObject = defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+    }
+    load() {
+        this.getAsync();
+        return this;
+    }
+    isLoaded() {
+        return this._isLoaded;
+    }
+    /**
+     * 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() {
+        if (this.isLoaded()) {
+            return Promise.resolve(neverNull(this._loadedObject));
+        }
+        else {
+            if (!this._loadingPromise) {
+                this._loadingPromise = this._loadFunction().then(result => {
+                    this._loadedObject = result;
+                    this._isLoaded = true;
+                    return result;
+                });
+            }
+            return this._loadingPromise;
+        }
+    }
+    /**
+     * Returns null if the object is not loaded yet.
+     */
+    getSync() {
+        return this._loadedObject;
+    }
+    /**
+     * Only call this function if you know that the object is already loaded.
+     */
+    getLoaded() {
+        return neverNull(this._loadedObject);
+    }
+    /**
+     * Removes the currently loaded object, so it will be loaded again with the next getAsync() call. Does not set any default value.
+     */
+    reset() {
+        this._isLoaded = false;
+        this._loadingPromise = null;
+        this._loadedObject = null;
+    }
+    /**
+     * Loads the object again and replaces the current one
+     */
+    reload() {
+        return this._loadFunction().then(result => {
+            this._isLoaded = true;
+            this._loadedObject = result;
+            return result;
+        });
+    }
+}

package/dist/MapUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Merges multiple maps into a single map with lists of values.
+ * @param maps
+ */
+export declare function mergeMaps<T>(maps: Map<string, T>[]): Map<string, T[]>;
+export declare function getFromMap<K, V>(map: Map<K, V>, key: K, byDefault: () => V): V;
+/** Creates a new map with key and value added to {@param map}. It is like set() but for immutable map. */
+export declare function addMapEntry<K, V>(map: ReadonlyMap<K, V>, key: K, value: V): Map<K, V>;
+export declare function deleteMapEntry<K, V>(map: ReadonlyMap<K, V>, key: K): Map<K, V>;

package/dist/MapUtils.js

@@ -0,0 +1,38 @@
+import { neverNull } from "./Utils.js";
+/**
+ * Merges multiple maps into a single map with lists of values.
+ * @param maps
+ */
+export function mergeMaps(maps) {
+    return maps.reduce((mergedMap, map) => {
+        // merge same key of multiple attributes
+        map.forEach((value, key) => {
+            if (mergedMap.has(key)) {
+                neverNull(mergedMap.get(key)).push(value);
+            }
+            else {
+                mergedMap.set(key, [value]);
+            }
+        });
+        return mergedMap;
+    }, new Map());
+}
+export function getFromMap(map, key, byDefault) {
+    let value = map.get(key);
+    if (!value) {
+        value = byDefault();
+        map.set(key, value);
+    }
+    return value;
+}
+/** Creates a new map with key and value added to {@param map}. It is like set() but for immutable map. */
+export function addMapEntry(map, key, value) {
+    const newMap = new Map(map);
+    newMap.set(key, value);
+    return newMap;
+}
+export function deleteMapEntry(map, key) {
+    const newMap = new Map(map);
+    newMap.delete(key);
+    return newMap;
+}

package/dist/MathUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function mod(n: number, m: number): number;
+/**
+ * Clamp value to between min and max (inclusive)
+ */
+export declare function clamp(value: number, min: number, max: number): number;