expensify-common 2.0.181 → 2.0.183

package/dist/ExpensiMark.js

@@ -54,6 +54,242 @@ const VICTORY_CHART_REGEX = /<VictoryChart\b[^>]*\/>|<VictoryChart\b[^>]*>[\s\S]
 const VICTORY_CHART_PLACEHOLDER_DELIMITER = String.fromCharCode(0);
 const VICTORY_CHART_PLACEHOLDER_PATTERN = new RegExp(`${VICTORY_CHART_PLACEHOLDER_DELIMITER}(\\d+)${VICTORY_CHART_PLACEHOLDER_DELIMITER}`, 'g');
 const createVictoryChartPlaceholder = (index) => `${VICTORY_CHART_PLACEHOLDER_DELIMITER}${index}${VICTORY_CHART_PLACEHOLDER_DELIMITER}`;
+function extractVictoryChartTags(text) {
+    const tags = [];
+    const out = text.replaceAll(VICTORY_CHART_REGEX, (match) => {
+        const placeholder = createVictoryChartPlaceholder(tags.length);
+        tags.push(match);
+        return placeholder;
+    });
+    return { text: out, tags };
+}
+function restoreVictoryChartTags(text, tags) {
+    if (tags.length === 0) {
+        return text;
+    }
+    return text.replaceAll(VICTORY_CHART_PLACEHOLDER_PATTERN, (match, idx) => { var _a; return (_a = tags[Number(idx)]) !== null && _a !== void 0 ? _a : match; });
+}
+function resolveAttributeCache(extras) {
+    var _a, _b;
+    if (!extras) {
+        return { attrCachingFn: undefined, attrCache: undefined };
+    }
+    return {
+        attrCachingFn: (_a = extras.mediaAttributeCachingFn) !== null && _a !== void 0 ? _a : extras.cacheVideoAttributes,
+        attrCache: (_b = extras.mediaAttributeCache) !== null && _b !== void 0 ? _b : extras.videoAttributeCache,
+    };
+}
+function replaceTextWithExtras(text, regexp, extras, replacement) {
+    if (typeof replacement === 'function') {
+        return text.replace(regexp, (...args) => replacement(extras, ...args));
+    }
+    return text.replace(regexp, replacement);
+}
+/**
+ * replace block element with '\n' if :
+ * 1. We have text within the element.
+ * 2. The text does not end with a new line.
+ * 3. It's not the last element in the string.
+ */
+function replaceBlockElementWithNewLine(htmlString) {
+    let splitText = htmlString
+        // Lines starting with quote mark '>' will have '\n' added to them so to avoid adding extra '\n', remove the block element right next to it
+        .replaceAll(/<blockquote>> (<div.*?>|<\/div>|<comment.*?>|\n<\/comment>|<\/comment>|<h1>|<\/h1>|<h2>|<\/h2>|<h3>|<\/h3>|<h4>|<\/h4>|<h5>|<\/h5>|<h6>|<\/h6>|<p>|<\/p>|<li>|<\/li>)/gi, '<blockquote>> ')
+        .split(/<div.*?>|<\/div>|<comment.*?>|\n<\/comment>|<\/comment>|<h1>|<\/h1>|<h2>|<\/h2>|<h3>|<\/h3>|<h4>|<\/h4>|<h5>|<\/h5>|<h6>|<\/h6>|<p>|<\/p>|<li>|<\/li>|<blockquote>|<\/blockquote>/);
+    const stripHTML = (text) => str_1.default.stripHTML(text);
+    splitText = splitText.map(stripHTML);
+    let joinedText = '';
+    // Delete whitespace at the end
+    while (splitText.length) {
+        if (splitText[splitText.length - 1].trim().length > 0 || splitText[splitText.length - 1].match(/\n/)) {
+            break;
+        }
+        splitText.pop();
+    }
+    const processText = (text, index) => {
+        if (text.trim().length === 0 && !text.match(/\n/)) {
+            return;
+        }
+        // Insert '\n' unless it ends with '\n' or it's the last element, or if it's a header ('# ') with a space.
+        if (text.match(/\n[\s]?$/) || index === splitText.length - 1 || text === '# ') {
+            joinedText += text;
+        }
+        else {
+            joinedText += `${text}\n`;
+        }
+    };
+    for (const [index, text] of splitText.entries()) {
+        processText(text, index);
+    }
+    return joinedText;
+}
+/** Check if the input text includes only the open or the close tag of an element. */
+function containsNonPairTag(textToCheck) {
+    // Create a regular expression to match HTML tags
+    const tagRegExp = /<([a-z][a-z0-9-]*)\b[^>]*>|<\/([a-z][a-z0-9-]*)\s*>/gi;
+    // Use a stack to keep track of opening tags
+    const tagStack = [];
+    // Match all HTML tags in the string
+    let match = tagRegExp.exec(textToCheck);
+    while (match) {
+        const openingTag = match[1];
+        const closingTag = match[2];
+        if (openingTag && openingTag !== 'br') {
+            // If it's an opening tag, push it onto the stack
+            tagStack.push(openingTag);
+        }
+        else if (closingTag) {
+            // If it's a closing tag, pop the top of the stack
+            const expectedTag = tagStack.pop();
+            // If the closing tag doesn't match the expected opening tag, return false
+            if (closingTag !== expectedTag) {
+                return true;
+            }
+        }
+        match = tagRegExp.exec(textToCheck);
+    }
+    // If there are any tags left in the stack, they're unclosed
+    return tagStack.length !== 0;
+}
+/**
+ * Determines the end position to truncate the HTML content while considering word boundaries.
+ */
+function getEndPosition(content, tailPosition, maxLength, totalLength, opts) {
+    const WORD_BREAK_REGEX = /\W+/g;
+    const defaultPosition = maxLength - totalLength;
+    const slop = opts.slop;
+    if (!slop) {
+        return defaultPosition;
+    }
+    let position = defaultPosition;
+    const isShort = defaultPosition < slop;
+    const slopPos = isShort ? defaultPosition : slop - 1;
+    const substr = content.slice(isShort ? 0 : defaultPosition - slop, tailPosition !== undefined ? tailPosition : defaultPosition + slop);
+    const wordBreakMatch = WORD_BREAK_REGEX.exec(substr);
+    if (!opts.truncateLastWord) {
+        if (tailPosition && substr.length <= tailPosition) {
+            position = substr.length;
+        }
+        else {
+            while (wordBreakMatch !== null) {
+                if (wordBreakMatch.index < slopPos) {
+                    position = defaultPosition - (slopPos - wordBreakMatch.index);
+                    if (wordBreakMatch.index === 0 && defaultPosition <= 1) {
+                        break;
+                    }
+                }
+                else if (wordBreakMatch.index === slopPos) {
+                    position = defaultPosition;
+                    break;
+                }
+                else {
+                    position = defaultPosition + (wordBreakMatch.index - slopPos);
+                    break;
+                }
+            }
+        }
+        if (content.charAt(position - 1).match(/\s$/)) {
+            position--;
+        }
+    }
+    return position;
+}
+/**
+ * Truncate HTML string and keep tag safe.
+ * pulled from https://github.com/huang47/nodejs-html-truncate/blob/master/lib/truncate.js
+ */
+function truncateHTML(html, maxLength, options) {
+    const EMPTY_STRING = '';
+    const DEFAULT_TRUNCATE_SYMBOL = '...';
+    const DEFAULT_SLOP = Math.min(10, maxLength);
+    const tagsStack = [];
+    const KEY_VALUE_REGEX = '((?:\\s+(?:\\w+|-)+(?:\\s*=\\s*(?:"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|[^\'">\\s]+))?)*)';
+    const IS_CLOSE_REGEX = '\\s*\\/?\\s*';
+    const CLOSE_REGEX = '\\s*\\/\\s*';
+    const SELF_CLOSE_REGEX = new RegExp(`<\\/?(\\w+)${KEY_VALUE_REGEX}${CLOSE_REGEX}>`);
+    const HTML_TAG_REGEX = new RegExp(`<\\/?(\\w+)${KEY_VALUE_REGEX}${IS_CLOSE_REGEX}>`);
+    const URL_REGEX = /(((ftp|https?):\/\/)[\\-\w@:%_\\+.~#?,&\\/\\/=]+)|((mailto:)?[_.\w\\-]+@([\w][\w\\-]+\.)+[a-zA-Z]{2,3})/g;
+    const IMAGE_TAG_REGEX = new RegExp(`<img\\s*${KEY_VALUE_REGEX}${CLOSE_REGEX}>`);
+    let truncatedContent = EMPTY_STRING;
+    let totalLength = 0;
+    let matches = HTML_TAG_REGEX.exec(html);
+    let endResult;
+    let index;
+    let tag;
+    let selfClose = null;
+    let htmlString = html;
+    const opts = Object.assign({ ellipsis: DEFAULT_TRUNCATE_SYMBOL, truncateLastWord: true, slop: DEFAULT_SLOP }, options);
+    function removeImageTag(content) {
+        const match = IMAGE_TAG_REGEX.exec(content);
+        if (!match) {
+            return content;
+        }
+        const matchIndex = match.index;
+        const matchLength = match[0].length;
+        return content.substring(0, matchIndex) + content.substring(matchIndex + matchLength);
+    }
+    function closeTags(tags) {
+        return tags
+            .reverse()
+            .map((mappedTag) => `</${mappedTag}>`)
+            .join('');
+    }
+    while (matches) {
+        matches = HTML_TAG_REGEX.exec(htmlString);
+        if (!matches) {
+            if (totalLength >= maxLength) {
+                break;
+            }
+            matches = URL_REGEX.exec(htmlString);
+            if (!matches || matches.index >= maxLength) {
+                truncatedContent += htmlString.substring(0, getEndPosition(htmlString, undefined, maxLength, totalLength, opts));
+                break;
+            }
+            while (matches) {
+                endResult = matches[0];
+                if (endResult !== null) {
+                    index = matches.index;
+                    const truncateEnd = index + endResult.length;
+                    truncatedContent += htmlString.substring(0, truncateEnd - totalLength);
+                    htmlString = htmlString.substring(index + endResult.length);
+                    matches = URL_REGEX.exec(htmlString);
+                }
+            }
+            break;
+        }
+        endResult = matches[0];
+        index = matches.index;
+        if (totalLength + index > maxLength) {
+            truncatedContent += htmlString.substring(0, getEndPosition(htmlString, index, maxLength, totalLength, opts));
+            break;
+        }
+        else {
+            totalLength += index;
+            truncatedContent += htmlString.substring(0, index);
+        }
+        if (endResult[1] === '/') {
+            tagsStack.pop();
+            selfClose = null;
+        }
+        else {
+            selfClose = SELF_CLOSE_REGEX.exec(endResult);
+            if (!selfClose) {
+                tag = matches[1];
+                tagsStack.push(tag);
+            }
+        }
+        truncatedContent += selfClose ? selfClose[0] : endResult;
+        htmlString = htmlString.substring(index + endResult.length);
+    }
+    if (htmlString.length > maxLength - totalLength && opts.ellipsis) {
+        truncatedContent += opts.ellipsis ? '...' : '';
+    }
+    truncatedContent += closeTags(tagsStack);
+    if (opts.removeImageTag) {
+        truncatedContent = removeImageTag(truncatedContent);
+    }
+    return truncatedContent;
+}
 class ExpensiMark {
     /**
      * Set the logger to use for logging inside of the ExpensiMark class
@@ -63,35 +299,14 @@ class ExpensiMark {
         ExpensiMark.Log = logger;
     }
     constructor() {
-        this.extractVictoryChartTags = (text) => {
-            const tags = [];
-            const out = text.replace(VICTORY_CHART_REGEX, (match) => {
-                const placeholder = createVictoryChartPlaceholder(tags.length);
-                tags.push(match);
-                return placeholder;
-            });
-            return { text: out, tags };
-        };
-        this.restoreVictoryChartTags = (text, tags) => {
-            if (tags.length === 0) {
-                return text;
-            }
-            return text.replace(VICTORY_CHART_PLACEHOLDER_PATTERN, (match, idx) => { var _a; return (_a = tags[Number(idx)]) !== null && _a !== void 0 ? _a : match; });
-        };
-        this.getAttributeCache = (extras) => {
-            var _a, _b;
-            if (!extras) {
-                return { attrCachingFn: undefined, attrCache: undefined };
-            }
-            return {
-                attrCachingFn: (_a = extras.mediaAttributeCachingFn) !== null && _a !== void 0 ? _a : extras.cacheVideoAttributes,
-                attrCache: (_b = extras.mediaAttributeCache) !== null && _b !== void 0 ? _b : extras.videoAttributeCache,
-            };
-        };
         /**
          * The list of rules that we have to exclude in shouldKeepWhitespaceRules list.
          */
         this.whitespaceRulesToDisable = ['newline', 'replacepre', 'replacebr', 'replaceh1br'];
+        this.getAttributeCache = resolveAttributeCache;
+        this.replaceBlockElementWithNewLine = replaceBlockElementWithNewLine;
+        this.containsNonPairTag = containsNonPairTag;
+        this.truncateHTML = truncateHTML;
         /**
          * The list of regex replacements to do on a comment. Check the link regex is first so links are processed
          * before other delimiters
@@ -118,11 +333,11 @@ class ExpensiMark {
                 // want to do this anywhere else since that would break HTML.
                 // &nbsp; will create styling issues so use &#32;
                 replacement: (_extras, _match, _g1, _g2, textWithinFences) => {
-                    const group = textWithinFences.replace(/(?:(?![\n\r])\s)/g, '&#32;');
+                    const group = textWithinFences.replaceAll(/(?:(?![\n\r])\s)/g, '&#32;');
                     return `<pre>${group}</pre>`;
                 },
                 rawInputReplacement: (_extras, _match, _g1, newLineCharacter, textWithinFences) => {
-                    const group = textWithinFences.replace(/(?:(?![\n\r])\s)/g, '&#32;').replace(/<emoji>|<\/emoji>/g, '');
+                    const group = textWithinFences.replaceAll(/(?:(?![\n\r])\s)/g, '&#32;').replaceAll(/<emoji>|<\/emoji>/g, '');
                     return `<pre>${newLineCharacter}${group}</pre>`;
                 },
             },
@@ -141,12 +356,12 @@ class ExpensiMark {
                  * @return Returns the HTML video tag
                  */
                 replacement: (extras, _match, videoName, videoSource) => {
-                    const attrCache = this.getAttributeCache(extras).attrCache;
+                    const attrCache = resolveAttributeCache(extras).attrCache;
                     const extraAttrs = attrCache && attrCache[videoSource];
                     return `<video data-expensify-source="${str_1.default.sanitizeURL(videoSource)}" ${extraAttrs || ''}>${videoName ? `${videoName}` : ''}</video>`;
                 },
                 rawInputReplacement: (extras, _match, videoName, videoSource) => {
-                    const attrCache = this.getAttributeCache(extras).attrCache;
+                    const attrCache = resolveAttributeCache(extras).attrCache;
                     const extraAttrs = attrCache && attrCache[videoSource];
                     return `<video data-expensify-source="${str_1.default.sanitizeURL(videoSource)}" data-raw-href="${videoSource}" data-link-variant="${typeof videoName === 'string' ? 'labeled' : 'auto'}" ${extraAttrs || ''}>${videoName ? `${videoName}` : ''}</video>`;
                 },
@@ -210,7 +425,7 @@ class ExpensiMark {
                 name: 'heading1',
                 process: (textToProcess, replacement, shouldKeepRawInput = false) => {
                     const regexp = shouldKeepRawInput ? /^# ( *(?! )(?:(?!<pre>|<video>|\n|\r\n).)+)/gm : /^# +(?! )((?:(?!<pre>|<video>|\n|\r\n).)+)/gm;
-                    return this.replaceTextWithExtras(textToProcess, regexp, EXTRAS_DEFAULT, replacement);
+                    return replaceTextWithExtras(textToProcess, regexp, EXTRAS_DEFAULT, replacement);
                 },
                 replacement: '<h1>$1</h1>',
             },
@@ -226,18 +441,16 @@ class ExpensiMark {
                 name: 'image',
                 regex: MARKDOWN_IMAGE_REGEX,
                 replacement: (extras, _match, imgAlt, imgSource) => {
-                    const attrCache = this.getAttributeCache(extras).attrCache;
+                    const attrCache = resolveAttributeCache(extras).attrCache;
                     const extraAttrs = attrCache && attrCache[imgSource];
                     return `<img src="${str_1.default.sanitizeURL(imgSource)}"${imgAlt ? ` alt="${this.escapeAttributeContent(imgAlt)}"` : ''} ${extraAttrs || ''}/>`;
                 },
                 rawInputReplacement: (extras, _match, imgAlt, imgSource) => {
-                    const attrCache = this.getAttributeCache(extras).attrCache;
+                    const attrCache = resolveAttributeCache(extras).attrCache;
                     const extraAttrs = attrCache && attrCache[imgSource];
                     return `<img src="${str_1.default.sanitizeURL(imgSource)}"${imgAlt ? ` alt="${this.escapeAttributeContent(imgAlt)}"` : ''} data-raw-href="${imgSource}" data-link-variant="${typeof imgAlt === 'string' ? 'labeled' : 'auto'}" ${extraAttrs || ''}/>`;
                 },
-                shouldSkipProcessing: (textToCheck) => {
-                    return !textToCheck.includes('!') || !textToCheck.includes('(') || !textToCheck.includes(')');
-                },
+                shouldSkipProcessing: (textToCheck) => !textToCheck.includes('!') || !textToCheck.includes('(') || !textToCheck.includes(')'),
             },
             /**
              * Converts markdown style links to anchor tags e.g. [Expensify](https://www.expensify.com)
@@ -259,9 +472,7 @@ class ExpensiMark {
                     }
                     return `<a href="${str_1.default.sanitizeURL(g2)}" data-raw-href="${g2}" data-link-variant="labeled" target="_blank" rel="noreferrer noopener">${g1}</a>`;
                 },
-                shouldSkipProcessing: (textToCheck) => {
-                    return !textToCheck.includes('.');
-                },
+                shouldSkipProcessing: (textToCheck) => !textToCheck.includes('.'),
             },
             /**
              * Apply the hereMention first because the string @here is still a valid mention for the userMention regex.
@@ -346,9 +557,7 @@ class ExpensiMark {
                     const href = str_1.default.sanitizeURL(g2);
                     return `${g1}<a href="${href}" data-raw-href="${g2}" data-link-variant="auto" target="_blank" rel="noreferrer noopener">${g2}</a>${g1}`;
                 },
-                shouldSkipProcessing: (textToCheck) => {
-                    return !textToCheck.includes('.');
-                },
+                shouldSkipProcessing: (textToCheck) => !textToCheck.includes('.'),
             },
             {
                 name: 'quote',
@@ -357,7 +566,7 @@ class ExpensiMark {
                 // inline code blocks. A single prepending space should be stripped if it exists
                 process: (textToProcess, replacement, shouldKeepRawInput = false) => {
                     const regex = /^(?:&gt;|>)+ +(?! )(?![^<]*(?:<\/pre>|<\/code>|<\/video>))([^\v\n\r]*)/gm;
-                    let replacedText = this.replaceTextWithExtras(textToProcess, regex, EXTRAS_DEFAULT, replacement);
+                    let replacedText = replaceTextWithExtras(textToProcess, regex, EXTRAS_DEFAULT, replacement);
                     if (shouldKeepRawInput) {
                         return replacedText;
                     }
@@ -390,7 +599,7 @@ class ExpensiMark {
                         return html;
                     }
                     // If any tags are included inside underscores, ignore it. ie. _abc <pre>pre tag</pre> abc_
-                    if (textWithinUnderscores.includes('</pre>') || this.containsNonPairTag(textWithinUnderscores)) {
+                    if (textWithinUnderscores.includes('</pre>') || containsNonPairTag(textWithinUnderscores)) {
                         return match;
                     }
                     if (String(textWithinUnderscores).match(`^${Constants.CONST.REG_EXP.MARKDOWN_EMAIL}`)) {
@@ -449,13 +658,13 @@ class ExpensiMark {
                     if (g1.includes('_')) {
                         return `${g1}<strong>${g2}</strong>`;
                     }
-                    return g2.includes('</pre>') || this.containsNonPairTag(g2) ? match : `<strong>${g2}</strong>`;
+                    return g2.includes('</pre>') || containsNonPairTag(g2) ? match : `<strong>${g2}</strong>`;
                 },
             },
             {
                 name: 'strikethrough',
                 regex: /(?<!<[^>]*)\B~((?![\s~])[\s\S]*?[^\s~](?<!\s))~\B(?![^<]*>)(?![^<]*(<\/pre>|<\/code>|<\/a>|<\/video>))/g,
-                replacement: (_extras, match, g1) => (g1.includes('</pre>') || this.containsNonPairTag(g1) ? match : `<del>${g1}</del>`),
+                replacement: (_extras, match, g1) => (g1.includes('</pre>') || containsNonPairTag(g1) ? match : `<del>${g1}</del>`),
             },
             {
                 name: 'newline',
@@ -503,7 +712,7 @@ class ExpensiMark {
                 pre: (inputString) => inputString
                     .replace('<br></br>', '<br/>')
                     .replace('<br><br/>', '<br/>')
-                    .replace(/(<tr.*?<\/tr>)/g, '$1<br/>')
+                    .replaceAll(/(<tr.*?<\/tr>)/g, '$1<br/>')
                     .replace('<br/></tbody>', '')
                     .replace(SLACK_SPAN_NEW_LINE_TAG + SLACK_SPAN_NEW_LINE_TAG, '<br/><br/><br/>')
                     .replace(SLACK_SPAN_NEW_LINE_TAG, '<br/><br/>'),
@@ -533,7 +742,11 @@ class ExpensiMark {
                 replacement: (extras, match, tagName, innerContent) => {
                     // To check if style attribute contains bold font-weight
                     const isBoldFromStyle = (style) => {
-                        return style ? style.replace(/\s/g, '').includes('font-weight:bold;') || style.replace(/\s/g, '').includes('font-weight:700;') : false;
+                        if (!style) {
+                            return false;
+                        }
+                        const normalizedStyle = style.replaceAll(/\s/g, '');
+                        return normalizedStyle.includes('font-weight:bold;') || normalizedStyle.includes('font-weight:700;');
                     };
                     const updateSpacesAndWrapWithAsterisksIfBold = (content, isBold) => {
                         const trimmedContent = content.trim();
@@ -547,7 +760,7 @@ class ExpensiMark {
                     const isFontWeightBold = isBoldFromStyle(styleAttributeMatch ? styleAttributeMatch[1] : null);
                     const isBold = styleAttributeMatch ? isFontWeightBold : tagName === 'b' || tagName === 'strong';
                     // Process nested spans with potential bold style
-                    const processedInnerContent = innerContent.replace(/<span(?:"[^"]*"|'[^']*'|[^'">])*>([\s\S]*?)<\/span>/gi, (nestedMatch, nestedContent) => {
+                    const processedInnerContent = innerContent.replaceAll(/<span(?:"[^"]*"|'[^']*'|[^'">])*>([\s\S]*?)<\/span>/gi, (nestedMatch, nestedContent) => {
                         const nestedStyleMatch = nestedMatch.match(fontWeightRegex);
                         const isNestedBold = isBoldFromStyle(nestedStyleMatch ? nestedStyleMatch[1] : null);
                         return updateSpacesAndWrapWithAsterisksIfBold(nestedContent, isNestedBold);
@@ -566,15 +779,13 @@ class ExpensiMark {
                 replacement: (_extras, _match, _g1, g2) => {
                     // We remove the line break before heading inside quote to avoid adding extra line
                     let resultString = g2
-                        .replace(/\n?(<h1># )/g, '$1')
-                        .replace(/(<h1>|<\/h1>)+/g, '\n')
+                        .replaceAll(/\n?(<h1># )/g, '$1')
+                        .replaceAll(/(<h1>|<\/h1>)+/g, '\n')
                         // Replace trim() with manually removing line breaks at the beginning and end of the string to avoid adding extra lines
-                        .replace(/^(\n)+|(\n)+$/g, '')
+                        .replaceAll(/^(\n)+|(\n)+$/g, '')
                         .split('\n');
                     // Wrap each string in the array with <blockquote> and </blockquote>
-                    resultString = resultString.map((line) => {
-                        return `<blockquote>${line}</blockquote>`;
-                    });
+                    resultString = resultString.map((line) => `<blockquote>${line}</blockquote>`);
                     resultString = resultString
                         .map((text) => {
                         let modifiedText = text;
@@ -583,8 +794,8 @@ class ExpensiMark {
                             depth = (modifiedText.match(/<blockquote>/gi) || []).length;
                             // Need (\s)? because the server usually sends a space character after <blockquote> so we need to consume it,
                             // avoid being redundant because it is added in the return part
-                            modifiedText = modifiedText.replace(/<blockquote>(\s)?/gi, '');
-                            modifiedText = modifiedText.replace(/<\/blockquote>/gi, '');
+                            modifiedText = modifiedText.replaceAll(/<blockquote>(\s)?/gi, '');
+                            modifiedText = modifiedText.replaceAll(/<\/blockquote>/gi, '');
                         } while (/<blockquote>/i.test(modifiedText));
                         return `${'>'.repeat(depth)} ${modifiedText}`;
                     })
@@ -630,7 +841,7 @@ class ExpensiMark {
                     let altText = '';
                     const altRegex = /alt\s*=\s*(['"])(.*?)\1/i;
                     const altMatch = imgAttrs.match(altRegex);
-                    const attrCachingFn = this.getAttributeCache(extras).attrCachingFn;
+                    const attrCachingFn = resolveAttributeCache(extras).attrCachingFn;
                     let attributes = imgAttrs;
                     if (altMatch) {
                         altText = altMatch[2];
@@ -663,7 +874,7 @@ class ExpensiMark {
                  * @returns The markdown video tag
                  */
                 replacement: (extras, _match, _g1, videoSource, videoAttrs, videoName) => {
-                    const attrCachingFn = this.getAttributeCache(extras).attrCachingFn;
+                    const attrCachingFn = resolveAttributeCache(extras).attrCachingFn;
                     if (videoAttrs && attrCachingFn && typeof attrCachingFn === 'function') {
                         attrCachingFn(videoSource, videoAttrs);
                     }
@@ -676,10 +887,12 @@ class ExpensiMark {
             {
                 name: 'reportMentions',
                 regex: /<mention-report reportID="?(\d+)"?(?: *\/>|><\/mention-report>)/gi,
-                replacement: (extras, _match, g1, _offset, _string) => {
+                replacement: (extras, _match, g1) => {
                     const reportToNameMap = extras.reportIDToName;
                     if (!reportToNameMap || !reportToNameMap[g1]) {
-                        ExpensiMark.Log.alert('[ExpensiMark] Missing report name', { reportID: g1 });
+                        ExpensiMark.Log.alert('[ExpensiMark] Missing report name', {
+                            reportID: g1,
+                        });
                         return '#Hidden';
                     }
                     return reportToNameMap[g1];
@@ -688,12 +901,14 @@ class ExpensiMark {
             {
                 name: 'userMention',
                 regex: /(?:<mention-user accountID="?(\d+)"?(?: *\/>|><\/mention-user>))|(?:<mention-user>(.*?)<\/mention-user>)/gi,
-                replacement: (extras, _match, g1, g2, _offset, _string) => {
+                replacement: (extras, _match, g1, g2) => {
                     var _a, _b;
                     if (g1) {
                         const accountToNameMap = extras.accountIDToName;
                         if (!accountToNameMap || !accountToNameMap[g1]) {
-                            ExpensiMark.Log.alert('[ExpensiMark] Missing account name', { accountID: g1 });
+                            ExpensiMark.Log.alert('[ExpensiMark] Missing account name', {
+                                accountID: g1,
+                            });
                             return '@Hidden';
                         }
                         return `@${str_1.default.removeSMSDomain((_b = (_a = extras.accountIDToName) === null || _a === void 0 ? void 0 : _a[g1]) !== null && _b !== void 0 ? _b : '')}`;
@@ -760,10 +975,12 @@ class ExpensiMark {
             {
                 name: 'reportMentions',
                 regex: /<mention-report reportID="?(\d+)"?(?: *\/>|><\/mention-report>)/gi,
-                replacement: (extras, _match, g1, _offset, _string) => {
+                replacement: (extras, _match, g1) => {
                     const reportToNameMap = extras.reportIDToName;
                     if (!reportToNameMap || !reportToNameMap[g1]) {
-                        ExpensiMark.Log.alert('[ExpensiMark] Missing report name', { reportID: g1 });
+                        ExpensiMark.Log.alert('[ExpensiMark] Missing report name', {
+                            reportID: g1,
+                        });
                         return '#Hidden';
                     }
                     return reportToNameMap[g1];
@@ -772,12 +989,14 @@ class ExpensiMark {
             {
                 name: 'userMention',
                 regex: /(?:<mention-user accountID="?(\d+)"?(?: *\/>|><\/mention-user>))|(?:<mention-user>(.*?)<\/mention-user>)/gi,
-                replacement: (extras, _match, g1, g2, _offset, _string) => {
+                replacement: (extras, _match, g1, g2) => {
                     var _a, _b;
                     if (g1) {
                         const accountToNameMap = extras.accountIDToName;
                         if (!accountToNameMap || !accountToNameMap[g1]) {
-                            ExpensiMark.Log.alert('[ExpensiMark] Missing account name', { accountID: g1 });
+                            ExpensiMark.Log.alert('[ExpensiMark] Missing account name', {
+                                accountID: g1,
+                            });
                             return '@Hidden';
                         }
                         return `@${str_1.default.removeSMSDomain((_b = (_a = extras.accountIDToName) === null || _a === void 0 ? void 0 : _a[g1]) !== null && _b !== void 0 ? _b : '')}`;
@@ -853,7 +1072,7 @@ class ExpensiMark {
         }
         // Extract VictoryChart blocks to preserve their markup during processing.
         // Only safe for trusted server input - user input must be escaped to prevent XSS.
-        const { text: textWithPlaceholders, tags: victoryChartTags } = shouldEscapeText ? { text, tags: [] } : this.extractVictoryChartTags(text);
+        const { text: textWithPlaceholders, tags: victoryChartTags } = shouldEscapeText ? { text, tags: [] } : extractVictoryChartTags(text);
         // This ensures that any html the user puts into the comment field shows as raw html
         let replacedText = shouldEscapeText ? Utils.escapeText(textWithPlaceholders) : textWithPlaceholders;
         const rules = this.getHtmlRuleset(filterRules, disabledRules, shouldKeepRawInput);
@@ -870,7 +1089,7 @@ class ExpensiMark {
                 replacedText = rule.process(replacedText, replacement, shouldKeepRawInput);
             }
             else {
-                replacedText = this.replaceTextWithExtras(replacedText, rule.regex, extras, replacement);
+                replacedText = replaceTextWithExtras(replacedText, rule.regex, extras, replacement);
             }
             // Post-process text after applying regex
             if (rule.post) {
@@ -878,14 +1097,16 @@ class ExpensiMark {
             }
         };
         try {
-            rules.forEach(processRule);
+            for (const rule of rules) {
+                processRule(rule);
+            }
         }
         catch (e) {
             ExpensiMark.Log.alert('Error replacing text with html in ExpensiMark.replace', { error: e });
             // We want to return text without applying rules if exception occurs during replacing
             return shouldEscapeText ? Utils.escapeText(text) : text;
         }
-        return this.restoreVictoryChartTags(replacedText, victoryChartTags);
+        return restoreVictoryChartTags(replacedText, victoryChartTags);
     }
     /**
      * Checks matched URLs for validity and replace valid links with html elements
@@ -1003,7 +1224,10 @@ class ExpensiMark {
             startIndex = match.index + match[0].length;
             // Line breaks (`\n`) followed by empty contents are already removed
             // but line breaks inside contents should be parsed to <br/> to skip `autoEmail` rule
-            replacedText = this.replace(replacedText, { filterRules: ['newline'], shouldEscapeText: false });
+            replacedText = this.replace(replacedText, {
+                filterRules: ['newline'],
+                shouldEscapeText: false,
+            });
             // Now we move to the next match that the js regex found in the text
             match = regex.exec(textToCheck);
         }
@@ -1012,43 +1236,6 @@ class ExpensiMark {
         }
         return replacedText;
     }
-    /**
-     * replace block element with '\n' if :
-     * 1. We have text within the element.
-     * 2. The text does not end with a new line.
-     * 3. It's not the last element in the string.
-     */
-    replaceBlockElementWithNewLine(htmlString) {
-        // eslint-disable-next-line max-len
-        let splitText = htmlString
-            // Lines starting with quote mark '>' will have '\n' added to them so to avoid adding extra '\n', remove the block element right next to it
-            .replaceAll(/<blockquote>> (<div.*?>|<\/div>|<comment.*?>|\n<\/comment>|<\/comment>|<h1>|<\/h1>|<h2>|<\/h2>|<h3>|<\/h3>|<h4>|<\/h4>|<h5>|<\/h5>|<h6>|<\/h6>|<p>|<\/p>|<li>|<\/li>)/gi, '<blockquote>> ')
-            .split(/<div.*?>|<\/div>|<comment.*?>|\n<\/comment>|<\/comment>|<h1>|<\/h1>|<h2>|<\/h2>|<h3>|<\/h3>|<h4>|<\/h4>|<h5>|<\/h5>|<h6>|<\/h6>|<p>|<\/p>|<li>|<\/li>|<blockquote>|<\/blockquote>/);
-        const stripHTML = (text) => str_1.default.stripHTML(text);
-        splitText = splitText.map(stripHTML);
-        let joinedText = '';
-        // Delete whitespace at the end
-        while (splitText.length) {
-            if (splitText[splitText.length - 1].trim().length > 0 || splitText[splitText.length - 1].match(/\n/)) {
-                break;
-            }
-            splitText.pop();
-        }
-        const processText = (text, index) => {
-            if (text.trim().length === 0 && !text.match(/\n/)) {
-                return;
-            }
-            // Insert '\n' unless it ends with '\n' or it's the last element, or if it's a header ('# ') with a space.
-            if (text.match(/\n[\s]?$/) || index === splitText.length - 1 || text === '# ') {
-                joinedText += text;
-            }
-            else {
-                joinedText += `${text}\n`;
-            }
-        };
-        splitText.forEach(processText);
-        return joinedText;
-    }
     /**
      * Unpacks nested quote HTML tags that have been packed by the 'quote' rule in this.rules for shouldKeepRawInput = false
      *
@@ -1069,10 +1256,8 @@ class ExpensiMark {
      * Note that there will always be only a single closing tag, even if multiple opening tags exist.
      * Only one closing tag is needed to detect if a nested quote has ended.
      */
-    unpackNestedQuotes(text) {
-        let parsedText = text.replace(/((<\/blockquote>)+(<br \/>)?)|(<br \/>)/g, (match) => {
-            return `${match}</split>`;
-        });
+    static unpackNestedQuotes(text) {
+        let parsedText = text.replaceAll(/((<\/blockquote>)+(<br \/>)?)|(<br \/>)/g, (match) => `${match}</split>`);
         const splittedText = parsedText.split('</split>');
         if (splittedText.length > 0 && splittedText[splittedText.length - 1] === '') {
             splittedText.pop();
@@ -1084,7 +1269,7 @@ class ExpensiMark {
             if (line === '' && count === 0) {
                 return '';
             }
-            const textLine = line.replace(/(<br \/>)$/g, '');
+            const textLine = line.replaceAll(/(<br \/>)$/g, '');
             if (textLine.startsWith('<blockquote>')) {
                 count += (textLine.match(/<blockquote>/g) || []).length;
             }
@@ -1116,20 +1301,22 @@ class ExpensiMark {
         if (parseBodyTag) {
             generatedMarkdown = parseBodyTag[2];
         }
-        generatedMarkdown = this.unpackNestedQuotes(generatedMarkdown);
+        generatedMarkdown = ExpensiMark.unpackNestedQuotes(generatedMarkdown);
         // Extract VictoryChart blocks before HTML stripping, then restore them.
-        const { text: textWithPlaceholders, tags: victoryChartTags } = this.extractVictoryChartTags(generatedMarkdown);
+        const { text: textWithPlaceholders, tags: victoryChartTags } = extractVictoryChartTags(generatedMarkdown);
         generatedMarkdown = textWithPlaceholders;
         const processRule = (rule) => {
             // Pre-processes input HTML before applying regex
             if (rule.pre) {
                 generatedMarkdown = rule.pre(generatedMarkdown);
             }
-            generatedMarkdown = this.replaceTextWithExtras(generatedMarkdown, rule.regex, extras, rule.replacement);
+            generatedMarkdown = replaceTextWithExtras(generatedMarkdown, rule.regex, extras, rule.replacement);
         };
-        this.htmlToMarkdownRules.forEach(processRule);
-        const decoded = str_1.default.htmlDecode(this.replaceBlockElementWithNewLine(generatedMarkdown));
-        return this.restoreVictoryChartTags(decoded, victoryChartTags);
+        for (const rule of this.htmlToMarkdownRules) {
+            processRule(rule);
+        }
+        const decoded = str_1.default.htmlDecode(replaceBlockElementWithNewLine(generatedMarkdown));
+        return restoreVictoryChartTags(decoded, victoryChartTags);
     }
     /**
      * Convert HTML to text
@@ -1137,9 +1324,11 @@ class ExpensiMark {
     htmlToText(htmlString, extras = EXTRAS_DEFAULT) {
         let replacedText = htmlString;
         const processRule = (rule) => {
-            replacedText = this.replaceTextWithExtras(replacedText, rule.regex, extras, rule.replacement);
+            replacedText = replaceTextWithExtras(replacedText, rule.regex, extras, rule.replacement);
         };
-        this.htmlToTextRules.forEach(processRule);
+        for (const rule of this.htmlToTextRules) {
+            processRule(rule);
+        }
         // Unescaping because the text is escaped in 'replace' function
         // We use 'htmlDecode' instead of 'unescape' to replace entities like '&#32;'
         replacedText = str_1.default.htmlDecode(replacedText);
@@ -1156,7 +1345,7 @@ class ExpensiMark {
             isStartingWithSpace = !!g2;
             return '';
         };
-        const textToReplace = text.replace(/^(?:&gt;|>)( )?/gm, handleMatch);
+        const textToReplace = text.replaceAll(/^(?:&gt;|>)( )?/gm, handleMatch);
         const filterRules = ['heading1'];
         // If we don't reach the max quote depth, we allow the recursive call to process other possible quotes
         if (this.currentQuoteDepth < this.maxQuoteDepth - 1 && !isStartingWithSpace) {
@@ -1171,36 +1360,6 @@ class ExpensiMark {
         this.currentQuoteDepth = 0;
         return { replacedText, shouldAddSpace: isStartingWithSpace };
     }
-    /**
-     * Check if the input text includes only the open or the close tag of an element.
-     */
-    containsNonPairTag(textToCheck) {
-        // Create a regular expression to match HTML tags
-        const tagRegExp = /<([a-z][a-z0-9-]*)\b[^>]*>|<\/([a-z][a-z0-9-]*)\s*>/gi;
-        // Use a stack to keep track of opening tags
-        const tagStack = [];
-        // Match all HTML tags in the string
-        let match = tagRegExp.exec(textToCheck);
-        while (match) {
-            const openingTag = match[1];
-            const closingTag = match[2];
-            if (openingTag && openingTag !== 'br') {
-                // If it's an opening tag, push it onto the stack
-                tagStack.push(openingTag);
-            }
-            else if (closingTag) {
-                // If it's a closing tag, pop the top of the stack
-                const expectedTag = tagStack.pop();
-                // If the closing tag doesn't match the expected opening tag, return false
-                if (closingTag !== expectedTag) {
-                    return true;
-                }
-            }
-            match = tagRegExp.exec(textToCheck);
-        }
-        // If there are any tags left in the stack, they're unclosed
-        return tagStack.length !== 0;
-    }
     /**
      * @returns array or undefined if exception occurs when executing regex matching
      */
@@ -1243,187 +1402,6 @@ class ExpensiMark {
         originalContent = str_1.default.replaceAll(originalContent, '\n', '');
         return Utils.escapeText(originalContent);
     }
-    /**
-     * Determines the end position to truncate the HTML content while considering word boundaries.
-     *
-     * @param {string} content - The HTML content to be truncated.
-     * @param {number} tailPosition - The position up to which the content should be considered.
-     * @param {number} maxLength - The maximum length of the truncated content.
-     * @param {number} totalLength - The length of the content processed so far.
-     * @param {Object} opts - Options to customize the truncation.
-     * @returns {number} The calculated position to truncate the content.
-     */
-    getEndPosition(content, tailPosition, maxLength, totalLength, opts) {
-        const WORD_BREAK_REGEX = /\W+/g;
-        // Calculate the default position to truncate based on the maximum length and the length of the content processed so far
-        const defaultPosition = maxLength - totalLength;
-        // Define the slop value, which determines the tolerance for cutting off content near the maximum length
-        const slop = opts.slop;
-        if (!slop)
-            return defaultPosition;
-        // Initialize the position to the default position
-        let position = defaultPosition;
-        // Determine if the default position is considered "short" based on the slop value
-        const isShort = defaultPosition < slop;
-        // Calculate the position within the slop range
-        const slopPos = isShort ? defaultPosition : slop - 1;
-        // Extract the substring to analyze for word boundaries, considering the slop and tail position
-        const substr = content.slice(isShort ? 0 : defaultPosition - slop, tailPosition !== undefined ? tailPosition : defaultPosition + slop);
-        // Find the first word boundary within the substring
-        const wordBreakMatch = WORD_BREAK_REGEX.exec(substr);
-        // Adjust the position to avoid truncating in the middle of a word if the option is enabled
-        if (!opts.truncateLastWord) {
-            if (tailPosition && substr.length <= tailPosition) {
-                // If tail position is defined and the substring length is within the tail position, set position to the substring length
-                position = substr.length;
-            }
-            else {
-                // Iterate through word boundary matches to adjust the position
-                while (wordBreakMatch !== null) {
-                    if (wordBreakMatch.index < slopPos) {
-                        // If the word boundary is before the slop position, adjust position backward
-                        position = defaultPosition - (slopPos - wordBreakMatch.index);
-                        if (wordBreakMatch.index === 0 && defaultPosition <= 1) {
-                            break;
-                        }
-                    }
-                    else if (wordBreakMatch.index === slopPos) {
-                        // If the word boundary is at the slop position, set position to the default position
-                        position = defaultPosition;
-                        break;
-                    }
-                    else {
-                        // If the word boundary is after the slop position, adjust position forward
-                        position = defaultPosition + (wordBreakMatch.index - slopPos);
-                        break;
-                    }
-                }
-            }
-            // If the character at the determined position is a whitespace, adjust position backward
-            if (content.charAt(position - 1).match(/\s$/)) {
-                position--;
-            }
-        }
-        // Return the calculated position to truncate the content
-        return position;
-    }
-    /**
-     * Truncate HTML string and keep tag safe.
-     * pulled from https://github.com/huang47/nodejs-html-truncate/blob/master/lib/truncate.js
-     *
-     * @param {string} html - The string that needs to be truncated
-     * @param {number} maxLength - Length of truncated string
-     * @param {Object} [options] - Optional configuration options
-     * @returns {string} The truncated string
-     */
-    truncateHTML(html, maxLength, options) {
-        const EMPTY_STRING = '';
-        const DEFAULT_TRUNCATE_SYMBOL = '...';
-        const DEFAULT_SLOP = Math.min(10, maxLength);
-        const tagsStack = [];
-        const KEY_VALUE_REGEX = '((?:\\s+(?:\\w+|-)+(?:\\s*=\\s*(?:"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\'|[^\'">\\s]+))?)*)';
-        const IS_CLOSE_REGEX = '\\s*\\/?\\s*';
-        const CLOSE_REGEX = '\\s*\\/\\s*';
-        const SELF_CLOSE_REGEX = new RegExp(`<\\/?(\\w+)${KEY_VALUE_REGEX}${CLOSE_REGEX}>`);
-        const HTML_TAG_REGEX = new RegExp(`<\\/?(\\w+)${KEY_VALUE_REGEX}${IS_CLOSE_REGEX}>`);
-        const URL_REGEX = /(((ftp|https?):\/\/)[\\-\w@:%_\\+.~#?,&\\/\\/=]+)|((mailto:)?[_.\w\\-]+@([\w][\w\\-]+\.)+[a-zA-Z]{2,3})/g;
-        const IMAGE_TAG_REGEX = new RegExp(`<img\\s*${KEY_VALUE_REGEX}${CLOSE_REGEX}>`);
-        let truncatedContent = EMPTY_STRING;
-        let totalLength = 0;
-        let matches = HTML_TAG_REGEX.exec(html);
-        let endResult;
-        let index;
-        let tag;
-        let selfClose = null;
-        let htmlString = html;
-        const opts = Object.assign({ ellipsis: DEFAULT_TRUNCATE_SYMBOL, truncateLastWord: true, slop: DEFAULT_SLOP }, options);
-        function removeImageTag(content) {
-            const match = IMAGE_TAG_REGEX.exec(content);
-            if (!match) {
-                return content;
-            }
-            const matchIndex = match.index;
-            const matchLength = match[0].length;
-            return content.substring(0, matchIndex) + content.substring(matchIndex + matchLength);
-        }
-        function closeTags(tags) {
-            return tags
-                .reverse()
-                .map((mappedTag) => {
-                return `</${mappedTag}>`;
-            })
-                .join('');
-        }
-        while (matches) {
-            matches = HTML_TAG_REGEX.exec(htmlString);
-            if (!matches) {
-                if (totalLength >= maxLength) {
-                    break;
-                }
-                matches = URL_REGEX.exec(htmlString);
-                if (!matches || matches.index >= maxLength) {
-                    truncatedContent += htmlString.substring(0, this.getEndPosition(htmlString, undefined, maxLength, totalLength, opts));
-                    break;
-                }
-                while (matches) {
-                    endResult = matches[0];
-                    if (endResult !== null) {
-                        index = matches.index;
-                        truncatedContent += htmlString.substring(0, index + endResult.length - totalLength);
-                        htmlString = htmlString.substring(index + endResult.length);
-                        matches = URL_REGEX.exec(htmlString);
-                    }
-                }
-                break;
-            }
-            endResult = matches[0];
-            index = matches.index;
-            if (totalLength + index > maxLength) {
-                truncatedContent += htmlString.substring(0, this.getEndPosition(htmlString, index, maxLength, totalLength, opts));
-                break;
-            }
-            else {
-                totalLength += index;
-                truncatedContent += htmlString.substring(0, index);
-            }
-            if (endResult[1] === '/') {
-                tagsStack.pop();
-                selfClose = null;
-            }
-            else {
-                selfClose = SELF_CLOSE_REGEX.exec(endResult);
-                if (!selfClose) {
-                    tag = matches[1];
-                    tagsStack.push(tag);
-                }
-            }
-            truncatedContent += selfClose ? selfClose[0] : endResult;
-            htmlString = htmlString.substring(index + endResult.length); // Update htmlString
-        }
-        if (htmlString.length > maxLength - totalLength && opts.ellipsis) {
-            truncatedContent += opts.ellipsis ? '...' : '';
-        }
-        truncatedContent += closeTags(tagsStack);
-        if (opts.removeImageTag) {
-            truncatedContent = removeImageTag(truncatedContent);
-        }
-        return truncatedContent;
-    }
-    /**
-     * Replaces text with a replacement based on a regex
-     * @param text - The text to replace
-     * @param regexp - The regex to match
-     * @param extras - The extras object
-     * @param replacement - The replacement string or function
-     * @returns The replaced text
-     */
-    replaceTextWithExtras(text, regexp, extras, replacement) {
-        if (typeof replacement === 'function') {
-            // if the replacement is a function, we pass the extras object to it
-            return text.replace(regexp, (...args) => replacement(extras, ...args));
-        }
-        return text.replace(regexp, replacement);
-    }
 }
 ExpensiMark.Log = new Logger_1.default({
     serverLoggingCallback: () => undefined,