Clean Markup

Safe Dynamic Pattern Matching with Native RegExp escape

Safe Dynamic Pattern Matching with Native RegExp escape

Building dynamic regular expressions from user-supplied text—such as live search filtering, autocomplete highlighting, or filename matching—has historically required developers to copy-paste fragile regex replacement helpers. If an input string contained unescaped metacharacters like ., *, +, ?, (, [, or $, passing it directly into new RegExp(input) could either throw a SyntaxError on unmatched brackets, match unintended characters, or trigger catastrophic backtracking (ReDoS) when maliciously crafted quantifiers were evaluated against long strings.

In 2025, RegExp.escape() reached ES2025 standardization and shipped across all major JavaScript engines (Chrome, Firefox, Safari, and modern Node.js runtimes). Unlike ad-hoc str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') snippets, the built-in RegExp.escape(text) specification handles every edge case uniformly: it escapes regex syntax characters, line terminators, Unicode whitespace, and even leading ASCII alphanumeric characters with hexadecimal escapes when necessary so that concatenating the escaped output after backreferences or inside character classes cannot alter pattern semantics.

Example

// Escaping arbitrary user input containing regex metacharacters
const rawQuery = 'v2.0 (beta) + $price?';
const safePattern = RegExp.escape(rawQuery);

// Case-insensitive literal match with zero SyntaxError or wildcard leakage
const matcher = new RegExp(safePattern, 'gi');

const sample = 'Upgrade to v2.0 (beta) + $price? today, not v2x0.';
console.log(sample.match(matcher));
// Output: ['v2.0 (beta) + $price?']

Implementation

/**
 * Builds a safe literal RegExp from untrusted user input.
 * Uses native ES2025 RegExp.escape when available, with a strict fallback
 * for older runtimes.
 */
export function createLiteralRegExp(input, flags = 'gi', { wholeWord = false } = {}) {
  if (typeof input !== 'string') {
    throw new TypeError('Search query must be a string.');
  }

  const trimmed = input.trim();
  if (trimmed.length === 0) {
    return null;
  }

  const escaped =
    typeof RegExp.escape === 'function'
      ? RegExp.escape(trimmed)
      : trimmed.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');

  const pattern = wholeWord ? `\\b${escaped}\\b` : escaped;
  return new RegExp(pattern, flags);
}

/**
 * Highlights literal matches inside a DOM container safely using DocumentFragment
 * and <mark> nodes rather than unsafe innerHTML string interpolation.
 */
export function highlightMatches(container, rawText, query) {
  const regex = createLiteralRegExp(query, 'gi');
  container.textContent = '';

  if (!regex) {
    container.textContent = rawText;
    return 0;
  }

  const fragment = document.createDocumentFragment();
  let lastIndex = 0;
  let matchCount = 0;

  for (const match of rawText.matchAll(regex)) {
    const start = match.index;
    const matchedText = match[0];

    if (start > lastIndex) {
      fragment.appendChild(document.createTextNode(rawText.slice(lastIndex, start)));
    }

    const mark = document.createElement('mark');
    mark.textContent = matchedText;
    fragment.appendChild(mark);

    lastIndex = start + matchedText.length;
    matchCount += 1;
  }

  if (lastIndex < rawText.length) {
    fragment.appendChild(document.createTextNode(rawText.slice(lastIndex)));
  }

  container.appendChild(fragment);
  return matchCount;
}

Main Point: Native ES2025 RegExp.escape converts untrusted strings into literal pattern fragments cleanly and reliably, preventing syntax errors and regex injection without hand-rolled escaping helpers.

Credits

Photo by Sarah Dorweiler on Unsplash

← Home