@ngrdt/utils 0.0.77 → 0.0.80

package/fesm2022/ngrdt-utils.mjs

@@ -1,8 +1,1620 @@
-"use strict";
+import { Observable, combineLatest, startWith, map, switchMap, EMPTY, of } from 'rxjs';
+import { assertInInjectionContext, inject, Injector, effect, untracked, DestroyRef } from '@angular/core';
+
+var RdtEncoding;
+(function (RdtEncoding) {
+    RdtEncoding["UTF_8"] = "utf-8";
+    RdtEncoding["IBM_866"] = "ibm866";
+    RdtEncoding["ISO_8859_2"] = "iso-8859-2";
+    RdtEncoding["ISO_8859_3"] = "iso-8859-3";
+    RdtEncoding["ISO_8859_4"] = "iso-8859-4";
+    RdtEncoding["ISO_8859_5"] = "iso-8859-5";
+    RdtEncoding["ISO_8859_6"] = "iso-8859-6";
+    RdtEncoding["ISO_8859_7"] = "iso-8859-7";
+    RdtEncoding["ISO_8859_8"] = "iso-8859-8";
+    RdtEncoding["ISO_8859_8_I"] = "iso-8859-8-i";
+    RdtEncoding["ISO_8859_10"] = "iso-8859-10";
+    RdtEncoding["ISO_8859_13"] = "iso-8859-13";
+    RdtEncoding["ISO_8859_14"] = "iso-8859-14";
+    RdtEncoding["ISO_8859_15"] = "iso-8859-15";
+    RdtEncoding["ISO_8859_16"] = "iso-8859-16";
+    RdtEncoding["KOI8_R"] = "koi8-r";
+    RdtEncoding["MACINTOSH"] = "macintosh";
+    RdtEncoding["WINDOWS_874"] = "windows-874";
+    RdtEncoding["WINDOWS_1250"] = "windows-1250";
+    RdtEncoding["WINDOWS_1251"] = "windows-1251";
+    RdtEncoding["WINDOWS_1252"] = "windows-1252";
+    RdtEncoding["WINDOWS_1253"] = "windows-1253";
+    RdtEncoding["WINDOWS_1254"] = "windows-1254";
+    RdtEncoding["WINDOWS_1255"] = "windows-1255";
+    RdtEncoding["WINDOWS_1256"] = "windows-1256";
+    RdtEncoding["WINDOWS_1257"] = "windows-1257";
+    RdtEncoding["WINDOWS_1258"] = "windows-1258";
+    RdtEncoding["X_MAC_CYRILLIC"] = "x-mac-cyrillic";
+    RdtEncoding["GBK"] = "gbk";
+    RdtEncoding["GB18030"] = "gb18030";
+    RdtEncoding["BIG5"] = "big5";
+    RdtEncoding["EUC_JP"] = "euc-jp";
+    RdtEncoding["ISO_2022_JP"] = "iso-2022-jp";
+    RdtEncoding["SHIFT_JIS"] = "shift-jis";
+    RdtEncoding["EUC_KR"] = "euc-kr";
+    RdtEncoding["HZ_GB_2312"] = "hz-gb-2312";
+    RdtEncoding["ISO_2022_CN"] = "iso-2022-cn";
+    RdtEncoding["ISO_2022_CN_EXT"] = "iso-2022-cn-ext";
+    RdtEncoding["ISO_2022_KR"] = "iso-2022-kr";
+    RdtEncoding["UTF_16"] = "utf-16";
+    RdtEncoding["X_USER_DEFINED"] = "x-user-defined";
+})(RdtEncoding || (RdtEncoding = {}));
+
+const ARROW = {
+    UP: 'ArrowUp',
+    DOWN: 'ArrowDown',
+    LEFT: 'ArrowLeft',
+    RIGHT: 'ArrowRight',
+};
+const KB_KEY = {
+    SPACEBAR: ' ',
+    ENTER: 'Enter',
+    ESCAPE: 'Escape',
+    HOME: 'Home',
+    END: 'End',
+    TAB: 'Tab',
+    ARROW: ARROW,
+};
+const KB_CODE = {
+    ...KB_KEY,
+    SPACEBAR: 'Space',
+};
+const ALPHABET_KEYCODES = Array.from(Array(26)).map((e, i) => i + 65);
+const ALPHABET_KB_KEYS = ALPHABET_KEYCODES.map(x => String.fromCharCode(x));
+const KB_ALPHABET_CODES = ALPHABET_KB_KEYS.map(key => `Key${key.toUpperCase()}`);
+
+var RdtMimeType;
+(function (RdtMimeType) {
+    RdtMimeType["DOCX"] = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    RdtMimeType["XLSX"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    RdtMimeType["PDF"] = "application/pdf";
+    RdtMimeType["TXT"] = "text/plain";
+    RdtMimeType["CSV"] = "text/csv";
+    RdtMimeType["ZIP"] = "application/zip";
+    RdtMimeType["JPG"] = "image/jpeg";
+    RdtMimeType["PNG"] = "image/png";
+    RdtMimeType["GIF"] = "image/gif";
+    RdtMimeType["SVG"] = "image/svg+xml";
+    RdtMimeType["HTML"] = "text/html";
+    RdtMimeType["XML"] = "application/xml";
+    RdtMimeType["JSON"] = "application/json";
+    RdtMimeType["MP3"] = "audio/mpeg";
+    RdtMimeType["MP4"] = "video/mp4";
+    RdtMimeType["OGG"] = "audio/ogg";
+    RdtMimeType["WEBM"] = "video/webm";
+    RdtMimeType["WAV"] = "audio/wav";
+    RdtMimeType["AVI"] = "video/x-msvideo";
+    RdtMimeType["MPEG"] = "video/mpeg";
+    RdtMimeType["WEBP"] = "image/webp";
+    RdtMimeType["ICO"] = "image/x-icon";
+    RdtMimeType["TTF"] = "font/ttf";
+    RdtMimeType["WOFF"] = "font/woff";
+    RdtMimeType["WOFF2"] = "font/woff2";
+    RdtMimeType["EOT"] = "application/vnd.ms-fontobject";
+    RdtMimeType["OTF"] = "font/otf";
+    RdtMimeType["PPTX"] = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    RdtMimeType["PPT"] = "application/vnd.ms-powerpoint";
+    RdtMimeType["XLS"] = "application/vnd.ms-excel";
+    RdtMimeType["DOC"] = "application/msword";
+    RdtMimeType["ODT"] = "application/vnd.oasis.opendocument.text";
+    RdtMimeType["ODS"] = "application/vnd.oasis.opendocument.spreadsheet";
+    RdtMimeType["ODP"] = "application/vnd.oasis.opendocument.presentation";
+    RdtMimeType["ODF"] = "application/vnd.oasis.opendocument.formula";
+    RdtMimeType["RAR"] = "application/vnd.rar";
+    RdtMimeType["TAR"] = "application/x-tar";
+    RdtMimeType["GZIP"] = "application/gzip";
+    RdtMimeType["BZIP2"] = "application/x-bzip2";
+    RdtMimeType["XZ"] = "application/x-xz";
+    RdtMimeType["SEVENZ"] = "application/x-7z-compressed";
+    RdtMimeType["RAR5"] = "application/x-rar-compressed";
+    RdtMimeType["WMA"] = "audio/x-ms-wma";
+    RdtMimeType["WMV"] = "video/x-ms-wmv";
+    RdtMimeType["FLV"] = "video/x-flv";
+    RdtMimeType["OGV"] = "video/ogg";
+    RdtMimeType["BIN"] = "application/octet-stream";
+    RdtMimeType["UNKNOWN"] = "unknown";
+})(RdtMimeType || (RdtMimeType = {}));
+var RdtCombinedMimeType;
+(function (RdtCombinedMimeType) {
+    RdtCombinedMimeType["IMAGE"] = "image/*";
+    RdtCombinedMimeType["AUDIO"] = "audio/*";
+    RdtCombinedMimeType["VIDEO"] = "video/*";
+    RdtCombinedMimeType["FONT"] = "font/*";
+    RdtCombinedMimeType["DOCUMENT"] = "application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.oasis.opendocument.text,application/pdf,text/plain,text/csv";
+    RdtCombinedMimeType["SPREADSHEET"] = "application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,application/vnd.oasis.opendocument.spreadsheet";
+    RdtCombinedMimeType["PRESENTATION"] = "application/vnd.ms-powerpoint,application/vnd.openxmlformats-officedocument.presentationml.presentation,application/vnd.oasis.opendocument.presentation";
+    RdtCombinedMimeType["ARCHIVE"] = "application/zip,application/vnd.rar,application/x-tar,application/gzip,application/x-bzip2,application/x-xz,application/x-7z-compressed,application/x-rar-compressed";
+})(RdtCombinedMimeType || (RdtCombinedMimeType = {}));
+const EXTENSION_BY_MIME_TYPE = {
+    [RdtMimeType.DOCX]: 'docx',
+    [RdtMimeType.XLSX]: 'xlsx',
+    [RdtMimeType.PDF]: 'pdf',
+    [RdtMimeType.TXT]: 'txt',
+    [RdtMimeType.CSV]: 'csv',
+    [RdtMimeType.ZIP]: 'zip',
+    [RdtMimeType.JPG]: 'jpg',
+    [RdtMimeType.PNG]: 'png',
+    [RdtMimeType.GIF]: 'gif',
+    [RdtMimeType.SVG]: 'svg',
+    [RdtMimeType.HTML]: 'html',
+    [RdtMimeType.XML]: 'xml',
+    [RdtMimeType.JSON]: 'json',
+    [RdtMimeType.MP3]: 'mp3',
+    [RdtMimeType.MP4]: 'mp4',
+    [RdtMimeType.OGG]: 'ogg',
+    [RdtMimeType.WEBM]: 'webm',
+    [RdtMimeType.WAV]: 'wav',
+    [RdtMimeType.AVI]: 'avi',
+    [RdtMimeType.MPEG]: 'mpeg',
+    [RdtMimeType.WEBP]: 'webp',
+    [RdtMimeType.ICO]: 'ico',
+    [RdtMimeType.TTF]: 'ttf',
+    [RdtMimeType.WOFF]: 'woff',
+    [RdtMimeType.WOFF2]: 'woff2',
+    [RdtMimeType.EOT]: 'eot',
+    [RdtMimeType.OTF]: 'otf',
+    [RdtMimeType.PPTX]: 'pptx',
+    [RdtMimeType.PPT]: 'ppt',
+    [RdtMimeType.XLS]: 'xls',
+    [RdtMimeType.DOC]: 'doc',
+    [RdtMimeType.ODT]: 'odt',
+    [RdtMimeType.ODS]: 'ods',
+    [RdtMimeType.ODP]: 'odp',
+    [RdtMimeType.ODF]: 'odf',
+    [RdtMimeType.RAR]: 'rar',
+    [RdtMimeType.TAR]: 'tar',
+    [RdtMimeType.GZIP]: 'gz',
+    [RdtMimeType.BZIP2]: 'bz2',
+    [RdtMimeType.XZ]: 'xz',
+    [RdtMimeType.SEVENZ]: '7z',
+    [RdtMimeType.RAR5]: 'rar',
+    [RdtMimeType.WMA]: 'wma',
+    [RdtMimeType.WMV]: 'wmv',
+    [RdtMimeType.FLV]: 'flv',
+    [RdtMimeType.OGV]: 'ogv',
+    [RdtMimeType.BIN]: 'bin',
+    [RdtMimeType.UNKNOWN]: 'unknown',
+};
+const MIME_TYPE_BY_EXTENSION = {};
+for (const [key, value] of Object.entries(EXTENSION_BY_MIME_TYPE)) {
+    MIME_TYPE_BY_EXTENSION[value] = key;
+}
+
+class RdtArrayUtils {
+    static removeAt(array, index) {
+        if (index < 0 || index > array.length) {
+            throw new Error(`Out of bounds! Array length: ${array.length}, index: ${index}`);
+        }
+        return [...array.slice(0, index), ...array.slice(index + 1)];
+    }
+    static insertAt(array, index, item) {
+        if (index < 0 || index > array.length) {
+            throw new Error(`Out of bounds! Array length: ${array.length}, index: ${index}`);
+        }
+        return [...array.slice(0, index), item, ...array.slice(index)];
+    }
+    static isEqual(a, b) {
+        if (!a || !b) {
+            return !a === !b;
+        }
+        return a.length === b.length && a.every((el) => b.indexOf(el) > -1);
+    }
+}
+
+class RdtCssUtils {
+    static normalizeColor(color) {
+        const normalized = color.trim();
+        if (this.isHexColor(normalized)) {
+            return RdtCssUtils.normalizeHex(normalized);
+        }
+        else if (this.isRgbColor(normalized)) {
+            return RdtCssUtils.normalizeRgb(normalized);
+        }
+        else if (this.isRgbaColor(normalized)) {
+            return RdtCssUtils.normalizeRgba(normalized);
+        }
+        return null;
+    }
+    static normalizeHex(color) {
+        const matches = color.match(RdtCssUtils.hexRegex);
+        if (!matches) {
+            return null;
+        }
+        return `#${matches[2]}`;
+    }
+    static normalizeRgb(color) {
+        const matches = color.match(RdtCssUtils.rgbRegex);
+        if (!matches) {
+            return null;
+        }
+        return `rgb(${matches[2]},${matches[3]},${matches[4]})`;
+    }
+    static normalizeRgba(color) {
+        const matches = color.match(RdtCssUtils.rgbaRegex);
+        if (!matches) {
+            return null;
+        }
+        return `rgba(${matches[2]},${matches[3]},${matches[4]},${matches[5]})`;
+    }
+    static isRgbColor(color) {
+        return RdtCssUtils.rgbRegex.test(color);
+    }
+    static isHexColor(color) {
+        return RdtCssUtils.hexRegex.test(color);
+    }
+    static isRgbaColor(color) {
+        return RdtCssUtils.rgbaRegex.test(color);
+    }
+    static rgbRegex = /^(rgb)?\(?\s*([01]?\d\d?|2[0-4]\d|25[0-5])\W+([01]?\d\d?|2[0-4]\d|25[0-5])\W+([01]?\d\d?|2[0-4]\d|25[0-5])\s*\)?$/;
+    static rgbaRegex = /^(rgba)?\(?\s*([01]?\d\d?|2[0-4]\d|25[0-5])\W+([01]?\d\d?|2[0-4]\d|25[0-5])\W+([01]?\d\d?|2[0-4]\d|25[0-5])\W+((0(\.\d+)?)|(1(\.0)?))\s*\)?$/;
+    static hexRegex = /^(#?)([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+}
+
+class RdtDateUtils {
+    static MS = 1;
+    static SECOND = 1000 * RdtDateUtils.MS;
+    static MINUTE = 60 * RdtDateUtils.SECOND;
+    static HOUR = 60 * RdtDateUtils.MINUTE;
+    static DAY = 24 * RdtDateUtils.HOUR;
+    /**
+     * Returns number of days between two dates.
+     * Returns zero in case dates are the same. Ignores time.
+     */
+    static getDays(a, b) {
+        return (RdtDateUtils.getDayOffset(new Date(a)) -
+            RdtDateUtils.getDayOffset(new Date(b)));
+    }
+    static checkDate(year, month, day) {
+        const d = new Date(year, month - 1, day);
+        return (d.getFullYear() === year &&
+            d.getMonth() + 1 === month &&
+            d.getDate() === day);
+    }
+    static isValidDate(value) {
+        if (value == null) {
+            return false;
+        }
+        if (value instanceof Date) {
+            return !isNaN(value.getTime());
+        }
+        return !isNaN(new Date(value).getTime());
+    }
+    static startOfDay(input) {
+        const date = new Date(input);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    static endOfDay(input) {
+        const date = new Date(input);
+        date.setHours(23, 59, 59);
+        return date;
+    }
+    static startOfMonth(input) {
+        const date = new Date(input);
+        date.setHours(0, 0, 0, 0);
+        date.setDate(1);
+        return date;
+    }
+    static endOfMonth(input) {
+        const date = new Date(input);
+        date.setHours(23, 59, 59);
+        date.setDate(0);
+        return date;
+    }
+    static startOfYear(year) {
+        return new Date(year, Month.January, 1);
+    }
+    static endOfYear(year) {
+        return new Date(year, Month.December, 31);
+    }
+    static beginningOfNextMonth() {
+        const today = new Date();
+        if (today.getMonth() === 11) {
+            return new Date(today.getFullYear() + 1, 0, 1);
+        }
+        else {
+            return new Date(today.getFullYear(), today.getMonth() + 1, 1);
+        }
+    }
+    static endOfNextMonth() {
+        const today = new Date();
+        if (today.getMonth() === 10) {
+            const firstDayOfInTwoMonths = new Date(today.getFullYear() + 1, 0, 1);
+            return this.minusOneDay(firstDayOfInTwoMonths);
+        }
+        else if (today.getMonth() === 11) {
+            const firstDayOfInTwoMonths = new Date(today.getFullYear() + 1, 1, 1);
+            return this.minusOneDay(firstDayOfInTwoMonths);
+        }
+        else {
+            const firstDayOfInTwoMonths = new Date(today.getFullYear(), today.getMonth() + 2, 1);
+            return this.minusOneDay(firstDayOfInTwoMonths);
+        }
+    }
+    static beginningOfInThreeMonths() {
+        const today = new Date();
+        if (today.getMonth() === 10) {
+            return new Date(today.getFullYear() + 1, 1, 1);
+        }
+        else if (today.getMonth() === 11) {
+            return new Date(today.getFullYear() + 1, 2, 1);
+        }
+        else {
+            return new Date(today.getFullYear(), today.getMonth() + 3, 1);
+        }
+    }
+    static endOfInNextThreeMonths() {
+        const today = new Date();
+        if (today.getMonth() === 9) {
+            const firstDayOfInFourMonths = new Date(today.getFullYear() + 1, 1, 1);
+            return this.minusOneDay(firstDayOfInFourMonths);
+        }
+        else if (today.getMonth() === 10) {
+            const firstDayOfInFourMonths = new Date(today.getFullYear() + 1, 2, 1);
+            return this.minusOneDay(firstDayOfInFourMonths);
+        }
+        else if (today.getMonth() === 11) {
+            const firstDayOfInFourMonths = new Date(today.getFullYear() + 1, 3, 1);
+            return this.minusOneDay(firstDayOfInFourMonths);
+        }
+        else {
+            const firstDayOfInFourMonths = new Date(today.getFullYear(), today.getMonth() + 4, 1);
+            return this.minusOneDay(firstDayOfInFourMonths);
+        }
+    }
+    static minusOneDay(date) {
+        return new Date(date.getTime() - RdtDateUtils.DAY);
+    }
+    static toISOLocal(d) {
+        const year = d.getFullYear();
+        const month = `${d.getMonth() + 1}`.padStart(2, '0');
+        const day = `${d.getDate()}`.padStart(2, '0');
+        const hours = `${d.getHours()}`.padStart(2, '0');
+        const minutes = `${d.getMinutes()}`.padStart(2, '0');
+        const seconds = `${d.getSeconds()}`.padStart(2, '0');
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}`;
+    }
+    static formatDate(date) {
+        if (date === null || date === undefined || date === '') {
+            return '';
+        }
+        const d = date instanceof Date ? date : new Date(date);
+        if (RdtDateUtils.isValidDate(d)) {
+            const year = d.getFullYear();
+            const month = `${d.getMonth() + 1}`.padStart(2, '0');
+            const day = `${d.getDate()}`.padStart(2, '0');
+            return `${day}.${month}.${year}`;
+        }
+        else {
+            return '';
+        }
+    }
+    static timeToDate(time) {
+        const date = new Date(0);
+        if (RdtDateUtils.hhMmSsMsRegex.test(time)) {
+            const matches = time.match(RdtDateUtils.hhMmSsMsRegex);
+            if (matches) {
+                const h = parseInt(matches[1]);
+                const m = parseInt(matches[2]);
+                const s = parseInt(matches[3]);
+                const ms = parseInt(matches[4]);
+                date.setHours(h, m, s, ms);
+                return date;
+            }
+        }
+        else if (RdtDateUtils.hhMmSsRegex.test(time)) {
+            const matches = time.match(RdtDateUtils.hhMmSsRegex);
+            if (matches) {
+                const h = parseInt(matches[1]);
+                const m = parseInt(matches[2]);
+                const s = parseInt(matches[3]);
+                date.setHours(h, m, s);
+                return date;
+            }
+        }
+        else if (RdtDateUtils.hhMmRegex.test(time)) {
+            const matches = time.match(RdtDateUtils.hhMmRegex);
+            if (matches) {
+                const h = parseInt(matches[1]);
+                const m = parseInt(matches[2]);
+                date.setHours(h, m);
+                return date;
+            }
+        }
+        return null;
+    }
+    static setTime(date, time) {
+        const newDate = new Date(date);
+        const timeDate = RdtDateUtils.timeToDate(time);
+        if (timeDate) {
+            newDate.setHours(timeDate.getHours(), timeDate.getMinutes(), timeDate.getSeconds(), timeDate.getMilliseconds());
+        }
+        return newDate;
+    }
+    static getTime(d, showSeconds = true) {
+        const hh = d.getHours().toString().padStart(2, '0');
+        const mm = d.getMinutes().toString().padStart(2, '0');
+        if (showSeconds) {
+            const ss = d.getSeconds().toString().padStart(2, '0');
+            return `${hh}:${mm}:${ss}`;
+        }
+        else {
+            return `${hh}:${mm}`;
+        }
+    }
+    static parseToDate(input) {
+        if (input instanceof Date) {
+            return RdtDateUtils.isValidDate(input) ? input : null;
+        }
+        if (typeof input === 'string') {
+            const date = new Date(input);
+            if (RdtDateUtils.isValidDate(date)) {
+                return date;
+            }
+        }
+        return null;
+    }
+    static parse(input) {
+        if (input instanceof Date) {
+            return RdtDateUtils.isValidDate(input) ? input.getTime() : null;
+        }
+        if (typeof input === 'string') {
+            const date = new Date(input);
+            if (RdtDateUtils.isValidDate(date)) {
+                return date.getTime();
+            }
+        }
+        return null;
+    }
+    static isEqual(d1, d2) {
+        if (d1 === d2) {
+            return true;
+        }
+        if (!d1 || !d2) {
+            return false;
+        }
+        return d1.getTime() === d2.getTime();
+    }
+    static isLeapYear(year) {
+        return new Date(year, 1, 29).getDate() === 29;
+    }
+    static getDaysInYear(year) {
+        return RdtDateUtils.isLeapYear(year) ? 366 : 365;
+    }
+    static hhMmRegex = /^\s*([0-9]|0[0-9]|1[0-9]|2[0-3])\s*\W+\s*([0-5]?[0-9])\s*$/;
+    static hhMmSsRegex = /^\s*([0-9]|0[0-9]|1[0-9]|2[0-3])\s*\W+\s*([0-5]?[0-9])\s*\W+\s*([0-5]?\d)\s*$/;
+    static hhMmSsMsRegex = /^\s*([0-9]|0[0-9]|1[0-9]|2[0-3])\s*\W+\s*([0-5]?[0-9])\s*\W+\s*([0-5]?\d)\s*[\W|\s]\s*(\d{1,3})\s*$/;
+    static daysUpToMonth = [
+        0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
+    ];
+    static daysUpToMonthLeapYear = [
+        0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335,
+    ];
+    static getDayOffset(date) {
+        const year = date.getFullYear() - 1;
+        const month = date.getMonth() + 1, day = date.getDate();
+        const numOfLeapsYear = Math.trunc(year / 4) - Math.trunc(year / 100) + Math.trunc(year / 400);
+        if (RdtDateUtils.isLeapYear(year + 1)) {
+            return (year * 365 +
+                numOfLeapsYear +
+                RdtDateUtils.daysUpToMonthLeapYear[month - 1] +
+                day -
+                1);
+        }
+        else {
+            return (year * 365 +
+                numOfLeapsYear +
+                RdtDateUtils.daysUpToMonth[month - 1] +
+                day -
+                1);
+        }
+    }
+    static doubleDigitYearToPast(year2) {
+        // If current year is 2024 and input is 24 or less, then result is 2024
+        // If input is 25 or greater, then result is 1925-1999
+        const currentYear = RdtDateUtils.getCurrentYear();
+        const current2 = currentYear % 100;
+        if (year2 <= current2) {
+            return year2 + currentYear - current2;
+        }
+        else {
+            return year2 + currentYear - current2 - 100;
+        }
+    }
+    static doubleDigitYearToFuture(year2) {
+        // If current year is 2024 and input is 24 or less, then result is 2124
+        // If input is 25 or greater, then result is 2025-2099
+        const currentYear = RdtDateUtils.getCurrentYear();
+        const current2 = currentYear % 100;
+        if (year2 >= current2) {
+            return year2 + currentYear - current2;
+        }
+        else {
+            return year2 + currentYear - current2 + 100;
+        }
+    }
+    static getCurrentYear() {
+        return new Date().getFullYear();
+    }
+    static calculateAge(birthDateStr, referenceDateStr) {
+        const birthDate = new Date(birthDateStr);
+        const referenceDate = new Date(referenceDateStr);
+        let age = referenceDate.getFullYear() - birthDate.getFullYear();
+        const monthDifference = referenceDate.getMonth() - birthDate.getMonth();
+        const dayDifference = referenceDate.getDate() - birthDate.getDate();
+        if (monthDifference < 0 || (monthDifference === 0 && dayDifference < 0)) {
+            age--;
+        }
+        return age;
+    }
+}
+var Month;
+(function (Month) {
+    Month[Month["January"] = 0] = "January";
+    Month[Month["February"] = 1] = "February";
+    Month[Month["March"] = 2] = "March";
+    Month[Month["April"] = 3] = "April";
+    Month[Month["May"] = 4] = "May";
+    Month[Month["June"] = 5] = "June";
+    Month[Month["July"] = 6] = "July";
+    Month[Month["August"] = 7] = "August";
+    Month[Month["September"] = 8] = "September";
+    Month[Month["October"] = 9] = "October";
+    Month[Month["November"] = 10] = "November";
+    Month[Month["December"] = 11] = "December";
+})(Month || (Month = {}));
+
+class RdtHTMLUtils {
+    static scrollIntoViewHorizontallyWithinParent(element) {
+        const container = element.parentElement;
+        if (!container) {
+            return;
+        }
+        const elOffset = element.offsetLeft;
+        const elWidth = element.offsetWidth;
+        const containerWidth = container.offsetWidth;
+        const currentScroll = container.scrollLeft;
+        const alignLeft = elOffset;
+        const alignRight = elOffset - containerWidth + elWidth;
+        if (currentScroll > alignLeft) {
+            container.scrollLeft = alignLeft;
+        }
+        else if (currentScroll < alignRight) {
+            container.scrollLeft = alignRight;
+        }
+    }
+    static setCaretPosition(element, index) {
+        element.focus();
+        element.setSelectionRange(index, index);
+    }
+}
+
+class RdtStringUtils {
+    static tokenize(value) {
+        return value ? value.split(/\W+/).filter((tokens) => !!tokens) : [];
+    }
+    static joinPaths(parent, child) {
+        const b = parent.endsWith('/');
+        const p = child.startsWith('/');
+        if (b && p) {
+            return parent.slice(0, -1) + child;
+        }
+        else if (b || p) {
+            return parent + child;
+        }
+        else {
+            return parent + '/' + child;
+        }
+    }
+    static isAlphabetCharacter(char) {
+        if (char.length > 1) {
+            return false;
+        }
+        return char.toLocaleLowerCase() !== char.toLocaleUpperCase();
+    }
+    static isNumericCharacter(char) {
+        return !isNaN(parseInt(char));
+    }
+    static capitalize(str) {
+        return str.charAt(0).toLocaleUpperCase() + str.slice(1);
+    }
+    static toDataTestId(str) {
+        return RdtStringUtils.removeAccents(str).toLowerCase()?.replace(/ /g, '-');
+    }
+    static removeAccents(str) {
+        return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    }
+    static stripTrailingSlash(url) {
+        const match = url.match(/#|\?|$/);
+        const pathEndIdx = (match && match.index) || url.length;
+        const droppedSlashIdx = pathEndIdx - (url[pathEndIdx - 1] === '/' ? 1 : 0);
+        return url.slice(0, droppedSlashIdx) + url.slice(pathEndIdx);
+    }
+    static createAbsoluteUrl(url, baseHref) {
+        return RdtStringUtils.joinPaths(baseHref, url);
+    }
+    static appendQueryParams(url, params) {
+        if (!params || Object.keys(params).length === 0) {
+            return url;
+        }
+        else {
+            const queryParams = new URLSearchParams(params);
+            return `${url}?${queryParams}`;
+        }
+    }
+    static localeCompare(a, b, order = 'asc') {
+        const mult = order === 'asc' ? 1 : -1;
+        if (a == b) {
+            return 0;
+        }
+        else if (a == null) {
+            return -mult;
+        }
+        else if (b == null) {
+            return mult;
+        }
+        return a.localeCompare(b) * mult;
+    }
+    static komixcomlocalReplaceString(url) {
+        const hostname = location.hostname;
+        const replaceString = url.includes('komix.com')
+            ? 'komix.com'
+            : 'komix.local';
+        const toReplace = hostname.includes('komix.com')
+            ? 'komix.com'
+            : 'komix.local';
+        return { replaceString, toReplace };
+    }
+    static swapChars(src, i, j) {
+        if (i < 0 || j < 0 || i >= src.length || j >= src.length) {
+            return src;
+        }
+        if (j < i) {
+            [i, j] = [j, i];
+        }
+        return (src.slice(0, i) + src[j] + src.slice(i + 1, j) + src[i] + src.slice(j + 1));
+    }
+    static insertAt(src, index, value) {
+        return src.slice(0, index) + value + src.slice(index);
+    }
+    static getDataTestId(label, prefix, suffix) {
+        let dataTestId = label.toLowerCase()?.replace(/ /g, '-');
+        if (prefix) {
+            dataTestId = `${prefix}__${dataTestId}`;
+        }
+        if (suffix) {
+            dataTestId = `${dataTestId}--${suffix}`;
+        }
+        return RdtStringUtils.removeAccents(dataTestId);
+    }
+    static stripQueryParams(url) {
+        const match = url.match(/#|\?|$/);
+        const pathEndIdx = (match && match.index) || url.length;
+        return url.slice(0, pathEndIdx);
+    }
+}
+
+var RdtFormatType;
+(function (RdtFormatType) {
+    RdtFormatType["Day"] = "day";
+    RdtFormatType["Month"] = "month";
+    RdtFormatType["Year"] = "year";
+    RdtFormatType["Constant"] = "constant";
+})(RdtFormatType || (RdtFormatType = {}));
+const PRIMENG_DATE_FORMAT_META = {
+    d: {
+        type: RdtFormatType.Day,
+        minLength: 1,
+        maxLength: 2,
+    },
+    dd: {
+        type: RdtFormatType.Day,
+        minLength: 2,
+        maxLength: 2,
+    },
+    m: {
+        type: RdtFormatType.Month,
+        minLength: 1,
+        maxLength: 2,
+    },
+    mm: {
+        type: RdtFormatType.Month,
+        minLength: 2,
+        maxLength: 2,
+    },
+    y: {
+        type: RdtFormatType.Year,
+        minLength: 2,
+        maxLength: 2,
+    },
+    yy: {
+        type: RdtFormatType.Year,
+        minLength: 4,
+        maxLength: 4,
+    },
+};
+var RdtInsertMode;
+(function (RdtInsertMode) {
+    RdtInsertMode[RdtInsertMode["Overwrite"] = 0] = "Overwrite";
+    RdtInsertMode[RdtInsertMode["Shift"] = 1] = "Shift";
+})(RdtInsertMode || (RdtInsertMode = {}));
+var RdtPasteMode;
+(function (RdtPasteMode) {
+    RdtPasteMode[RdtPasteMode["Replace"] = 0] = "Replace";
+    RdtPasteMode[RdtPasteMode["Insert"] = 1] = "Insert";
+})(RdtPasteMode || (RdtPasteMode = {}));
+var RdtYearInputMode;
+(function (RdtYearInputMode) {
+    RdtYearInputMode[RdtYearInputMode["FourDigit"] = 1] = "FourDigit";
+    RdtYearInputMode[RdtYearInputMode["TwoDigit"] = 2] = "TwoDigit";
+    RdtYearInputMode[RdtYearInputMode["Both"] = 3] = "Both";
+})(RdtYearInputMode || (RdtYearInputMode = {}));
+var RdtLeadingZeroInputMode;
+(function (RdtLeadingZeroInputMode) {
+    RdtLeadingZeroInputMode[RdtLeadingZeroInputMode["NoLeadingZero"] = 1] = "NoLeadingZero";
+    RdtLeadingZeroInputMode[RdtLeadingZeroInputMode["LeadingZero"] = 2] = "LeadingZero";
+    RdtLeadingZeroInputMode[RdtLeadingZeroInputMode["Both"] = 3] = "Both";
+})(RdtLeadingZeroInputMode || (RdtLeadingZeroInputMode = {}));
+function getDigitCount(value) {
+    return (Math.log10(value) + 1) | 0;
+}
+class RdtDateParser {
+    cfg;
+    _value;
+    _inputValue;
+    _parsedFormat;
+    deleting;
+    caretPosition;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this._inputValue = '';
+        this._value = null;
+        this._parsedFormat = this.parseFormat(cfg);
+        this.deleting = false;
+        this.caretPosition = 0;
+    }
+    set leadingZeroMode(mode) {
+        this.cfg.leadingZeroMode = mode;
+        this._parsedFormat = this.parseFormat(this.cfg);
+    }
+    get leadingZeroMode() {
+        return this.cfg.leadingZeroMode;
+    }
+    set yearInputMode(mode) {
+        this.cfg.yearInputMode = mode;
+        this._parsedFormat = this.parseFormat(this.cfg);
+    }
+    get yearInputMode() {
+        return this.cfg.yearInputMode;
+    }
+    set twoDigitYearInputStrategy(strategy) {
+        this.cfg.twoDigitYearInputStrategy = strategy;
+        this._parsedFormat = this.parseFormat(this.cfg);
+    }
+    get twoDigitYearInputStrategy() {
+        return this.cfg.twoDigitYearInputStrategy;
+    }
+    set insertMode(mode) {
+        this.cfg.insertMode = mode;
+        this._parsedFormat = this.parseFormat(this.cfg);
+    }
+    get insertMode() {
+        return this.cfg.insertMode;
+    }
+    set format(format) {
+        this.cfg.format = format;
+        this._parsedFormat = this.parseFormat(this.cfg);
+    }
+    get format() {
+        return this.cfg.format;
+    }
+    onKeyDown(event) {
+        if (event.key === 'Backspace') {
+            this.deleting = true;
+        }
+        const target = event.target;
+        this.caretPosition = target.selectionStart ?? target.value.length - 1;
+    }
+    onKeyUp(event) {
+        if (event.key === 'Backspace') {
+            this.deleting = false;
+        }
+    }
+    onInput(event) {
+        const target = event.target;
+        const value = target.value;
+        const caretPosition = target.selectionStart ?? value.length - 1;
+        const res = this.parse(value, caretPosition);
+        target.value = res.prettyInput;
+        RdtHTMLUtils.setCaretPosition(target, res.caret);
+        this._value = res.date;
+        this._inputValue = res.prettyInput;
+        this.caretPosition = res.caret;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(d) {
+        if (!(d instanceof Date)) {
+            this._value = null;
+            this._inputValue = '';
+            return;
+        }
+        let result = '';
+        this._parsedFormat.forEach((node) => {
+            switch (node.type) {
+                case RdtFormatType.Constant:
+                    result += node.value;
+                    break;
+                case RdtFormatType.Day:
+                    result += `${d.getDate()}`.padStart(node.minLength, '0');
+                    break;
+                case RdtFormatType.Month:
+                    result += `${d.getMonth() + 1}`.padStart(node.minLength, '0');
+                    break;
+                case RdtFormatType.Year:
+                    result += `${d.getFullYear() % 10 ** node.maxLength}`.padStart(node.minLength, '0');
+                    break;
+            }
+        });
+        this._value = d;
+        this._inputValue = result;
+    }
+    set inputValue(value) {
+        this._inputValue = value;
+    }
+    get inputValue() {
+        return this._inputValue;
+    }
+    parse(input, caretPosition = this.caretPosition, deleting = this.deleting) {
+        let rest = input;
+        let day = null, month = null, year = null;
+        let output = '';
+        let targetCaret = caretPosition;
+        let allComplete = true;
+        let ambiguous = false;
+        for (let i = 0; i < this._parsedFormat.length; i++) {
+            if (rest.length === 0) {
+                break;
+            }
+            const node = this._parsedFormat[i];
+            const firstNumber = rest.search(/\d/);
+            if (node.type === RdtFormatType.Constant) {
+                if (firstNumber > 0) {
+                    const value = deleting
+                        ? rest.substring(0, node.value.length)
+                        : rest.substring(0, firstNumber);
+                    // In case we are deleting from separator, delete previous number as well
+                    if (deleting && value !== node.value) {
+                        if (rest.length === input.length) {
+                            continue;
+                        }
+                        else {
+                            targetCaret -= node.value.length - value.length;
+                        }
+                    }
+                    rest = rest.substring(firstNumber);
+                }
+                output += node.value;
+            }
+            else {
+                if (firstNumber < 0) {
+                    break;
+                }
+                if (targetCaret > output.length) {
+                    allComplete = true;
+                }
+                if (node.type === RdtFormatType.Year) {
+                    if (this.cfg.yearInputMode & RdtYearInputMode.FourDigit &&
+                        (rest.match(/^\d{3,4}/) ||
+                            (rest.match(/^\d{2}$/) && i !== this._parsedFormat.length - 1))) {
+                        if (!deleting &&
+                            this.cfg.insertMode === RdtInsertMode.Overwrite &&
+                            rest.match(/^\d{5}/) &&
+                            caretPosition < rest.length &&
+                            caretPosition - output.length <= 5 &&
+                            RdtStringUtils.isNumericCharacter(rest[caretPosition])) {
+                            rest =
+                                rest.substring(0, caretPosition) +
+                                    rest.substring(caretPosition + 1);
+                        }
+                        if (rest.match(/^\d{4}/)) {
+                            const strVal = rest.substring(0, 4);
+                            year = parseInt(strVal);
+                            rest = rest.substring(4);
+                            output += strVal;
+                            if (!deleting) {
+                                ({ rest, targetCaret } = this.useUpNumbersUntilNextSeparator(rest, targetCaret, true, deleting));
+                            }
+                        }
+                        else if (rest.match(/^\d{3}/)) {
+                            output += rest.substring(0, 3);
+                            rest = rest.substring(3);
+                            if (output.length <= targetCaret) {
+                                allComplete = false;
+                            }
+                        }
+                        else {
+                            output = rest.substring(0, 2);
+                            rest = rest.substring(2);
+                            if (output.length <= targetCaret) {
+                                allComplete = false;
+                            }
+                        }
+                    }
+                    else if (this.cfg.yearInputMode & RdtYearInputMode.TwoDigit &&
+                        rest.match(/^\d{2}/) &&
+                        (this.containsNonNumericCharacters(rest.substring(2)) ||
+                            i === this._parsedFormat.length - 1)) {
+                        const strVal = rest.substring(0, 2);
+                        const y2 = parseInt(strVal);
+                        if (this.cfg.twoDigitYearInputStrategy === 'past') {
+                            year = RdtDateUtils.doubleDigitYearToPast(y2);
+                        }
+                        else {
+                            year = RdtDateUtils.doubleDigitYearToFuture(y2);
+                        }
+                        rest = rest.substring(2);
+                        if (!deleting) {
+                            ({ rest, targetCaret } = this.useUpNumbersUntilNextSeparator(rest, targetCaret, true, deleting));
+                        }
+                        output += strVal;
+                        if (this.cfg.yearInputMode & RdtYearInputMode.FourDigit &&
+                            i === this._parsedFormat.length - 1) {
+                            ambiguous = true;
+                        }
+                    }
+                    else if (rest.match(/^\d/)) {
+                        output += rest[0];
+                        rest = rest.substring(1);
+                        if (output.length <= targetCaret) {
+                            allComplete = false;
+                        }
+                    }
+                }
+                else if (node.type === RdtFormatType.Month) {
+                    const val = this.readNumber(1, 12, output, rest, targetCaret, deleting);
+                    output = val.output;
+                    rest = val.rest;
+                    targetCaret = val.targetCaret;
+                    if (val.value !== null) {
+                        month = val.value;
+                        // Add separator in case it's complete
+                        if (val.complete && !deleting) {
+                            ({ rest, targetCaret } = this.useUpNumbersUntilNextSeparator(rest, targetCaret, true, deleting));
+                        }
+                        if (!val.complete && output.length <= targetCaret) {
+                            allComplete = false;
+                        }
+                    }
+                }
+                else if (node.type === RdtFormatType.Day) {
+                    const val = this.readNumber(1, 31, output, rest, targetCaret, deleting);
+                    output = val.output;
+                    rest = val.rest;
+                    targetCaret = val.targetCaret;
+                    if (val.value !== null) {
+                        day = val.value;
+                        // Add separator in case it's complete
+                        if (val.complete && !deleting) {
+                            ({ rest, targetCaret } = this.useUpNumbersUntilNextSeparator(rest, targetCaret, true, deleting));
+                        }
+                        if (!val.complete && output.length <= targetCaret) {
+                            allComplete = false;
+                        }
+                    }
+                }
+            }
+        }
+        let date = null;
+        if (year !== null && month !== null && day !== null) {
+            date = new Date(year, month - 1, day);
+            if (date.getMonth() !== month - 1) {
+                date = null;
+            }
+        }
+        targetCaret = Math.min(targetCaret, output.length + 1);
+        if (!deleting) {
+            if (caretPosition === input.length) {
+                targetCaret = output.length;
+            }
+            else if (allComplete) {
+                while (targetCaret > 0 &&
+                    output.length > targetCaret &&
+                    !RdtStringUtils.isNumericCharacter(output[targetCaret])) {
+                    targetCaret++;
+                }
+            }
+        }
+        else if (!date) {
+            output = input;
+            targetCaret = caretPosition;
+        }
+        return {
+            prettyInput: output,
+            date: date,
+            complete: date !== null,
+            caret: targetCaret,
+            ambiguous: ambiguous || date === null,
+        };
+    }
+    readNumber(min, max, output, rest, targetCaret, deleting) {
+        const maxDigits = getDigitCount(max);
+        let value = null;
+        let strVal = '';
+        let complete = false;
+        if (!(this.cfg.leadingZeroMode & RdtLeadingZeroInputMode.NoLeadingZero)) {
+            const regex = new RegExp(`^\\d{${maxDigits}}`);
+            if (rest.match(regex)) {
+                strVal = rest.substring(0, maxDigits);
+                output += strVal;
+                rest = rest.substring(maxDigits);
+                value = parseInt(strVal);
+            }
+        }
+        else {
+            let digits = rest.match(/^\d+/)?.[0] ?? '';
+            if (digits.length > 0) {
+                digits = digits.slice(0, maxDigits);
+                value = parseInt(digits);
+                if (value < min) {
+                    value = null;
+                    let nines = '9';
+                    while (digits.length + 1 > maxDigits ||
+                        parseInt(digits + nines) < min) {
+                        digits = digits.slice(0, -1);
+                        nines += '9';
+                    }
+                }
+                else {
+                    while (value > max && digits.length > 0) {
+                        digits = digits.slice(0, -1);
+                        value = parseInt(digits);
+                    }
+                    if (digits.length === 0) {
+                        value = null;
+                    }
+                }
+                if (digits[0] === '0' &&
+                    min !== 0 &&
+                    !(this.cfg.leadingZeroMode & RdtLeadingZeroInputMode.LeadingZero)) {
+                    value = null;
+                    digits = '';
+                }
+            }
+            output += digits;
+            rest = rest.substring(digits.length);
+            strVal = digits;
+        }
+        if (value !== null && value >= min && value <= max) {
+            complete = strVal.length === maxDigits || value * 10 > max;
+            ({ rest, targetCaret } = this.useUpNumbersUntilNextSeparator(rest, targetCaret, complete && !deleting, deleting));
+            return { value, complete, output, rest, targetCaret };
+        }
+        else {
+            return { value: null, complete: false, output, rest, targetCaret };
+        }
+    }
+    parseFormat(cfg) {
+        const keys = Object.keys(cfg.symbolMeta);
+        keys.sort((a, b) => b.length - a.length);
+        let rest = cfg.format;
+        const result = [];
+        while (rest.length > 0) {
+            const indices = keys.map((key) => rest.indexOf(key));
+            const minI = indices.indexOf(Math.min(...indices.filter((i) => i >= 0)));
+            const minIndex = indices[minI];
+            const minKey = keys[minI];
+            if (minIndex > 0) {
+                result.push({
+                    type: RdtFormatType.Constant,
+                    value: rest.substring(0, minIndex),
+                });
+                rest = rest.substring(minIndex);
+            }
+            else if (minIndex < 0) {
+                result.push({
+                    type: RdtFormatType.Constant,
+                    value: rest,
+                });
+                rest = '';
+            }
+            else {
+                result.push(cfg.symbolMeta[minKey]);
+                rest = rest.substring(minIndex + minKey.length);
+            }
+        }
+        return result;
+    }
+    useUpNumbersUntilNextSeparator(input, targetCaret, insertSeparator, deleting) {
+        let i = 0;
+        while (i < input.length && RdtStringUtils.isNumericCharacter(input[i])) {
+            i++;
+        }
+        if (i !== input.length) {
+            return {
+                rest: input.substring(i),
+                targetCaret: targetCaret - (deleting ? i : 0),
+            };
+        }
+        else if (insertSeparator) {
+            return { rest: ' ' + input, targetCaret: targetCaret };
+        }
+        else {
+            return { rest: input, targetCaret };
+        }
+    }
+    containsNonNumericCharacters(input) {
+        return input.search(/\D/) >= 0;
+    }
+}
+
+class RdtDomUtils {
+    static getResizeEvent$(element) {
+        return new Observable((observer) => {
+            const resizeObserver = new ResizeObserver((entries) => {
+                observer.next(entries);
+            });
+            resizeObserver.observe(element);
+            return () => {
+                resizeObserver.unobserve(element);
+                resizeObserver.disconnect();
+            };
+        });
+    }
+}
+
+var RdtMsOfficeAction;
+(function (RdtMsOfficeAction) {
+    RdtMsOfficeAction["Edit"] = "ofe|u|";
+    RdtMsOfficeAction["View"] = "ofv|u|";
+})(RdtMsOfficeAction || (RdtMsOfficeAction = {}));
+var RdtMsOfficeApp;
+(function (RdtMsOfficeApp) {
+    RdtMsOfficeApp["Word"] = "ms-word";
+    RdtMsOfficeApp["Excel"] = "ms-excel";
+    RdtMsOfficeApp["PowerPoint"] = "ms-powerpoint";
+})(RdtMsOfficeApp || (RdtMsOfficeApp = {}));
+const RDT_DEFAULT_MIME_TYPE = RdtMimeType.UNKNOWN;
+const RDT_DEFAULT_MS_OFFICE_ACTION = RdtMsOfficeAction.View;
+var RdtFileSizeUnit;
+(function (RdtFileSizeUnit) {
+    RdtFileSizeUnit["B"] = "B";
+    RdtFileSizeUnit["KB"] = "KB";
+    RdtFileSizeUnit["MB"] = "MB";
+    RdtFileSizeUnit["GB"] = "GB";
+    RdtFileSizeUnit["TB"] = "TB";
+    RdtFileSizeUnit["PB"] = "PB";
+    RdtFileSizeUnit["EB"] = "EB";
+    RdtFileSizeUnit["ZB"] = "ZB";
+    RdtFileSizeUnit["YB"] = "YB";
+})(RdtFileSizeUnit || (RdtFileSizeUnit = {}));
+const SORTED_FILE_SIZE_UNITS = [
+    RdtFileSizeUnit.B,
+    RdtFileSizeUnit.KB,
+    RdtFileSizeUnit.MB,
+    RdtFileSizeUnit.GB,
+    RdtFileSizeUnit.TB,
+    RdtFileSizeUnit.PB,
+    RdtFileSizeUnit.EB,
+    RdtFileSizeUnit.ZB,
+    RdtFileSizeUnit.YB,
+];
+class RdtFileUtils {
+    static getMsOfficeLink(url, config) {
+        const app = config.app ?? RdtFileUtils.getMsOfficeAppByMimeType(config.mimeType);
+        if (app) {
+            const action = config.action ?? RDT_DEFAULT_MS_OFFICE_ACTION;
+            return `${app}:${action}${url}`;
+        }
+        else {
+            return url;
+        }
+    }
+    static openFileFromRemoteUrl(url, config) {
+        window.open(RdtFileUtils.getMsOfficeLink(url, config));
+    }
+    static openFileInBrowser(stringData, mimeType) {
+        const link = RdtFileUtils.getBase64Link(stringData, mimeType);
+        window.open(link, '_blank');
+    }
+    static fileAsArrayBuffer(file) {
+        return new Promise((resolve, reject) => {
+            if (!file) {
+                reject(null);
+            }
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsArrayBuffer(file);
+        });
+    }
+    static fileAsText(file, encoding) {
+        return new Promise((resolve, reject) => {
+            if (!file) {
+                reject(null);
+            }
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsText(file, encoding);
+        });
+    }
+    static downloadFileFromData(stringData, filename, mimeType) {
+        mimeType =
+            mimeType ??
+                RdtFileUtils.getMimeTypeFromFileName(filename) ??
+                RdtFileUtils.getMimeTypeFromBase64(stringData);
+        const url = RdtFileUtils.getBase64Link(stringData, mimeType);
+        this.downloadFileFromRemoteUrl(url, filename, mimeType);
+    }
+    static downloadFileFromRemoteUrl(url, filename, mimeType) {
+        mimeType = mimeType ?? RdtFileUtils.getMimeTypeFromFileName(filename);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = RdtFileUtils.getFileName(filename, mimeType);
+        link.click();
+    }
+    static getMimeTypeFromBase64(base64Data) {
+        return base64Data.match(/data:(.*?);base64/)?.[1];
+    }
+    static getMimeTypeFromFileName(fileName) {
+        const ext = fileName?.split('.').pop();
+        // @ts-ignore
+        return MIME_TYPE_BY_EXTENSION[ext];
+    }
+    static getFileName(filename, mimeType) {
+        if (mimeType && mimeType !== RdtMimeType.UNKNOWN) {
+            const ext = EXTENSION_BY_MIME_TYPE[mimeType];
+            if (filename.endsWith(`.${ext}`)) {
+                return filename;
+            }
+            else {
+                return `${filename}.${ext}`;
+            }
+        }
+        else {
+            return filename;
+        }
+    }
+    static getBase64Link(base64Data, mimeType) {
+        if (base64Data.startsWith('data:')) {
+            return base64Data;
+        }
+        else if (mimeType) {
+            if (mimeType === RdtMimeType.UNKNOWN) {
+                return `data:${RdtMimeType.BIN};base64,${base64Data}`;
+            }
+            else {
+                return `data:${mimeType};base64,${base64Data}`;
+            }
+        }
+        else {
+            console.error('Missing mime type for base64 data.');
+            return '';
+        }
+    }
+    static getMimeTypeFromResponse(resp) {
+        return resp.body?.type;
+    }
+    static getFileNameFromResponse(resp) {
+        return (resp.headers
+            .get('content-disposition')
+            ?.split('filename=')?.[1]
+            ?.split(';')?.[0] ?? '');
+    }
+    static async blobToDataUrl(file) {
+        return new Promise((resolve, reject) => {
+            if (!file) {
+                reject(null);
+            }
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(file);
+        });
+    }
+    static convertFromBytes(bytes, decimals = 2) {
+        if (bytes === 0) {
+            return '0 ' + RdtFileSizeUnit.B;
+        }
+        const k = 1024;
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return (parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) +
+            ' ' +
+            SORTED_FILE_SIZE_UNITS[i]);
+    }
+    static convertToBytes(amount, unit) {
+        const k = 1024;
+        const i = SORTED_FILE_SIZE_UNITS.indexOf(unit);
+        return amount * Math.pow(k, i);
+    }
+    static fileSizeToBytes(fileSize) {
+        const [amountStr, unitStr] = fileSize.split(' ');
+        const amount = parseFloat(amountStr);
+        const unit = unitStr;
+        if (isNaN(amount) || SORTED_FILE_SIZE_UNITS.indexOf(unit) === -1) {
+            return null;
+        }
+        return RdtFileUtils.convertToBytes(amount, unit);
+    }
+    static getMsOfficeAppByMimeType(mimeType) {
+        switch (mimeType) {
+            case RdtMimeType.DOC:
+            case RdtMimeType.DOCX:
+            case RdtMimeType.ODT:
+                return RdtMsOfficeApp.Word;
+            case RdtMimeType.XLS:
+            case RdtMimeType.XLSX:
+            case RdtMimeType.ODS:
+                return RdtMsOfficeApp.Excel;
+            case RdtMimeType.PPT:
+            case RdtMimeType.PPTX:
+            case RdtMimeType.ODP:
+                return RdtMsOfficeApp.PowerPoint;
+            default:
+                return null;
+        }
+    }
+}
+
+/**
+ * From @nx/devkit because it has nodejs as dependency and won't transpile.
+ * Util function to generate different strings based off the provided name.
+ *
+ * Examples:
+ *
+ * ```typescript
+ * names("my-name") // {name: 'my-name', className: 'MyName', propertyName: 'myName', constantName: 'MY_NAME', fileName: 'my-name'}
+ * names("myName") // {name: 'myName', className: 'MyName', propertyName: 'myName', constantName: 'MY_NAME', fileName: 'my-name'}
+ * ```
+ * @param name
+ */
+function names(name) {
+    return {
+        name,
+        className: toClassName(name),
+        propertyName: toPropertyName(name),
+        constantName: toConstantName(name),
+        fileName: toFileName(name),
+    };
+}
+/**
+ * Hyphenated to UpperCamelCase
+ */
+function toClassName(str) {
+    return toCapitalCase(toPropertyName(str));
+}
+/**
+ * Hyphenated to lowerCamelCase
+ */
+function toPropertyName(s) {
+    return s
+        .replace(/([^a-zA-Z0-9])+(.)?/g, (_, __, chr) => chr ? chr.toUpperCase() : '')
+        .replace(/[^a-zA-Z\d]/g, '')
+        .replace(/^([A-Z])/, m => m.toLowerCase());
+}
+/**
+ * Hyphenated to CONSTANT_CASE
+ */
+function toConstantName(s) {
+    const normalizedS = s.toUpperCase() === s ? s.toLowerCase() : s;
+    return toFileName(toPropertyName(normalizedS))
+        .replace(/([^a-zA-Z0-9])/g, '_')
+        .toUpperCase();
+}
+/**
+ * Upper camelCase to lowercase, hyphenated
+ */
+function toFileName(s) {
+    return s
+        .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+        .toLowerCase()
+        .replace(/(?!^_)[ _]/g, '-');
+}
+/**
+ * Capitalizes the first letter of a string
+ */
+function toCapitalCase(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+const BOOLEAN_KEYWORDS = ['je', 'lze'];
+const ID_KEYWORD = 'id';
+class RdtModelUtils {
+    static inferPropertyInfo(properties, interfaceName) {
+        // Lowercase words that interface name consists of
+        const words = names(interfaceName).fileName.split('-');
+        const wordMap = {};
+        words.forEach((w) => (wordMap[w] = 1));
+        let maxMatches = 0;
+        // Primary key is property that shares the most words with interface name
+        // while containing the word 'id'.
+        // If more such properties exist, the one with shortest name is selected.
+        let primaryKey = '';
+        properties.forEach(({ key }) => {
+            const propertyNameWords = names(key).fileName.split('-');
+            let matches = 0;
+            propertyNameWords.forEach((w) => (matches += wordMap[w] ?? 0));
+            const isId = propertyNameWords.includes(ID_KEYWORD);
+            if (matches > maxMatches && isId) {
+                maxMatches = matches;
+                primaryKey = key;
+            }
+            else if (matches === maxMatches && isId) {
+                if (key.length < primaryKey.length) {
+                    primaryKey = key;
+                }
+            }
+        });
+        const res = properties.map((pair) => {
+            const propertyNameWords = names(pair.key).fileName.split('-');
+            const isId = propertyNameWords.includes(ID_KEYWORD);
+            return {
+                key: pair.key,
+                type: pair.type,
+                required: true,
+                formControlType: pair.type === 'date' ? 'string' : pair.type,
+                primaryKey: pair.key === primaryKey,
+                // Any other property that contains ID, but is not primary key is foreign key.
+                // Foreign keys are to be ignored.
+                foreignKey: isId && pair.key !== primaryKey,
+                // If the property starts with the word 'je' and it's numeric,
+                // then it's probably boolean.
+                probablyBoolean: BOOLEAN_KEYWORDS.includes(propertyNameWords[0]) &&
+                    pair.type === 'number',
+            };
+        });
+        return res;
+    }
+    static names(name) {
+        return names(name);
+    }
+}
+
+class RdtObjectUtils {
+    static pluck(obj, path) {
+        if (!obj) {
+            return undefined;
+        }
+        const parts = Array.isArray(path) ? path : path.split('.');
+        let current = obj;
+        for (const key of parts) {
+            if (current == undefined) {
+                return undefined;
+            }
+            if (Array.isArray(current) && typeof key === 'string') {
+                current = current[parseInt(key)];
+            }
+            else {
+                current = current[key];
+            }
+        }
+        return current;
+    }
+    static notNullGuard(value) {
+        return value != null;
+    }
+    static expandKey(key, value) {
+        const parts = key.split('.');
+        if (parts.length === 0) {
+            return value;
+        }
+        const first = getObjectFromKey(parts[0]);
+        let current = first;
+        for (let i = 1; i < parts.length; i++) {
+            const next = getObjectFromKey(parts[i]);
+            current.obj[current.key] = next.obj;
+            current = next;
+        }
+        current.obj[current.key] = value;
+        return first.obj;
+    }
+    static someValuesTrue(obj) {
+        const keys = Object.getOwnPropertySymbols(obj);
+        return keys.some((key) => obj[key]);
+    }
+}
+function getObjectFromKey(key) {
+    const int = parseInt(key);
+    if (isNaN(int)) {
+        return {
+            obj: {},
+            key: key,
+        };
+    }
+    else {
+        return {
+            obj: [],
+            key: int,
+        };
+    }
+}
+
+class RdtRandomUtils {
+    static randomId() {
+        return Math.random().toString(36).substring(2);
+    }
+    static trueFalse() {
+        return Math.random() < 0.5;
+    }
+}
+
+class RdtRxUtils {
+    // Will repeat last value when notifier$ emits anything.
+    static repeatLatestWhen(notifier$) {
+        return (source) => {
+            return combineLatest([source, notifier$.pipe(startWith(null))]).pipe(map(([val]) => val));
+        };
+    }
+    static completeIfNull(source$) {
+        return source$.pipe(switchMap((value) => (value == null ? EMPTY : of(value))));
+    }
+    static makeObservable(value) {
+        return value instanceof Observable ? value : of(value);
+    }
+}
+
+function signalToPromise(source, options) {
+    if (ngDevMode && !options?.injector) {
+        assertInInjectionContext(signalToPromise);
+    }
+    const injector = options?.injector ?? inject(Injector);
+    return new Promise((resolve, reject) => {
+        const watcher = effect(() => {
+            let value;
+            try {
+                value = source();
+            }
+            catch (err) {
+                untracked(() => reject(err));
+                return;
+            }
+            untracked(() => resolve(value));
+        }, { injector, manualCleanup: true });
+        injector.get(DestroyRef).onDestroy(() => {
+            watcher.destroy();
+        });
+    });
+}
+function signalToPromiseOnce(source, options) {
+    const injector = options?.injector ?? inject(Injector);
+    return new Promise((resolve, reject) => {
+        let watcher = null;
+        watcher = effect(() => {
+            let value;
+            try {
+                value = source();
+            }
+            catch (err) {
+                untracked(() => reject(err));
+                watcher?.destroy();
+                watcher = null;
+                return;
+            }
+            untracked(() => {
+                resolve(value);
+                watcher?.destroy();
+                watcher = null;
+            });
+        }, { injector, manualCleanup: true });
+        const destroyRef = injector.get(DestroyRef, null);
+        destroyRef?.onDestroy(() => {
+            watcher?.destroy();
+            watcher = null;
+        });
+    });
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./index"), exports);
+
+export { ALPHABET_KB_KEYS, ARROW, EXTENSION_BY_MIME_TYPE, KB_ALPHABET_CODES, KB_CODE, KB_KEY, MIME_TYPE_BY_EXTENSION, Month, PRIMENG_DATE_FORMAT_META, RDT_DEFAULT_MIME_TYPE, RDT_DEFAULT_MS_OFFICE_ACTION, RdtArrayUtils, RdtCombinedMimeType, RdtCssUtils, RdtDateParser, RdtDateUtils, RdtDomUtils, RdtEncoding, RdtFileSizeUnit, RdtFileUtils, RdtHTMLUtils, RdtInsertMode, RdtLeadingZeroInputMode, RdtMimeType, RdtModelUtils, RdtMsOfficeAction, RdtMsOfficeApp, RdtObjectUtils, RdtPasteMode, RdtRandomUtils, RdtRxUtils, RdtStringUtils, RdtYearInputMode, signalToPromise, signalToPromiseOnce };
 //# sourceMappingURL=ngrdt-utils.mjs.map