TypeScript icon, indicating that this package has built-in type declarations

1.0.1 • Public • Published


Optimized and powerful regexes for JavaScript

npm Version License Build Status Bundle Size

Breaking Changes

In ES5, matching literal regexes with other regex in medium complexity code is highly risky.
In ES6 it is practically impossible.

For this reason, as of v1.0 JS_REGEX_P is deprecated and will be removed in the next minor version.

JS_REGEX will be maintained, but its use should be limited to complement other utilities, such as skip-regex, which uses a customized version of JS_REGEX to identify regular expresions reliably.

The minimum supported version of NodeJS now is 6.14 (oldest maintained LTS version w/fixes).


npm install perf-regexes --save
# or 
yarn add perf-regexes

In the browser, this loads perf-regexes in the global R object:

<script src=""></script>

Included Regexes

All of these regexes recognize Win/Mac/Unix line-endings and are ready to be used, but you can customize them using the RegExp constructor and the source property of the desired regex.


Name Flags Matches
HTML_CMNT g Valid HTML comments, according to the SGML standard.


Name Flags Matches
JS_MLCMNT g Multiline JS comment, with support for embedded '/*' sequences.
JS_SLCMNT g Single-line JS comments, not including its line-ending.
JS_DQSTR g Double quoted JS string, with support for escaped quotes and line-endings.
JS_SQSTR g Single quoted JS string, with support for escaped quotes and line-endings.
JS_STRING g Combines JS_SQSTR and JS_DQSTR to match single or double quoted strings.
JS_REGEX g Regex. Note: The result must be validated.
JS_REGEX_P g Deprecated, do not use it.

Selection of lines:

Name Flags Matches
EMPTY_LINES gm Empty line or line with only whitespace within, including its line-ending, if it has one.
NON_EMPTY_LINES gm Line with at least one non-whitespace character, including its line-ending, if it has one.
TRAILING_WS gm The trailing whitespace of a line, without including its line-ending.
OPT_WS_EOL g Zero or more blank characters followed by a line-ending, or the final blanks, if the (last) line has no line-ending.
EOL g Line-ending of any type


Because the 'g' flag, always set lastIndex or clone the regex before using it with the exec method.


Using only one regex, this simple example will...

  • Remove trailing whitespace of each line.
  • Remove the empty lines.
  • Normalize the line-endings to unix style.
const R = require('perf-regexes')
const cleaner = (text) => text.split(R.OPT_WS_EOL).filter(Boolean).join('\n')
console.dir(cleaner(' \r\r\n\nAA\t\t\t\r\n\rBB\nCC  \rDD  '))
// ⇒ 'AA\nBB\nCC\nDD'

Use the previous function to cleanup HTML text:

const htmlCleaner = (html) => cleaner(html.replace(R.HTML_CMNT, ''))
  '\r<!--header--><h1>A</h1>\r<div>B<br>\r\nC</div> <!--end-->\n'))
// ⇒ '<h1>A</h1>\n<div>B<br>\nC</div>'

Line-endings Normalization

const R = require('perf-regexes')
const normalize = (text) => text.split(R.EOL).join('\n')
console.dir(normalize('\rAA\r\r\nBB\r\nCC \nDD\r'))
// ⇒ '\nAA\n\nBB\nCC \nDD\n'

Double-quoted to single-quoted strings

const toSingleQuotes = (text) => text.replace(R.JS_STRING, (str) => {
  return str[0] === '"'
    ? `'${str.slice(1, -1).replace(/'/g, "\\'")}'`
    : str
console.log(toSingleQuotes(`"A's" 'B' "C"`))
// ⇒ 'A\'s' 'B' 'C'

Matching Regexes

With the arrival of ES6TL and new keywords, finding literal regexes with another regex is not viable, you need a JS parser such as acorn or a specialized one such as skip-regex to do it correctly.

This is a very basic example that uses skip-regex:

import R from 'perf-regexes'
import skipRegex from 'skip-regex'
 * Source to match quoted string, comments, and slashes.
 * Captures en $1 the slash
const reStr = `${R.JS_STRING.source}|${R.JS_MLCMNT.source}|${R.JS_SLCMNT.source}|(/)`
 * Search regexes in `code` and display the result to the console.
const searchRegexes = (code) => {
  // Creating `re` here keeps its lastIndex private
  const re = RegExp(reStr, 'g')
  let match = re.exec(code)
  while (match) {
    if (match[1]) {
      const start = match.index
      const end = skipRegex(code, start)
      // skipRegex returns start+1 if this is not a regex
      if (end > start + 1) {
        console.log(`Found "${code.slice(start, end)}" at ${start}`)
      re.lastIndex = end
    match = re.exec(code)
const code = `
const A = 2
const s = '/A/'            // must not find /A/
const re1 = /A/g           // regex
re1.lastIndex = 2 /A/ 1    // must not find /A/
/* /B/                     // must not find /B/
const re2 = /B/g           // regex
re1.exec(s || "/B/")       // must not find /B/
// output:
// Found "/A/g" at 74
// Found "/B/b" at 210

The previous code does not support ES6TL, but it works quite well on ES5 files and is very fast.

For a more complete example of using perf-regexes, see js-cleanup, an advanced utility with support for ES6 that trims trailing spaces, compacts empty lines, normalizes line-endings, and removes comments conditionally.

ES6 Template Literals

ES6TLs are too complex to be identified by one single regex, do not even try.

Support my Work

I'm a full-stack developer with more than 20 year of experience and I try to share most of my work for free and help others, but this takes a significant amount of time and effort so, if you like my work, please consider...

Of course, feedback, PRs, and stars are also welcome 🙃

Thanks for your support!


The MIT License (MIT)

Package Sidebar


npm i perf-regexes

Weekly Downloads






Unpacked Size

23.9 kB

Total Files


Last publish


  • amarcruz