expensify-common 2.0.188 → 2.0.190

package/dist/esm/str.js

@@ -0,0 +1,1036 @@
+'worklet';
+/* eslint-disable no-control-regex */
+import $ from 'jquery';
+import { parsePhoneNumber } from 'awesome-phonenumber';
+import Punycode from 'punycode/';
+import * as HtmlEntities from 'html-entities';
+import * as Constants from './CONST';
+import * as UrlPatterns from './Url';
+import * as Utils from './utils';
+import Log from './Log';
+const REMOVE_SMS_DOMAIN_PATTERN = /@expensify\.sms/gi;
+function resultFn(parameter, ...args) {
+    if (typeof parameter === 'function') {
+        return parameter(...args);
+    }
+    return parameter;
+}
+const Str = {
+    /**
+     * Return true if the string is ending with the provided suffix
+     *
+     * @param str String ot search in
+     * @param suffix What to look for
+     */
+    endsWith(str, suffix) {
+        if (!str || !suffix) {
+            return false;
+        }
+        return str.substr(-suffix.length) === suffix;
+    },
+    /**
+     * Converts a USD string into th number of cents it represents.
+     *
+     * @param amountStr A string representing a USD value.
+     * @param allowFraction Flag indicating if fractions of cents should be
+     *                               allowed in the output.
+     *
+     * @returns The cent value of the @p amountStr.
+     */
+    fromUSDToNumber(amountStr, allowFraction) {
+        let amount = String(amountStr).replaceAll(/[^\d.\-()]+/g, '');
+        if (amount.match(/\(.*\)/)) {
+            const modifiedAmount = amount.replaceAll(/[()]/g, '');
+            amount = `-${modifiedAmount}`;
+        }
+        amount = Number(amount) * 100;
+        amount = Math.round(amount * 1e3) / 1e3;
+        return allowFraction ? amount : Math.round(amount);
+    },
+    /**
+     * Truncates the middle section of a string based on the max allowed length
+     */
+    truncateInMiddle(fullStr, maxLength) {
+        if (fullStr.length <= maxLength) {
+            return fullStr;
+        }
+        const separator = '...';
+        const halfLengthToShow = (maxLength - separator.length) / 2;
+        const beginning = fullStr.substr(0, Math.ceil(halfLengthToShow));
+        const end = fullStr.substr(fullStr.length - Math.floor(halfLengthToShow));
+        return beginning + separator + end;
+    },
+    /**
+     * Convert new line to <br />
+     */
+    nl2br(str) {
+        return str.replaceAll('\n', '<br />');
+    },
+    /**
+     * Decodes the given HTML encoded string.
+     *
+     * @param s The string to decode.
+     * @returns The decoded string.
+     */
+    htmlDecode(s) {
+        return HtmlEntities.decode(s);
+    },
+    /**
+     * HTML encodes the given string.
+     *
+     * @param s The string to encode.
+     * @return string @p s HTML encoded.
+     */
+    htmlEncode(s) {
+        return HtmlEntities.encode(s);
+    },
+    /**
+     * Decodes the given HTML encoded string.
+     *
+     * @param s The string to decode.
+     * @returns The decoded string.
+     */
+    htmlDecodeWithJQueryOrNative(s) {
+        // Use jQuery if it exists or else use html-entities
+        if (typeof $ !== 'undefined') {
+            return $('<textarea/>').html(s).text();
+        }
+        return HtmlEntities.decode(s);
+    },
+    /**
+     * HTML encodes the given string.
+     *
+     * @param s The string to encode.
+     * @return string @p s HTML encoded.
+     */
+    htmlEncodeWithJQueryOrNative(s) {
+        // Use jQuery if it exists or else use html-entities
+        if (typeof $ !== 'undefined') {
+            return $('<textarea/>').text(s).html();
+        }
+        return HtmlEntities.encode(s);
+    },
+    /**
+     * Escape text while preventing any sort of double escape, so 'X & Y' -> 'X &amp; Y' and 'X &amp; Y' -> 'X &amp; Y'
+     *
+     * @param s The string to escape
+     * @returns The escaped string
+     */
+    safeEscape(s) {
+        return Utils.escapeText(Utils.unescapeText(s));
+    },
+    /**
+     * HTML encoding insensitive equals.
+     *
+     * @param first string to compare
+     * @param second string to compare
+     * @returns True when first === second, ignoring HTML encoding
+     */
+    htmlEncodingInsensitiveEquals(first, second) {
+        return first === second || this.htmlDecode(first) === second || this.htmlEncode(first) === second;
+    },
+    /**
+     * Creates an ID that can be used as an HTML attribute from @p str.
+     *
+     * @param str A string to create an ID from.
+     * @returns The ID string made from @p str.
+     */
+    makeID(str) {
+        const modifiedString = String(str)
+            .replaceAll(/[^A-Za-z0-9]/g, '_')
+            .toUpperCase();
+        return `id_${modifiedString}`;
+    },
+    /**
+     * Extracts an ID made with Str.makeID from a larger string.
+     *
+     * @param str A string containing an id made with Str.makeID
+     * @returns The ID string.
+     */
+    extractID(str) {
+        const matches = str.match(/id[A-Z0-9_]+/);
+        return matches && matches.length > 0 ? matches[0] : null;
+    },
+    /**
+     * Modifies the string so the first letter of each word is capitalized and the
+     * rest lowercased.
+     *
+     * @param val The string to modify
+     */
+    recapitalize(val) {
+        // First replace every letter with its lowercase equivalent
+        // Cast to string.
+        let str = String(val);
+        if (str.length <= 0) {
+            return str;
+        }
+        str = str.substr(0, 1).toUpperCase() + str.substr(1).toLowerCase();
+        function recap_callback(t, a, b) {
+            return a + b.toUpperCase();
+        }
+        return str.replaceAll(
+        // **NOTE: Match to _libfop.php
+        /([^A-Za-z'.0-9])([a-z])/g, recap_callback);
+    },
+    /**
+     * Replace all the non alphanumerical character by _
+     */
+    sanitizeToAlphaNumeric(input) {
+        return String(input).replaceAll(/[^\d\w]/g, '_');
+    },
+    /**
+     * Strip out all the non numerical characters
+     */
+    stripNonNumeric(input) {
+        return String(input).replaceAll(/[^\d]/g, '');
+    },
+    /**
+     * Strips all non ascii characters from a string
+     * @returns The ascii version of the string.
+     */
+    stripNonASCIICharacters(input) {
+        return String(input).replaceAll(/[\u0000-\u0019\u0080-\uffff]/g, '');
+    },
+    /**
+     * Shortens the @p text to @p length and appends an ellipses to it.
+     *
+     * The ellipses will only be appended if @p text is longer than the @p length
+     * given.
+     *
+     * @param val The string to reduce in size.
+     * @param length The maximal length desired.
+     * @returns The shortened @p text.
+     */
+    shortenText(val, length) {
+        // Remove extra spaces because they don't show up in html anyway.
+        const text = String(val).replaceAll(/\s+/g, ' ');
+        const truncatedText = text.substr(0, length - 3);
+        return text.length > length ? `${truncatedText}...` : text;
+    },
+    /**
+     * Returns the byte size of a character
+     * @param inputChar You can input more than one character, but it will only return the size of the first
+     * one.
+     * @returns Byte size of the character
+     */
+    getRawByteSize(inputChar) {
+        const onlyChar = String(inputChar);
+        const c = onlyChar.charCodeAt(0);
+        // If we are grabbing the byte size, we need to temporarily diable no-bitwise for linting
+        /* eslint-disable no-bitwise */
+        if (c < 1 << 7) {
+            return 1;
+        }
+        if (c < 1 << 11) {
+            return 2;
+        }
+        if (c < 1 << 16) {
+            return 3;
+        }
+        if (c < 1 << 21) {
+            return 4;
+        }
+        if (c < 1 << 26) {
+            return 5;
+        }
+        if (c < 1 << 31) {
+            return 6;
+        }
+        /* eslint-enable no-bitwise */
+        return Number.NaN;
+    },
+    /**
+     * Gets the length of a string in bytes, including non-ASCII characters
+     * @returns The number of bytes used by string
+     */
+    getByteLength(input) {
+        // Force string type
+        const stringInput = String(input);
+        const byteLength = Array.from(stringInput).reduce((acc, char) => acc + this.getRawByteSize(char), 0);
+        return byteLength;
+    },
+    /**
+     * Shortens the input by max byte size instead of by character length
+     * @param maxSize The max size in bytes, e.g. 256
+     * @returns Returns a shorted input if the input size exceeds the max
+     */
+    shortenByByte(input, maxSize) {
+        const stringInput = String(input);
+        let totalByteLength = 0;
+        for (let i = 0; i < stringInput.length; i++) {
+            const charByteSize = this.getRawByteSize(stringInput[i]);
+            if (charByteSize + totalByteLength > maxSize) {
+                // If the next character exceeds the limit, stop and return the truncated string.
+                return `${stringInput.substr(0, i - 3)}...`;
+            }
+            totalByteLength += charByteSize;
+        }
+        return stringInput;
+    },
+    /**
+     * Returns true if the haystack begins with the needle
+     *
+     * @param haystack The full string to be searched
+     * @param needle  The case-sensitive string to search for
+     * @returns True if the haystack starts with the needle.
+     */
+    startsWith(haystack, needle) {
+        return this.isString(haystack) && this.isString(needle) && haystack.substring(0, needle.length) === needle;
+    },
+    /**
+     * Gets the textual value of the given string.
+     *
+     * @param str The string to fetch the text value from.
+     * @returns The text from within the HTML string.
+     */
+    stripHTML(str) {
+        if (!this.isString(str)) {
+            return '';
+        }
+        return str.replaceAll(/<[^>]*>?/gm, '');
+    },
+    /**
+     * Modifies the string so the first letter of the string is capitalized
+     *
+     * @param str The string to modify.
+     * @returns The recapitalized string.
+     */
+    UCFirst(str) {
+        return str.substr(0, 1).toUpperCase() + str.substr(1);
+    },
+    /**
+     * Returns a string containing all the characters str from the beginning
+     * of str to the first occurrence of substr.
+     * Example: Str.cutAfter( 'hello$%world', '$%' ) // returns 'hello'
+     *
+     * @param str The string to modify.
+     * @param substr The substring to search for.
+     * @returns The cut/trimmed string.
+     */
+    cutAfter(str, substr) {
+        const index = str.indexOf(substr);
+        if (index !== -1) {
+            return str.substring(0, index);
+        }
+        return str;
+    },
+    /**
+     * Returns a string containing all the characters str from after the first
+     * occurrence of substr to the end of the string.
+     * Example: Str.cutBefore( 'hello$%world', '$%' ) // returns 'world'
+     *
+     * @param str The string to modify.
+     * @param substr The substring to search for.
+     * @returns The cut/trimmed string.
+     */
+    cutBefore(str, substr) {
+        const index = str.indexOf(substr);
+        if (index !== -1) {
+            return str.substring(index + substr.length);
+        }
+        return str;
+    },
+    /**
+     * Checks that the string is a domain name (e.g. example.com)
+     *
+     * @param str The string to check for domainnameness.
+     *
+     * @returns True if the string is a domain name
+     */
+    isValidDomainName(str) {
+        return !!String(str).match(Constants.CONST.REG_EXP.DOMAIN);
+    },
+    /**
+     * Checks that the string is a valid url
+     *
+     * @returns True if the string is a valid hyperlink
+     */
+    isValidURL(str) {
+        return !!String(str).match(Constants.CONST.REG_EXP.HYPERLINK);
+    },
+    /**
+     * Checks that the string is an email address.
+     * NOTE: TLDs are not just 2-4 characters. Keep this in sync with _inputrules.php
+     *
+     * @param str The string to check for email validity.
+     *
+     * @returns True if the string is an email
+     */
+    isValidEmail(str) {
+        if (!str || typeof str !== 'string') {
+            return false;
+        }
+        const unicodeVersion = Punycode.toUnicode(str);
+        if (String(unicodeVersion).match(Constants.CONST.REG_EXP.EMOJI_RULE)) {
+            return false;
+        }
+        return !!String(str).match(Constants.CONST.REG_EXP.EMAIL);
+    },
+    /**
+     * Checks if the string is an valid email address formed during comment markdown formation.
+     *
+     * @param str The string to check for email validity.
+     *
+     * @returns True if the string is an valid email created by comment markdown.
+     */
+    isValidEmailMarkdown(str) {
+        return !!String(str).match(`^${Constants.CONST.REG_EXP.MARKDOWN_EMAIL}$`);
+    },
+    /**
+     * Remove trailing comma from a string.
+     *
+     * @param str The string with any trailing comma to be removed.
+     *
+     * @returns string with the trailing comma removed
+     */
+    removeTrailingComma(str) {
+        return str.trim().replaceAll(/(,$)/g, '');
+    },
+    /**
+     * Checks that the string is a list of coma separated email addresss.
+     *
+     * @param str The string to check for emails validity.
+     *
+     * @returns True if all emails are valid or if input is empty
+     */
+    areValidEmails(str) {
+        const string = this.removeTrailingComma(str);
+        if (string === '') {
+            return true;
+        }
+        const emails = string.split(',');
+        const result = emails.every((email) => this.isValidEmail(email.trim()));
+        return result;
+    },
+    /**
+     * Extract the email addresses from a string
+     */
+    extractEmail(str) {
+        return String(str).match(Constants.CONST.REG_EXP.EMAIL_SEARCH);
+    },
+    /**
+     * Extracts the domain name from the given email address
+     * (e.g. "domain.com" for "joe@domain.com").
+     *
+     * @param email The email address.
+     *
+     * @returns The domain name in the email address.
+     */
+    extractEmailDomain(email) {
+        return this.cutBefore(email, '@');
+    },
+    /**
+     * Tries to extract the company name from the given email address
+     * (e.g. "yelp" for "joe@yelp.co.uk").
+     *
+     * @param email The email address.
+     *
+     * @returns The company name in the email address or null.
+     */
+    extractCompanyNameFromEmailDomain(email) {
+        const domain = this.extractEmailDomain(email);
+        if (!domain) {
+            return null;
+        }
+        const domainParts = domain.split('.');
+        if (!domainParts.length) {
+            return null;
+        }
+        return domainParts[0];
+    },
+    /**
+     * Extracts the local part from the given email address
+     * (e.g. "joe" for "joe@domain.com").
+     *
+     * @param email The email address.
+     *
+     * @returns The local part in the email address.
+     */
+    extractEmailLocalPart(email) {
+        return this.cutAfter(email, '@');
+    },
+    /**
+     * Sanitize phone number to return only numbers. Return null if non valid phone number.
+     */
+    sanitizePhoneNumber(str) {
+        const string = str.replaceAll(/(?!^\+)\D/g, '');
+        return string.length <= 15 && string.length >= 10 ? string : null;
+    },
+    /**
+     * Sanitize email. Return null if non valid email.
+     */
+    sanitizeEmail(str) {
+        const string = str.toLowerCase().trim();
+        return Constants.CONST.REG_EXP.EMAIL.test(string) ? string : null;
+    },
+    /**
+     * Escapes all special RegExp characters from a string
+     *
+     * @param str The subject
+     *
+     * @returns The escaped string
+     */
+    escapeForRegExp(str) {
+        return str.replaceAll(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+    },
+    /**
+     * Escapes all special RegExp characters from a string except for the period
+     *
+     * @param str The subject
+     * @returns The escaped string
+     */
+    escapeForExpenseRule(str) {
+        return str.replaceAll(/[-[\]/{}()*+?\\^$|]/g, '\\$&');
+    },
+    /**
+     * Adds a backslash in front of each of colon
+     * if they don't already have a backslash in front of them
+     *
+     * @param str The subject
+     * @returns The escaped string
+     */
+    addBackslashBeforeColonsForTagNamesComingFromQBD(str) {
+        return str.replaceAll(/([^\\]):/g, '$1\\:');
+    },
+    /**
+     * Removes backslashes from string
+     * eg: myString\[\]\* -> myString[]*
+     */
+    stripBackslashes(str) {
+        return str.replaceAll('\\', '');
+    },
+    /**
+     * Checks if a string's length is in the specified range
+     *
+     * @returns true if the length is in the range, false otherwise
+     */
+    isOfLength(str, minimumLength, maximumLength) {
+        if (!this.isString(str)) {
+            return false;
+        }
+        if (str.length < minimumLength) {
+            return false;
+        }
+        if (!this.isUndefined(maximumLength) && str.length > maximumLength) {
+            return false;
+        }
+        return true;
+    },
+    /**
+     * Count the number of occurences of needle in haystack.
+     * This is faster than counting the results of haystack.match( /needle/g )
+     * via http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string
+     *
+     * @param haystack The string to look inside of
+     * @param needle What we're looking for
+     * @param allowOverlapping Defaults to false
+     *
+     * @returns The number of times needle is in haystack.
+     */
+    occurences(haystack, needle, allowOverlapping) {
+        let count = 0;
+        let pos = 0;
+        // Force strings for input
+        const haystackStr = String(haystack);
+        const needleStr = String(needle);
+        if (needleStr.length <= 0) {
+            return haystackStr.length + 1;
+        }
+        const step = allowOverlapping ? 1 : needleStr.length;
+        while (pos >= 0) {
+            pos = haystackStr.indexOf(needleStr, pos);
+            if (pos >= 0) {
+                count += 1;
+                pos += step;
+            }
+        }
+        return count;
+    },
+    /**
+     * Uppercases the first letter of each word
+     * via https://github.com/kvz/phpjs/blob/master/functions/strings/ucwords.js
+     *
+     * @param str to uppercase words
+     * @returns Uppercase worded string
+     */
+    ucwords(str) {
+        const capitalize = ($1) => $1.toUpperCase();
+        return String(str).replaceAll(/^([a-z\u00E0-\u00FC])|\s+([a-z\u00E0-\u00FC])/g, capitalize);
+    },
+    /**
+     * Returns true if the haystack contains the needle
+     *
+     * @param haystack The full string to be searched
+     * @param needle The case-sensitive string to search for
+     *
+     * @returns Returns true if the haystack contains the needle
+     */
+    contains(haystack, needle) {
+        return haystack.indexOf(needle) !== -1;
+    },
+    /**
+     * Returns true if the haystack contains the needle, ignoring case
+     *
+     * @param haystack The full string to be searched
+     * @param needle The case-insensitive string to search for
+     *
+     * @returns Returns true if the haystack contains the needle, ignoring case
+     */
+    caseInsensitiveContains(haystack, needle) {
+        return this.contains(haystack.toLowerCase(), needle.toLowerCase());
+    },
+    /**
+     * Case insensitive compare function
+     *
+     * @param strA string to compare
+     * @param strB string to compare
+     *
+     * @returns -1 if first string < second string
+     *                   1 if first string > second string
+     *                   0 if first string = second string
+     */
+    caseInsensitiveCompare(strA, strB) {
+        const lowerCaseStrA = strA.toLocaleLowerCase();
+        const lowerCaseStrB = strB.toLocaleLowerCase();
+        return this.compare(lowerCaseStrA, lowerCaseStrB);
+    },
+    /**
+     * Case insensitive equals
+     *
+     * @param strA string to compare
+     * @param strB string to compare
+     * @returns true when first == second except for case
+     */
+    caseInsensitiveEquals(strA, strB) {
+        return this.caseInsensitiveCompare(strA, strB) === 0;
+    },
+    /**
+     * Compare function
+     *
+     * @param strA string to compare
+     * @param strB string to compare
+     *
+     * @returns -1 if first string < second string
+     *                   1 if first string > second string
+     *                   0 if first string = second string
+     */
+    compare(strA, strB) {
+        if (strA < strB) {
+            return -1;
+        }
+        if (strA > strB) {
+            return 1;
+        }
+        return 0;
+    },
+    /**
+     * Check if a file extension is supported by SmartReports
+     */
+    isFileExtensionSmartReportsValid(filename) {
+        var _a;
+        // Allowed extensions. Make sure to keep them in sync with those defined
+        // in SmartReport_Utils::templateFileUploadCheck()
+        const allowedExtensions = ['xls', 'xlsx', 'xlsm', 'xltm'];
+        const extension = (_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        return !!extension && allowedExtensions.indexOf(extension) > -1;
+    },
+    /**
+     * Mask Permanent Account Number (PAN) the same way Auth does
+     * @param num account number
+     * @returns masked account number
+     */
+    maskPAN(num) {
+        // cast to string
+        const accountNumber = String(num);
+        const len = accountNumber.length;
+        // Hide these numbers completely
+        // We should not be getting account numbers this small or large
+        if (len < 6 || len > 20) {
+            return this.maskFirstNCharacters(accountNumber, len, 'X');
+        }
+        // Can show last 4
+        if (len < 14) {
+            return this.maskFirstNCharacters(accountNumber, len - 4, 'X');
+        }
+        // Can show first 6 and last 4
+        const first = accountNumber.substr(0, 6);
+        const last = accountNumber.substr(7);
+        const masked = this.maskFirstNCharacters(last, len - 11, 'X');
+        return `${first}${masked}`;
+    },
+    /**
+     * Checks if something is a string
+     * Stolen from underscore
+     */
+    isString(obj) {
+        return this.isTypeOf(obj, 'String');
+    },
+    /**
+     * Checks if something is a number
+     * Stolen from underscore
+     * @param obj
+     */
+    isNumber(obj) {
+        return this.isTypeOf(obj, 'Number');
+    },
+    /**
+     * Checks if something is a certain type
+     * Stolen from underscore
+     */
+    isTypeOf(obj, type) {
+        return Object.prototype.toString.call(obj) === `[object ${type}]`;
+    },
+    /**
+     * Checks to see if something is undefined
+     * Stolen from underscore
+     */
+    isUndefined(obj) {
+        // eslint-disable-next-line no-void
+        return obj === void 0;
+    },
+    /**
+     * Replace first N characters of the string with maskChar
+     * eg: maskFirstNCharacters( '1234567890', 6, 'X' ) yields XXXXXX7890
+     * @param str String to mask
+     * @param num Number of characters we want to mask from the string
+     * @param mask String we want replace the first N chars with
+     * @returns Masked string
+     */
+    maskFirstNCharacters(str, num, mask) {
+        // if str is empty, str or mask aren't strings,
+        // or n is not a number, do nothing
+        if (!this.isString(str) || !this.isString(mask) || str.length === 0 || !this.isNumber(num)) {
+            return str;
+        }
+        return str.substring(0, num).replaceAll(/./g, mask) + str.substring(num);
+    },
+    /**
+     * Trim a string
+     */
+    trim(str) {
+        return str.trim();
+    },
+    /**
+     * Convert a percentage string like '25%' to 25/
+     * @param percentageString The percentage as a string
+     */
+    percentageStringToNumber(percentageString) {
+        return Number(this.cutAfter(percentageString, '%'));
+    },
+    /**
+     * Remove all the spaces from a string
+     */
+    removeSpaces(input) {
+        return String(input).replace(' ', '');
+    },
+    /**
+     * Returns the proper phrase depending on the count that is passed.
+     * Example:
+     * console.log(Str.pluralize('puppy', 'puppies', 1)) { // puppy
+     * console.log(Str.pluralize('puppy', 'puppies', 3)) { // puppies
+     *
+     * @param singular form of the phrase
+     * @param plural form of the phrase
+     * @param num the count which determines the plurality
+     */
+    pluralize(singular, plural, num) {
+        if (!num || num > 1) {
+            return plural;
+        }
+        return singular;
+    },
+    /**
+     * Returns whether or not a string is an encrypted number or not.
+     *
+     * @param num that we want to see if its encrypted or not
+     *
+     * @returns Whether or not this string is an encrpypted number
+     */
+    isEncryptedCardNumber(num) {
+        // Older encrypted versioning.
+        if (/^[\da-fA-F]+$/.test(num)) {
+            return num.length % 32 === 0;
+        }
+        // Check with the new versioning.
+        if (/^[vV][\d]+:[\da-fA-F]+$/.test(num)) {
+            return num.split(':')[1].length % 32 === 0;
+        }
+        return false;
+    },
+    /**
+     * Converts a value to boolean, case-insensitive.
+     */
+    toBool(value) {
+        if (this.isString(value)) {
+            return value.toLowerCase() === 'true';
+        }
+        return !!value;
+    },
+    /**
+     * Checks if a string could be the masked version of another one.
+     *
+     * @param strA String to compare
+     * @param strB String to compare
+     * @param [mask] Defaults to X
+     * @returns True when first could be the masked version of second
+     */
+    maskedEquals(strA, strB, mask) {
+        var _a, _b;
+        const firsts = (_a = strA.match(/.{1,1}/g)) !== null && _a !== void 0 ? _a : [];
+        const seconds = (_b = strB.match(/.{1,1}/g)) !== null && _b !== void 0 ? _b : [];
+        const defaultMask = mask || 'X';
+        if (firsts.length !== seconds.length) {
+            return false;
+        }
+        for (let i = 0; i < firsts.length; i += 1) {
+            if (firsts[i] !== seconds[i] && firsts[i] !== defaultMask && seconds[i] !== defaultMask) {
+                return false;
+            }
+        }
+        return true;
+    },
+    /**
+     * Bold any word matching the regexp in the text.
+     */
+    boldify(text, regexp) {
+        return text.replace(regexp, '<strong>$1</strong>');
+    },
+    /**
+     * Check for whether a phone number is valid.
+     * @deprecated use isValidE164Phone to validate E.164 phone numbers or isValidPhoneFormat to validate phone numbers in general
+     */
+    isValidPhone(phone) {
+        return Constants.CONST.SMS.E164_REGEX.test(phone);
+    },
+    /**
+     * Check for whether a phone number is valid.
+     */
+    isValidPhoneNumber(phone) {
+        return parsePhoneNumber(phone).possible;
+    },
+    /**
+     * Check for whether a phone number is valid according to E.164 standard.
+     */
+    isValidE164Phone(phone) {
+        return Constants.CONST.SMS.E164_REGEX.test(phone);
+    },
+    /**
+     * Check for whether a phone number is valid in different formats/standards. For example:
+     * significant: 4404589784
+     * international: +1 440-458-9784
+     * e164: +14404589784
+     * national: (440) 458-9784
+     * 123.456.7890
+     */
+    isValidPhoneFormat(phone) {
+        return Constants.CONST.REG_EXP.GENERAL_PHONE_PART.test(phone);
+    },
+    /**
+     * We validate mentions by checking if it's first character is an allowed character.
+     */
+    isValidMention(mention) {
+        // Mentions can start @ proceeded by a space, eg "ping @user@domain.tld"
+        if (/[\s@]/g.test(mention.charAt(0))) {
+            return true;
+        }
+        // Mentions can also start and end with a *, _, ~, ', or " (with no other preceding characters)
+        // eg "ping *@user@domain.tld*"
+        const firstChar = mention.charAt(0);
+        const lastChar = mention.charAt(mention.length - 1);
+        return /[*~_'"]/g.test(firstChar) && /[*~_'"]/g.test(lastChar) && firstChar === lastChar;
+    },
+    /**
+     * Returns text without our SMS domain
+     */
+    removeSMSDomain(text) {
+        return text.replaceAll(REMOVE_SMS_DOMAIN_PATTERN, '');
+    },
+    /**
+     * Returns true if the text is a valid E.164 phone number with our SMS domain removed
+     */
+    isSMSLogin(text) {
+        return this.isValidE164Phone(this.removeSMSDomain(text));
+    },
+    /**
+     * This method will return all matches of a single regex like preg_match_all() in PHP. This is not a common part of
+     * JS yet, so this is a good way of doing it according to
+     * https://github.com/airbnb/javascript/issues/1439#issuecomment-306297399 and doesn't get us in trouble with
+     * linting rules.
+     */
+    matchAll(str, regex) {
+        const matches = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const collectMatches = (...args) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const match = Array.prototype.slice.call(args, 0, -2);
+            match.input = args[args.length - 1];
+            match.index = args[args.length - 2];
+            matches.push(match);
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        str.replace(regex, collectMatches);
+        return matches;
+    },
+    /**
+     * A simple GUID generator taken from https://stackoverflow.com/a/32760401/9114791
+     *
+     * @param [prefix] an optional prefix to put in front of the guid
+     */
+    guid(prefix = '') {
+        function s4() {
+            return Math.floor((1 + Math.random()) * 0x10000)
+                .toString(16)
+                .substring(1);
+        }
+        return `${prefix}${s4()}${s4()}-${s4()}-${s4()}-${s4()}-${s4()}${s4()}${s4()}`;
+    },
+    /**
+     * Takes in a URL and returns it with a leading '/'
+     *
+     * @param url The URL to be formatted
+     * @returns The formatted URL
+     */
+    normalizeUrl(url) {
+        return typeof url === 'string' && url.startsWith('/') ? url : `/${url}`;
+    },
+    /**
+     *  Formats a URL by converting the domain name to lowercase and adding the missing 'https://' protocol.
+     *
+     * @param url The URL to be formatted
+     * @param defaultScheme The Scheme to use in the URL
+     * @returns The formatted URL
+     */
+    sanitizeURL(url, defaultScheme = 'https') {
+        const regex = new RegExp(`^${UrlPatterns.URL_REGEX}$`, 'i');
+        const match = regex.exec(url);
+        if (!match) {
+            return url;
+        }
+        const website = match[3] ? match[2] : `${defaultScheme}://${match[2]}`;
+        return website.toLowerCase() + this.cutBefore(match[1], match[2]);
+    },
+    /**
+     * Checks if parameter is a string or function
+     * if it is a function then we will call it with
+     * any additional arguments.
+     */
+    result: resultFn,
+    /**
+     * Get file extension for a given url with or
+     * without query parameters
+     */
+    getExtension(url) {
+        var _a, _b;
+        if (typeof url !== 'string') {
+            Log.warn('Str.getExtension: url is not a string', { url });
+            return undefined;
+        }
+        return (_b = (_a = url.split('.').pop()) === null || _a === void 0 ? void 0 : _a.split('?')[0]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    },
+    /**
+     * Takes in a URL and checks if the file extension is PDF
+     *
+     * @param url The URL to be checked
+     * @returns Whether file path is PDF or not
+     */
+    isPDF(url) {
+        return this.getExtension(url) === 'pdf';
+    },
+    /**
+     * Takes in a URL and checks if the file extension is an image
+     * that can be rendered by React Native. Do NOT add extensions
+     * to this list unless they appear in this list and are
+     * supported by all platforms.
+     *
+     * https://reactnative.dev/docs/image#source
+     */
+    isImage(url) {
+        const extension = this.getExtension(url);
+        if (!extension) {
+            return false;
+        }
+        return ['jpeg', 'jpg', 'gif', 'png', 'bmp', 'webp'].includes(extension);
+    },
+    /**
+     * Takes in a URL and checks if the file extension is a video
+     * that can be rendered by React Native. Do NOT add extensions
+     * to this list unless they are supported by all platforms.
+     *
+     * https://developer.android.com/media/platform/supported-formats#video-formats
+     * https://developer.apple.com/documentation/coremedia/1564239-video_codec_constants
+     * https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs
+     */
+    isVideo(url) {
+        const extension = this.getExtension(url);
+        if (!extension) {
+            return false;
+        }
+        return ['mov', 'mp4', 'webm', 'mkv'].includes(extension);
+    },
+    /**
+     * Checks whether the given string is a +@ domain email account, such as
+     * +@domain.com
+     *
+     * @returns True if is a domain account email, otherwise false.
+     */
+    isDomainEmail(email) {
+        return this.startsWith(email, '+@');
+    },
+    /**
+     * Find the minimum indentation of any line in the string,
+     * and remove that number of leading spaces from every line in the string.
+     *
+     * It also removes at most one leading newline, to reflect a common usage:
+     *
+     * ```
+     * Str.dedent(`
+     *    const myIndentedStr = 'Hello, world!';
+     *    console.log(myIndentedStr);
+     * `)
+     * ```
+     *
+     * This implementation assumes you'd want that to be:
+     *
+     * ```
+     * const myIndentedStr = 'Hello, world!';
+     * console.log(myIndentedStr);
+     *
+     * ```
+     *
+     * Rather than:
+     *
+     * ```
+     *
+     * const myIndentedStr = 'Hello, world!';
+     * console.log(myIndentedStr);
+     *
+     * ```
+     */
+    dedent(str) {
+        var _a, _b;
+        // Remove at most one leading newline
+        const stringWithoutLeadingNewlines = str.replaceAll(/^\r?\n/g, '');
+        // Split string by remaining newlines
+        const lines = stringWithoutLeadingNewlines.replaceAll('\r\n', '\n').split('\n');
+        // Find the minimum indentation of non-empty lines
+        let minIndent = Number.MAX_SAFE_INTEGER;
+        for (const line of lines) {
+            if (line.trim().length === 0) {
+                continue;
+            }
+            const indentation = (_b = (_a = line.match(/^ */)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+            if (indentation < minIndent) {
+                minIndent = indentation;
+            }
+        }
+        // Remove the common indentation
+        return lines.map((line) => line.slice(minIndent)).join('\n');
+    },
+    /**
+     * Polyfill for String.prototype.replaceAll
+     */
+    replaceAll(text, searchValue, replaceValue) {
+        return String.prototype.replaceAll.call(text, searchValue, replaceValue);
+    },
+};
+export default Str;