expensify-common 2.0.200 → 2.0.201

package/dist/ExpensiMark.d.ts

@@ -133,7 +133,7 @@ export default class ExpensiMark {
     /**
      * Checks matched URLs for validity and replace valid links with html elements
      */
-    modifyTextForUrlLinks(regex: RegExp, textToCheck: string, replacement: ReplacementFn): string;
+    modifyTextForUrlLinks(regex: RegExp, textToCheck: string, replacement: ReplacementFn, shouldScanForUrls?: boolean): string;
     /**
      * Checks matched Emails for validity and replace valid links with html elements
      */

package/dist/ExpensiMark.js

@@ -43,9 +43,23 @@ const UrlPatterns = __importStar(require("./Url"));
 const Logger_1 = __importDefault(require("./Logger"));
 const Utils = __importStar(require("./utils"));
 const EXTRAS_DEFAULT = {};
+// These constants represent the ASCII ranges for digits (0-9) and letters (A-Z, a-z).
+const ASCII_DIGIT_START = '0'.charCodeAt(0);
+const ASCII_DIGIT_END = '9'.charCodeAt(0);
+const ASCII_UPPERCASE_START = 'A'.charCodeAt(0);
+const ASCII_UPPERCASE_END = 'Z'.charCodeAt(0);
+const ASCII_LOWERCASE_START = 'a'.charCodeAt(0);
+const ASCII_LOWERCASE_END = 'z'.charCodeAt(0);
+const ASCII_WHITESPACE_END = ' '.charCodeAt(0);
+const NON_BREAKING_SPACE_CODE = 160;
+const URL_PROTOCOLS = ['https://', 'http://', 'ftps://', 'ftp://'];
+const URL_CANDIDATE_PREFIX_CHARACTERS = '@_*~';
+const PROTECTED_TAG_NAMES = new Set(['a', 'code', 'pre', 'video']);
 const MARKDOWN_LINK_REGEX = new RegExp(`\\[((?:[^\\[\\]\\r\\n]*(?:\\[[^\\[\\]\\r\\n]*][^\\[\\]\\r\\n]*)*))]\\(${UrlPatterns.MARKDOWN_URL_REGEX}\\)(?![^<]*(<\\/pre>|<\\/code>))`, 'gi');
 const MARKDOWN_IMAGE_REGEX = new RegExp(`\\!(?:\\[([^\\][]*(?:\\[[^\\][]*][^\\][]*)*)])?\\(${UrlPatterns.MARKDOWN_URL_REGEX}\\)(?![^<]*(<\\/pre>|<\\/code>))`, 'gi');
 const MARKDOWN_VIDEO_REGEX = new RegExp(`\\!(?:\\[([^\\][]*(?:\\[[^\\][]*][^\\][]*)*)])?\\(((${UrlPatterns.MARKDOWN_URL_REGEX})\\.(?:${Constants.CONST.VIDEO_EXTENSIONS.join('|')}))\\)(?![^<]*(<\\/pre>|<\\/code>))`, 'gi');
+const BOLD_MARKDOWN_REGEX = /(?<!<[^>]*)(\b_|\B)\*(?!(?:<\/em))(?![^<]*(?:<\/pre>|<\/code>|<\/a>|<\/video>))((?![\s*])[\s\S]*?[^\s*](?<!\s))\*\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g;
+const STRIKETHROUGH_MARKDOWN_REGEX = /(?<!<[^>]*)\B~((?![\s~])[\s\S]*?[^\s~](?<!\s))~\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g;
 const SLACK_SPAN_NEW_LINE_TAG = '<span class="c-mrkdwn__br" data-stringify-type="paragraph-break" style="box-sizing: inherit; display: block; height: unset;"></span>';
 // Preserve VirtualCFO chart blocks by matching the outer <VictoryChart> container.
 // This captures all nested Victory components and prevents markup escaping during conversion.
@@ -85,6 +99,236 @@ function replaceTextWithExtras(text, regexp, extras, replacement) {
     }
     return text.replace(regexp, replacement);
 }
+/** Returns whether the character is an ASCII letter or digit. */
+function isAsciiAlphaNumeric(character) {
+    if (!character) {
+        return false;
+    }
+    const code = character.charCodeAt(0);
+    return ((code >= ASCII_DIGIT_START && code <= ASCII_DIGIT_END) ||
+        (code >= ASCII_UPPERCASE_START && code <= ASCII_UPPERCASE_END) ||
+        (code >= ASCII_LOWERCASE_START && code <= ASCII_LOWERCASE_END));
+}
+/** Returns whether the character is an ASCII letter, digit, or underscore. */
+function isWordCharacter(character) {
+    return character === '_' || isAsciiAlphaNumeric(character);
+}
+/** Returns whether the marker at this position can open a bold range. */
+function canOpenBoldMarkdown(text, position, isProtected) {
+    if (isProtected) {
+        return false;
+    }
+    const nextCharacter = text[position + 1];
+    if (!nextCharacter || /\s|\*/.test(nextCharacter) || text.startsWith('</em', position + 1)) {
+        return false;
+    }
+    const previousCharacter = text[position - 1];
+    if (!isWordCharacter(previousCharacter)) {
+        return true;
+    }
+    return previousCharacter === '_' && !isWordCharacter(text[position - 2]);
+}
+/** Returns whether the marker at this position can open a strikethrough range. */
+function canOpenStrikethroughMarkdown(text, position) {
+    if (isWordCharacter(text[position - 1])) {
+        return false;
+    }
+    const nextCharacter = text[position + 1];
+    return !!nextCharacter && !/\s|~/.test(nextCharacter);
+}
+/** Returns whether the marker at this position can close a bold or strikethrough range. */
+function canCloseMarkdown(text, position, marker) {
+    const previousCharacter = text[position - 1];
+    return !!previousCharacter && !/\s/.test(previousCharacter) && previousCharacter !== marker && !isWordCharacter(text[position + 1]);
+}
+/** Records when scanning enters or leaves <a>, <code>, <pre>, or <video>, then returns the character after the tag. */
+function updateProtectedTagStack(text, tagStart, protectedTags) {
+    var _a, _b;
+    const tagEnd = text.indexOf('>', tagStart + 1);
+    if (tagEnd === -1) {
+        return undefined;
+    }
+    const tag = text.slice(tagStart + 1, tagEnd).trim();
+    const isClosingTag = tag.startsWith('/');
+    const tagName = (_b = (_a = tag.match(/^\/?\s*([a-z][a-z0-9-]*)/i)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    if (tagName && PROTECTED_TAG_NAMES.has(tagName)) {
+        if (isClosingTag) {
+            const matchingTagIndex = protectedTags.lastIndexOf(tagName);
+            if (matchingTagIndex !== -1) {
+                protectedTags.splice(matchingTagIndex, 1);
+            }
+        }
+        else if (!tag.endsWith('/')) {
+            protectedTags.push(tagName);
+        }
+    }
+    return tagEnd + 1;
+}
+/** Returns whether the character can be part of a hostname such as example.com. */
+function isHostnameCharacter(character) {
+    return !!character && (isAsciiAlphaNumeric(character) || character === '-' || character === '.');
+}
+/** Returns whether the character is whitespace that ends a possible URL. */
+function isUrlBoundarySpace(character) {
+    const code = character.charCodeAt(0);
+    return code <= ASCII_WHITESPACE_END || code === NON_BREAKING_SPACE_CODE;
+}
+/** Returns the supported URL protocol that starts at this position, if one exists. */
+function getProtocolAt(text, position) {
+    var _a;
+    const firstCharacter = (_a = text[position]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (firstCharacter !== 'h' && firstCharacter !== 'f') {
+        return undefined;
+    }
+    return URL_PROTOCOLS.find((protocol) => text.slice(position, position + protocol.length).toLowerCase() === protocol);
+}
+/** Reads the text after the dot in example.com and returns where the hostname ends. */
+function findHostnameEnd(text, hostnameStart, dotPosition) {
+    let hostnameEnd = dotPosition + 1;
+    while (hostnameEnd < text.length && (isAsciiAlphaNumeric(text[hostnameEnd]) || text[hostnameEnd] === '-')) {
+        hostnameEnd++;
+    }
+    if (hostnameStart === dotPosition || hostnameEnd === dotPosition + 1) {
+        return undefined;
+    }
+    return hostnameEnd;
+}
+/** Expands example.com to include nearby @, *, _, or ~ in any order, plus its path, until whitespace or HTML. */
+function extendUrlCandidateBoundaries(text, start, end) {
+    let candidateStart = start;
+    while (candidateStart > 0 && URL_CANDIDATE_PREFIX_CHARACTERS.includes(text[candidateStart - 1])) {
+        candidateStart--;
+    }
+    let candidateEnd = end;
+    while (candidateEnd < text.length && !isUrlBoundarySpace(text[candidateEnd]) && text[candidateEnd] !== '<') {
+        candidateEnd++;
+    }
+    return { start: candidateStart, end: candidateEnd };
+}
+/** Finds possible URL ranges, skips URL-looking text inside protected tags, and leaves validity to the existing regex. */
+function findUrlCandidates(text) {
+    const candidates = [];
+    const protectedTags = [];
+    let index = 0;
+    let hostnameRunStart = 0;
+    while (index < text.length) {
+        if (text[index] === '<') {
+            const nextIndex = updateProtectedTagStack(text, index, protectedTags);
+            if (nextIndex === undefined) {
+                break;
+            }
+            index = nextIndex;
+            hostnameRunStart = index;
+            continue;
+        }
+        if (protectedTags.length > 0) {
+            index++;
+            hostnameRunStart = index;
+            continue;
+        }
+        const matchedProtocol = getProtocolAt(text, index);
+        if (matchedProtocol) {
+            const candidate = extendUrlCandidateBoundaries(text, index, index + matchedProtocol.length);
+            candidates.push(candidate);
+            index = candidate.end;
+            hostnameRunStart = candidate.end;
+            continue;
+        }
+        if (!isHostnameCharacter(text[index])) {
+            hostnameRunStart = index + 1;
+            index++;
+            continue;
+        }
+        if (text[index] !== '.') {
+            index++;
+            continue;
+        }
+        const hostnameEnd = findHostnameEnd(text, hostnameRunStart, index);
+        if (hostnameEnd === undefined) {
+            index++;
+            continue;
+        }
+        const candidate = extendUrlCandidateBoundaries(text, hostnameRunStart, hostnameEnd);
+        candidates.push(candidate);
+        index = candidate.end;
+        hostnameRunStart = candidate.end;
+    }
+    return candidates;
+}
+/** Finds possible bold or strikethrough pairs, preserves marker order inside protected tags, and runs the existing regex only on each candidate. */
+function replaceMarkdownCandidates(text, regexp, replacement, marker, canOpen) {
+    if (!text.includes(marker)) {
+        return text;
+    }
+    const markers = [];
+    const protectedTags = [];
+    let index = 0;
+    while (index < text.length) {
+        if (text[index] === '<') {
+            const nextIndex = updateProtectedTagStack(text, index, protectedTags);
+            if (nextIndex === undefined) {
+                break;
+            }
+            index = nextIndex;
+            continue;
+        }
+        // Keep protected markers in order, but remember that they cannot be replaced.
+        if (text[index] === marker) {
+            markers.push({ position: index, isProtected: protectedTags.length > 0 });
+        }
+        index++;
+    }
+    // A Markdown range needs both an opening and closing marker, such as the two * characters in *bold*.
+    if (markers.length < 2) {
+        return text;
+    }
+    const output = [];
+    const candidateRegex = regexp;
+    let outputStart = 0;
+    let openingMarker;
+    for (const currentMarker of markers) {
+        const markerPosition = currentMarker.position;
+        if (openingMarker === undefined) {
+            openingMarker = canOpen(text, markerPosition, currentMarker.isProtected) ? currentMarker : undefined;
+            continue;
+        }
+        if (currentMarker.isProtected || !canCloseMarkdown(text, markerPosition, marker)) {
+            continue;
+        }
+        if (openingMarker.isProtected) {
+            openingMarker = undefined;
+            continue;
+        }
+        const openingPosition = openingMarker.position;
+        const prefixLength = openingPosition > 0 ? 1 : 0;
+        const suffixLength = markerPosition + 1 < text.length ? 1 : 0;
+        const candidateStart = openingPosition - prefixLength;
+        const candidateEnd = markerPosition + 1 + suffixLength;
+        const candidate = text.slice(candidateStart, candidateEnd);
+        candidateRegex.lastIndex = 0;
+        const candidateMatch = candidateRegex.exec(candidate);
+        if (!candidateMatch) {
+            openingMarker = canOpen(text, markerPosition, currentMarker.isProtected) ? currentMarker : undefined;
+            continue;
+        }
+        candidateRegex.lastIndex = 0;
+        const replacedCandidate = replaceTextWithExtras(candidate, candidateRegex, EXTRAS_DEFAULT, replacement);
+        if (replacedCandidate !== candidate) {
+            const replacedCoreEnd = suffixLength ? replacedCandidate.length - suffixLength : replacedCandidate.length;
+            output.push(text.slice(outputStart, openingPosition));
+            output.push(replacedCandidate.slice(prefixLength, replacedCoreEnd));
+            outputStart = markerPosition + 1;
+            openingMarker = undefined;
+            continue;
+        }
+        openingMarker = undefined;
+    }
+    if (output.length === 0) {
+        return text;
+    }
+    output.push(text.slice(outputStart));
+    return output.join('');
+}
 /**
  * replace block element with '\n' if :
  * 1. We have text within the element.
@@ -547,7 +791,7 @@ class ExpensiMark {
                 name: 'autolink',
                 process: (textToProcess, replacement) => {
                     const regex = new RegExp(`(?![^<]*>|[^<>]*<\\/(?!h1>))([_*~]*?)${UrlPatterns.MARKDOWN_URL_REGEX}\\1(?!((?:(?!<a).)+)?<\\/a>|[^<]*(<\\/pre>|<\\/code>))`, 'gi');
-                    return this.modifyTextForUrlLinks(regex, textToProcess, replacement);
+                    return this.modifyTextForUrlLinks(regex, textToProcess, replacement, true);
                 },
                 replacement: (_extras, _match, g1, g2) => {
                     const href = str_1.default.sanitizeURL(g2);
@@ -653,7 +897,7 @@ class ExpensiMark {
                 // \B will match everything that \b doesn't, so it works
                 // for * and ~: https://www.rexegg.com/regex-boundaries.html#notb
                 name: 'bold',
-                regex: /(?<!<[^>]*)(\b_|\B)\*(?!(?:<\/em))(?![^<]*(?:<\/pre>|<\/code>|<\/a>|<\/video>))((?![\s*])[\s\S]*?[^\s*](?<!\s))\*\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g,
+                process: (textToProcess, replacement) => replaceMarkdownCandidates(textToProcess, BOLD_MARKDOWN_REGEX, replacement, '*', canOpenBoldMarkdown),
                 replacement: (_extras, match, g1, g2) => {
                     if (g1.includes('_')) {
                         return `${g1}<strong>${g2}</strong>`;
@@ -663,7 +907,7 @@ class ExpensiMark {
             },
             {
                 name: 'strikethrough',
-                regex: /(?<!<[^>]*)\B~((?![\s~])[\s\S]*?[^\s~](?<!\s))~\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g,
+                process: (textToProcess, replacement) => replaceMarkdownCandidates(textToProcess, STRIKETHROUGH_MARKDOWN_REGEX, replacement, '~', canOpenStrikethroughMarkdown),
                 replacement: (_extras, match, g1) => (g1.includes('</pre>') || containsNonPairTag(g1) ? match : `<del>${g1}</del>`),
             },
             {
@@ -1111,7 +1355,25 @@ class ExpensiMark {
     /**
      * Checks matched URLs for validity and replace valid links with html elements
      */
-    modifyTextForUrlLinks(regex, textToCheck, replacement) {
+    modifyTextForUrlLinks(regex, textToCheck, replacement, shouldScanForUrls = false) {
+        if (shouldScanForUrls) {
+            const candidates = findUrlCandidates(textToCheck);
+            if (candidates.length === 0) {
+                return textToCheck;
+            }
+            const output = [];
+            const candidateRegex = regex;
+            let outputStart = 0;
+            for (const { start, end } of candidates) {
+                const candidate = textToCheck.slice(start, end);
+                candidateRegex.lastIndex = 0;
+                output.push(textToCheck.slice(outputStart, start));
+                output.push(this.modifyTextForUrlLinks(candidateRegex, candidate, replacement));
+                outputStart = end;
+            }
+            output.push(textToCheck.slice(outputStart));
+            return output.join('');
+        }
         let match = regex.exec(textToCheck);
         let replacedText = '';
         let startIndex = 0;

package/dist/esm/ExpensiMark.d.ts

@@ -133,7 +133,7 @@ export default class ExpensiMark {
     /**
      * Checks matched URLs for validity and replace valid links with html elements
      */
-    modifyTextForUrlLinks(regex: RegExp, textToCheck: string, replacement: ReplacementFn): string;
+    modifyTextForUrlLinks(regex: RegExp, textToCheck: string, replacement: ReplacementFn, shouldScanForUrls?: boolean): string;
     /**
      * Checks matched Emails for validity and replace valid links with html elements
      */

package/dist/esm/ExpensiMark.js

@@ -5,9 +5,23 @@ import * as UrlPatterns from './Url';
 import Logger from './Logger';
 import * as Utils from './utils';
 const EXTRAS_DEFAULT = {};
+// These constants represent the ASCII ranges for digits (0-9) and letters (A-Z, a-z).
+const ASCII_DIGIT_START = '0'.charCodeAt(0);
+const ASCII_DIGIT_END = '9'.charCodeAt(0);
+const ASCII_UPPERCASE_START = 'A'.charCodeAt(0);
+const ASCII_UPPERCASE_END = 'Z'.charCodeAt(0);
+const ASCII_LOWERCASE_START = 'a'.charCodeAt(0);
+const ASCII_LOWERCASE_END = 'z'.charCodeAt(0);
+const ASCII_WHITESPACE_END = ' '.charCodeAt(0);
+const NON_BREAKING_SPACE_CODE = 160;
+const URL_PROTOCOLS = ['https://', 'http://', 'ftps://', 'ftp://'];
+const URL_CANDIDATE_PREFIX_CHARACTERS = '@_*~';
+const PROTECTED_TAG_NAMES = new Set(['a', 'code', 'pre', 'video']);
 const MARKDOWN_LINK_REGEX = new RegExp(`\\[((?:[^\\[\\]\\r\\n]*(?:\\[[^\\[\\]\\r\\n]*][^\\[\\]\\r\\n]*)*))]\\(${UrlPatterns.MARKDOWN_URL_REGEX}\\)(?![^<]*(<\\/pre>|<\\/code>))`, 'gi');
 const MARKDOWN_IMAGE_REGEX = new RegExp(`\\!(?:\\[([^\\][]*(?:\\[[^\\][]*][^\\][]*)*)])?\\(${UrlPatterns.MARKDOWN_URL_REGEX}\\)(?![^<]*(<\\/pre>|<\\/code>))`, 'gi');
 const MARKDOWN_VIDEO_REGEX = new RegExp(`\\!(?:\\[([^\\][]*(?:\\[[^\\][]*][^\\][]*)*)])?\\(((${UrlPatterns.MARKDOWN_URL_REGEX})\\.(?:${Constants.CONST.VIDEO_EXTENSIONS.join('|')}))\\)(?![^<]*(<\\/pre>|<\\/code>))`, 'gi');
+const BOLD_MARKDOWN_REGEX = /(?<!<[^>]*)(\b_|\B)\*(?!(?:<\/em))(?![^<]*(?:<\/pre>|<\/code>|<\/a>|<\/video>))((?![\s*])[\s\S]*?[^\s*](?<!\s))\*\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g;
+const STRIKETHROUGH_MARKDOWN_REGEX = /(?<!<[^>]*)\B~((?![\s~])[\s\S]*?[^\s~](?<!\s))~\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g;
 const SLACK_SPAN_NEW_LINE_TAG = '<span class="c-mrkdwn__br" data-stringify-type="paragraph-break" style="box-sizing: inherit; display: block; height: unset;"></span>';
 // Preserve VirtualCFO chart blocks by matching the outer <VictoryChart> container.
 // This captures all nested Victory components and prevents markup escaping during conversion.
@@ -47,6 +61,236 @@ function replaceTextWithExtras(text, regexp, extras, replacement) {
     }
     return text.replace(regexp, replacement);
 }
+/** Returns whether the character is an ASCII letter or digit. */
+function isAsciiAlphaNumeric(character) {
+    if (!character) {
+        return false;
+    }
+    const code = character.charCodeAt(0);
+    return ((code >= ASCII_DIGIT_START && code <= ASCII_DIGIT_END) ||
+        (code >= ASCII_UPPERCASE_START && code <= ASCII_UPPERCASE_END) ||
+        (code >= ASCII_LOWERCASE_START && code <= ASCII_LOWERCASE_END));
+}
+/** Returns whether the character is an ASCII letter, digit, or underscore. */
+function isWordCharacter(character) {
+    return character === '_' || isAsciiAlphaNumeric(character);
+}
+/** Returns whether the marker at this position can open a bold range. */
+function canOpenBoldMarkdown(text, position, isProtected) {
+    if (isProtected) {
+        return false;
+    }
+    const nextCharacter = text[position + 1];
+    if (!nextCharacter || /\s|\*/.test(nextCharacter) || text.startsWith('</em', position + 1)) {
+        return false;
+    }
+    const previousCharacter = text[position - 1];
+    if (!isWordCharacter(previousCharacter)) {
+        return true;
+    }
+    return previousCharacter === '_' && !isWordCharacter(text[position - 2]);
+}
+/** Returns whether the marker at this position can open a strikethrough range. */
+function canOpenStrikethroughMarkdown(text, position) {
+    if (isWordCharacter(text[position - 1])) {
+        return false;
+    }
+    const nextCharacter = text[position + 1];
+    return !!nextCharacter && !/\s|~/.test(nextCharacter);
+}
+/** Returns whether the marker at this position can close a bold or strikethrough range. */
+function canCloseMarkdown(text, position, marker) {
+    const previousCharacter = text[position - 1];
+    return !!previousCharacter && !/\s/.test(previousCharacter) && previousCharacter !== marker && !isWordCharacter(text[position + 1]);
+}
+/** Records when scanning enters or leaves <a>, <code>, <pre>, or <video>, then returns the character after the tag. */
+function updateProtectedTagStack(text, tagStart, protectedTags) {
+    var _a, _b;
+    const tagEnd = text.indexOf('>', tagStart + 1);
+    if (tagEnd === -1) {
+        return undefined;
+    }
+    const tag = text.slice(tagStart + 1, tagEnd).trim();
+    const isClosingTag = tag.startsWith('/');
+    const tagName = (_b = (_a = tag.match(/^\/?\s*([a-z][a-z0-9-]*)/i)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    if (tagName && PROTECTED_TAG_NAMES.has(tagName)) {
+        if (isClosingTag) {
+            const matchingTagIndex = protectedTags.lastIndexOf(tagName);
+            if (matchingTagIndex !== -1) {
+                protectedTags.splice(matchingTagIndex, 1);
+            }
+        }
+        else if (!tag.endsWith('/')) {
+            protectedTags.push(tagName);
+        }
+    }
+    return tagEnd + 1;
+}
+/** Returns whether the character can be part of a hostname such as example.com. */
+function isHostnameCharacter(character) {
+    return !!character && (isAsciiAlphaNumeric(character) || character === '-' || character === '.');
+}
+/** Returns whether the character is whitespace that ends a possible URL. */
+function isUrlBoundarySpace(character) {
+    const code = character.charCodeAt(0);
+    return code <= ASCII_WHITESPACE_END || code === NON_BREAKING_SPACE_CODE;
+}
+/** Returns the supported URL protocol that starts at this position, if one exists. */
+function getProtocolAt(text, position) {
+    var _a;
+    const firstCharacter = (_a = text[position]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (firstCharacter !== 'h' && firstCharacter !== 'f') {
+        return undefined;
+    }
+    return URL_PROTOCOLS.find((protocol) => text.slice(position, position + protocol.length).toLowerCase() === protocol);
+}
+/** Reads the text after the dot in example.com and returns where the hostname ends. */
+function findHostnameEnd(text, hostnameStart, dotPosition) {
+    let hostnameEnd = dotPosition + 1;
+    while (hostnameEnd < text.length && (isAsciiAlphaNumeric(text[hostnameEnd]) || text[hostnameEnd] === '-')) {
+        hostnameEnd++;
+    }
+    if (hostnameStart === dotPosition || hostnameEnd === dotPosition + 1) {
+        return undefined;
+    }
+    return hostnameEnd;
+}
+/** Expands example.com to include nearby @, *, _, or ~ in any order, plus its path, until whitespace or HTML. */
+function extendUrlCandidateBoundaries(text, start, end) {
+    let candidateStart = start;
+    while (candidateStart > 0 && URL_CANDIDATE_PREFIX_CHARACTERS.includes(text[candidateStart - 1])) {
+        candidateStart--;
+    }
+    let candidateEnd = end;
+    while (candidateEnd < text.length && !isUrlBoundarySpace(text[candidateEnd]) && text[candidateEnd] !== '<') {
+        candidateEnd++;
+    }
+    return { start: candidateStart, end: candidateEnd };
+}
+/** Finds possible URL ranges, skips URL-looking text inside protected tags, and leaves validity to the existing regex. */
+function findUrlCandidates(text) {
+    const candidates = [];
+    const protectedTags = [];
+    let index = 0;
+    let hostnameRunStart = 0;
+    while (index < text.length) {
+        if (text[index] === '<') {
+            const nextIndex = updateProtectedTagStack(text, index, protectedTags);
+            if (nextIndex === undefined) {
+                break;
+            }
+            index = nextIndex;
+            hostnameRunStart = index;
+            continue;
+        }
+        if (protectedTags.length > 0) {
+            index++;
+            hostnameRunStart = index;
+            continue;
+        }
+        const matchedProtocol = getProtocolAt(text, index);
+        if (matchedProtocol) {
+            const candidate = extendUrlCandidateBoundaries(text, index, index + matchedProtocol.length);
+            candidates.push(candidate);
+            index = candidate.end;
+            hostnameRunStart = candidate.end;
+            continue;
+        }
+        if (!isHostnameCharacter(text[index])) {
+            hostnameRunStart = index + 1;
+            index++;
+            continue;
+        }
+        if (text[index] !== '.') {
+            index++;
+            continue;
+        }
+        const hostnameEnd = findHostnameEnd(text, hostnameRunStart, index);
+        if (hostnameEnd === undefined) {
+            index++;
+            continue;
+        }
+        const candidate = extendUrlCandidateBoundaries(text, hostnameRunStart, hostnameEnd);
+        candidates.push(candidate);
+        index = candidate.end;
+        hostnameRunStart = candidate.end;
+    }
+    return candidates;
+}
+/** Finds possible bold or strikethrough pairs, preserves marker order inside protected tags, and runs the existing regex only on each candidate. */
+function replaceMarkdownCandidates(text, regexp, replacement, marker, canOpen) {
+    if (!text.includes(marker)) {
+        return text;
+    }
+    const markers = [];
+    const protectedTags = [];
+    let index = 0;
+    while (index < text.length) {
+        if (text[index] === '<') {
+            const nextIndex = updateProtectedTagStack(text, index, protectedTags);
+            if (nextIndex === undefined) {
+                break;
+            }
+            index = nextIndex;
+            continue;
+        }
+        // Keep protected markers in order, but remember that they cannot be replaced.
+        if (text[index] === marker) {
+            markers.push({ position: index, isProtected: protectedTags.length > 0 });
+        }
+        index++;
+    }
+    // A Markdown range needs both an opening and closing marker, such as the two * characters in *bold*.
+    if (markers.length < 2) {
+        return text;
+    }
+    const output = [];
+    const candidateRegex = regexp;
+    let outputStart = 0;
+    let openingMarker;
+    for (const currentMarker of markers) {
+        const markerPosition = currentMarker.position;
+        if (openingMarker === undefined) {
+            openingMarker = canOpen(text, markerPosition, currentMarker.isProtected) ? currentMarker : undefined;
+            continue;
+        }
+        if (currentMarker.isProtected || !canCloseMarkdown(text, markerPosition, marker)) {
+            continue;
+        }
+        if (openingMarker.isProtected) {
+            openingMarker = undefined;
+            continue;
+        }
+        const openingPosition = openingMarker.position;
+        const prefixLength = openingPosition > 0 ? 1 : 0;
+        const suffixLength = markerPosition + 1 < text.length ? 1 : 0;
+        const candidateStart = openingPosition - prefixLength;
+        const candidateEnd = markerPosition + 1 + suffixLength;
+        const candidate = text.slice(candidateStart, candidateEnd);
+        candidateRegex.lastIndex = 0;
+        const candidateMatch = candidateRegex.exec(candidate);
+        if (!candidateMatch) {
+            openingMarker = canOpen(text, markerPosition, currentMarker.isProtected) ? currentMarker : undefined;
+            continue;
+        }
+        candidateRegex.lastIndex = 0;
+        const replacedCandidate = replaceTextWithExtras(candidate, candidateRegex, EXTRAS_DEFAULT, replacement);
+        if (replacedCandidate !== candidate) {
+            const replacedCoreEnd = suffixLength ? replacedCandidate.length - suffixLength : replacedCandidate.length;
+            output.push(text.slice(outputStart, openingPosition));
+            output.push(replacedCandidate.slice(prefixLength, replacedCoreEnd));
+            outputStart = markerPosition + 1;
+            openingMarker = undefined;
+            continue;
+        }
+        openingMarker = undefined;
+    }
+    if (output.length === 0) {
+        return text;
+    }
+    output.push(text.slice(outputStart));
+    return output.join('');
+}
 /**
  * replace block element with '\n' if :
  * 1. We have text within the element.
@@ -509,7 +753,7 @@ class ExpensiMark {
                 name: 'autolink',
                 process: (textToProcess, replacement) => {
                     const regex = new RegExp(`(?![^<]*>|[^<>]*<\\/(?!h1>))([_*~]*?)${UrlPatterns.MARKDOWN_URL_REGEX}\\1(?!((?:(?!<a).)+)?<\\/a>|[^<]*(<\\/pre>|<\\/code>))`, 'gi');
-                    return this.modifyTextForUrlLinks(regex, textToProcess, replacement);
+                    return this.modifyTextForUrlLinks(regex, textToProcess, replacement, true);
                 },
                 replacement: (_extras, _match, g1, g2) => {
                     const href = Str.sanitizeURL(g2);
@@ -615,7 +859,7 @@ class ExpensiMark {
                 // \B will match everything that \b doesn't, so it works
                 // for * and ~: https://www.rexegg.com/regex-boundaries.html#notb
                 name: 'bold',
-                regex: /(?<!<[^>]*)(\b_|\B)\*(?!(?:<\/em))(?![^<]*(?:<\/pre>|<\/code>|<\/a>|<\/video>))((?![\s*])[\s\S]*?[^\s*](?<!\s))\*\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g,
+                process: (textToProcess, replacement) => replaceMarkdownCandidates(textToProcess, BOLD_MARKDOWN_REGEX, replacement, '*', canOpenBoldMarkdown),
                 replacement: (_extras, match, g1, g2) => {
                     if (g1.includes('_')) {
                         return `${g1}<strong>${g2}</strong>`;
@@ -625,7 +869,7 @@ class ExpensiMark {
             },
             {
                 name: 'strikethrough',
-                regex: /(?<!<[^>]*)\B~((?![\s~])[\s\S]*?[^\s~](?<!\s))~\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g,
+                process: (textToProcess, replacement) => replaceMarkdownCandidates(textToProcess, STRIKETHROUGH_MARKDOWN_REGEX, replacement, '~', canOpenStrikethroughMarkdown),
                 replacement: (_extras, match, g1) => (g1.includes('</pre>') || containsNonPairTag(g1) ? match : `<del>${g1}</del>`),
             },
             {
@@ -1073,7 +1317,25 @@ class ExpensiMark {
     /**
      * Checks matched URLs for validity and replace valid links with html elements
      */
-    modifyTextForUrlLinks(regex, textToCheck, replacement) {
+    modifyTextForUrlLinks(regex, textToCheck, replacement, shouldScanForUrls = false) {
+        if (shouldScanForUrls) {
+            const candidates = findUrlCandidates(textToCheck);
+            if (candidates.length === 0) {
+                return textToCheck;
+            }
+            const output = [];
+            const candidateRegex = regex;
+            let outputStart = 0;
+            for (const { start, end } of candidates) {
+                const candidate = textToCheck.slice(start, end);
+                candidateRegex.lastIndex = 0;
+                output.push(textToCheck.slice(outputStart, start));
+                output.push(this.modifyTextForUrlLinks(candidateRegex, candidate, replacement));
+                outputStart = end;
+            }
+            output.push(textToCheck.slice(outputStart));
+            return output.join('');
+        }
         let match = regex.exec(textToCheck);
         let replacedText = '';
         let startIndex = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expensify-common",
-  "version": "2.0.200",
+  "version": "2.0.201",
   "author": "Expensify, Inc.",
   "description": "Expensify libraries and components shared across different repos",
   "homepage": "https://expensify.com",