XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag s, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native RegExp objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's groups object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running XRegExp.install('namespacing').
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with XRegExp.exec and XRegExp.replace.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading xregexp-all.js from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using xregexp-all.js, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
// Test some Unicode scripts
// Can also use the Script= prefix to match ES2018: \p{Script=Hiragana}
XRegExp('^\\p{Hiragana}+
By default, \p{…} and \P{…} support the Basic Multilingual Plane (i.e. code points up to U+FFFF). You can opt-in to full 21-bit Unicode support (with code points up to U+10FFFF) on a per-regex basis by using flag A. This is called astral mode. You can automatically add flag A for all new regexes by running XRegExp.install('astral'). When in astral mode, \p{…} and \P{…} always match a full code point rather than a code unit, using surrogate pairs for code points above U+FFFF.
// Using flag A to match astral code points
XRegExp('^\\p{S}
Opting in to astral mode disables the use of \p{…} and \P{…} within character classes. In astral mode, use e.g. (\pL|[0-9_])+ instead of [\pL0-9_]+.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
const time = XRegExp.build('(?x)^ {{hours}} ({{minutes}})
Named subpatterns can be provided as strings or regex objects. A leading ^ and trailing unescaped $ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. {{…}} tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax ({{name}}) works as shorthand for named capture via (?<name>{{name}}). Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
XRegExp.tag()`\b\w+\b`.test('word'); // -> true
const hours = /1[0-2]|0?[1-9]/;
const minutes = /(?<minutes>[0-5][0-9])/;
const time = XRegExp.tag('x')`\b ${hours} : ${minutes} \b`;
time.test('10:59'); // -> true
XRegExp.exec('10:59', time).groups.minutes; // -> '59'
const backref1 = /(a)\1/;
const backref2 = /(b)\1/;
XRegExp.tag()`${backref1}${backref2}`.test('aabb'); // -> true
XRegExp.tag does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. XRegExp.tag also uses XRegExp.build under the hood, so you get all of its extras for free. Leading ^ and trailing unescaped $ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
const str1 = '(t((e))s)t()(ing)';
XRegExp.matchRecursive(str1, '\\(', '\\)', 'g');
// -> ['t((e))s', '', 'ing']
// Extended information mode with valueNames
const str2 = 'Here is <div> <div>an</div></div> example';
XRegExp.matchRecursive(str2, '<div\\s*>', '</div>', 'gi', {
valueNames: ['between', 'left', 'match', 'right']
});
/* -> [
{name: 'between', value: 'Here is ', start: 0, end: 8},
{name: 'left', value: '<div>', start: 8, end: 13},
{name: 'match', value: ' <div>an</div>', start: 13, end: 27},
{name: 'right', value: '</div>', start: 27, end: 33},
{name: 'between', value: ' example', start: 33, end: 41}
] */
// Omitting unneeded parts with null valueNames, and using escapeChar
const str3 = '...{1}.\\{{function(x,y){return {y:x}}}';
XRegExp.matchRecursive(str3, '{', '}', 'g', {
valueNames: ['literal', null, 'value', null],
escapeChar: '\\'
});
/* -> [
{name: 'literal', value: '...', start: 0, end: 3},
{name: 'value', value: '1', start: 4, end: 5},
{name: 'literal', value: '.\\{', start: 6, end: 9},
{name: 'value', value: 'function(x,y){return {y:x}}', start: 10, end: 37}
] */
// Sticky mode via flag y
const str4 = '<1><<<2>>><3>4<5>';
XRegExp.matchRecursive(str4, '<', '>', 'gy');
// -> ['1', '<<2>>', '3']
// Skipping unbalanced delimiters instead of erroring
const str5 = 'Here is <div> <div>an</div> unbalanced example';
XRegExp.matchRecursive(str5, '<div\\s*>', '</div>', 'gi', {
unbalanced: 'skip'
});
// -> ['an']
By default, XRegExp.matchRecursive throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
<script src="https://unpkg.com/xregexp/xregexp-all.js"></script>
Using npm:
npm install xregexp
In Node.js:
const XRegExp = require('xregexp');
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true
XRegExp('^[\\p{Latin}\\p{Common}]+
By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true
// Test the Unicode categories Letter and Mark
// Can also use the short names \p{L} and \p{M}
const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');
XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;
See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/i
These examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
;
unicodeWord.test('Русский'); // -> true
unicodeWord.test('日本語'); // -> true
unicodeWord.test('العربية'); // -> true
By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('💩'); // -> false
XRegExp('^\\p{S}
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true
XRegExp('^[\\p{Latin}\\p{Common}]+
By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true
// Test the Unicode categories Letter and Mark
// Can also use the short names \p{L} and \p{M}
const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');
XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;
See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/i
These examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
;
unicodeWord.test('Русский'); // -> true
unicodeWord.test('日本語'); // -> true
unicodeWord.test('العربية'); // -> true
By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
, 'A').test('💩'); // -> true
// Using surrogate pair U+D83D U+DCA9 to represent U+1F4A9 (pile of poo)
XRegExp('^\\p{S}
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true
XRegExp('^[\\p{Latin}\\p{Common}]+
By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__
Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__
Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6__
__INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__
By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__
Using npm:
__CODE_BLOCK_9__
In Node.js:
__CODE_BLOCK_10__
Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true
// Test the Unicode categories Letter and Mark
// Can also use the short names \p{L} and \p{M}
const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');
XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;
See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/i
These examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
;
unicodeWord.test('Русский'); // -> true
unicodeWord.test('日本語'); // -> true
unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
, 'A').test('\uD83D\uDCA9'); // -> true // Implicit flag A XRegExp.install('astral'); XRegExp('^\\p{S}Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('💩'); // -> trueOpting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
, { hours: XRegExp.build('{{h12}} : | {{h24}}', { h12: /1[0-2]|0?[1-9]/, h24: /2[0-3]|[01][0-9]/ }), minutes: /^[0-5][0-9]$/ }); time.test('10:59'); // -> true XRegExp.exec('10:59', time).groups.minutes; // -> '59'Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('💩'); // -> false XRegExp('^\\p{S}Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
, 'A').test('💩'); // -> true // Using surrogate pair U+D83D U+DCA9 to represent U+1F4A9 (pile of poo) XRegExp('^\\p{S}Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
, 'A').test('\uD83D\uDCA9'); // -> true // Implicit flag A XRegExp.install('astral'); XRegExp('^\\p{S}Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('💩'); // -> trueOpting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('ひらがな'); // -> true XRegExp('^[\\p{Latin}\\p{Common}]+By default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.
).test('Über Café.'); // -> true // Test the Unicode categories Letter and Mark // Can also use the short names \p{L} and \p{M} const unicodeWord = XRegExp.tag()`^\p{Letter}[\p{Letter}\p{Mark}]*XRegExp
XRegExp was indispensable for heavy regex users in its time, but many of its best features have been adopted into modern JavaScript. Check out Regex+, the lightweight spiritual successor to XRegExp that once again takes JavaScript regexes to the next level.
XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
XRegExp supports ES5+ browsers, and you can use it with Node.js or as a RequireJS module. Over the years, many of XRegExp's features have been adopted by new JavaScript standards (named capturing, Unicode properties/scripts/categories, flag __INLINE_CODE_0__, sticky matching, etc.), so using XRegExp can be a way to extend these features into older browsers.
Performance
XRegExp compiles to native __INLINE_CODE_1__ objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
Named capture breaking change in XRegExp 5
XRegExp 5 introduced a breaking change where named backreference properties now appear on the result's __INLINE_CODE_2__ object (following ES2018), rather than directly on the result. To restore the old handling so you don't need to update old code, run the following line after importing XRegExp:
XRegExp.uninstall('namespacing');XRegExp 4.1.0 and later allow introducing the new behavior without upgrading to XRegExp 5 by running __INLINE_CODE_3__.
Following is the most commonly needed change to update code for the new behavior:
// Change this
const name = XRegExp.exec(str, regexWithNamedCapture).name;
// To this
const name = XRegExp.exec(str, regexWithNamedCapture).groups.name;See below for more examples of using named capture with __INLINE_CODE_4__ and __INLINE_CODE_5__.
Usage examples
// Using named capture and flag x for free-spacing and line comments
const date = XRegExp(
`(?<year> [0-9]{4} ) -? # year
(?<month> [0-9]{2} ) -? # month
(?<day> [0-9]{2} ) # day`, 'x');
// XRegExp.exec provides named backreferences on the result's groups property
let match = XRegExp.exec('2021-02-22', date);
match.groups.year; // -> '2021'
// It also includes optional pos and sticky arguments
let pos = 3;
const result = [];
while (match = XRegExp.exec('<1><2><3>4<5>', /<(\d+)>/, pos, 'sticky')) {
result.push(match[1]);
pos = match.index + match[0].length;
}
// result -> ['2', '3']
// XRegExp.replace allows named backreferences in replacements
XRegExp.replace('2021-02-22', date, '__CODE_BLOCK_2__lt;month>/__CODE_BLOCK_2__lt;day>/__CODE_BLOCK_2__lt;year>');
// -> '02/22/2021'
XRegExp.replace('2021-02-22', date, (...args) => {
// Named backreferences are on the last argument
const {day, month, year} = args.at(-1);
return `${month}/${day}/${year}`;
});
// -> '02/22/2021'
// XRegExps compile to RegExps and work with native methods
date.test('2021-02-22');
// -> true
// However, named captures must be referenced using numbered backreferences
// if used with native methods
'2021-02-22'.replace(date, '$2/$3/$1');
// -> '02/22/2021'
// Use XRegExp.forEach to extract every other digit from a string
const evens = [];
XRegExp.forEach('1a2345', /\d/, (match, i) => {
if (i % 2) evens.push(+match[0]);
});
// evens -> [2, 4]
// Use XRegExp.matchChain to get numbers within <b> tags
XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
XRegExp('<b>.*?</b>', 'is'),
/\d+/
]);
// -> ['2', '4', '56']
// You can also pass forward and return specific backreferences
const html =
`<a href="https://xregexp.com/">XRegExp</a>
<a href="https://www.google.com/">Google</a>`;
XRegExp.matchChain(html, [
{regex: /<a href="([^"]+)">/i, backref: 1},
{regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}
]);
// -> ['xregexp.com', 'www.google.com']
// Merge strings and regexes, with updated backreferences
XRegExp.union(['m+a*n', /(bear)\1/, /(pig)\1/], 'i', {conjunction: 'or'});
// -> /m\+a\*n|(bear)\1|(pig)\2/iThese examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See xregexp.com for details.
Addons
You can either load addons individually, or bundle all addons with XRegExp by loading __INLINE_CODE_6__ from https://unpkg.com/xregexp/xregexp-all.js.
Unicode
If not using __INLINE_CODE_7__, first include the Unicode Base script and then one or more of the addons for Unicode categories, properties, or scripts.
Then you can do this:
; unicodeWord.test('Русский'); // -> true unicodeWord.test('日本語'); // -> true unicodeWord.test('العربية'); // -> trueBy default, __INLINE_CODE_8__ and __INLINE_CODE_9__ support the Basic Multilingual Plane (i.e. code points up to __INLINE_CODE_10__). You can opt-in to full 21-bit Unicode support (with code points up to __INLINE_CODE_11__) on a per-regex basis by using flag __INLINE_CODE_12__. This is called astral mode. You can automatically add flag __INLINE_CODE_13__ for all new regexes by running __INLINE_CODE_14__. When in astral mode, __INLINE_CODE_15__ and __INLINE_CODE_16__ always match a full code point rather than a code unit, using surrogate pairs for code points above __INLINE_CODE_17__.
__CODE_BLOCK_4__Opting in to astral mode disables the use of __INLINE_CODE_18__ and __INLINE_CODE_19__ within character classes. In astral mode, use e.g. __INLINE_CODE_20__ instead of __INLINE_CODE_21__.
XRegExp uses Unicode 14.0.0.
XRegExp.build
Build regular expressions using named subpatterns, for readability and pattern reuse:
__CODE_BLOCK_5__Named subpatterns can be provided as strings or regex objects. A leading __INLINE_CODE_22__ and trailing unescaped __INLINE_CODE_23__ are stripped from subpatterns if both are present, which allows embedding independently-useful anchored patterns. __INLINE_CODE_24__ tokens can be quantified as a single unit. Any backreferences in the outer pattern or provided subpatterns are automatically renumbered to work correctly within the larger combined pattern. The syntax __INLINE_CODE_25__ works as shorthand for named capture via __INLINE_CODE_26__. Named subpatterns cannot be embedded within character classes.
XRegExp.tag (included with XRegExp.build)
Provides tagged template literals that create regexes with XRegExp syntax and flags:
__CODE_BLOCK_6____INLINE_CODE_27__ does more than just interpolation. You get all the XRegExp syntax and flags, and since it reads patterns as raw strings, you no longer need to escape all your backslashes. __INLINE_CODE_28__ also uses __INLINE_CODE_29__ under the hood, so you get all of its extras for free. Leading __INLINE_CODE_30__ and trailing unescaped __INLINE_CODE_31__ are stripped from interpolated patterns if both are present (to allow embedding independently useful anchored regexes), interpolating into a character class is an error (to avoid unintended meaning in edge cases), interpolated patterns are treated as atomic units when quantified, interpolated strings have their special characters escaped, and any backreferences within an interpolated regex are rewritten to work within the overall pattern.
XRegExp.matchRecursive
A robust and flexible API for matching recursive constructs using XRegExp pattern strings as left and right delimiters:
__CODE_BLOCK_7__By default, __INLINE_CODE_32__ throws an error if it scans past an unbalanced delimiter in the target string. Multiple alternative options are available for handling unbalanced delimiters.
Installation and usage
In browsers (bundle XRegExp with all of its addons):
__CODE_BLOCK_8__Using npm:
__CODE_BLOCK_9__In Node.js:
__CODE_BLOCK_10__Credits
XRegExp project collaborators are:
Thanks to all contributors and others who have submitted code, provided feedback, reported bugs, and inspired new features.
XRegExp is released under the MIT License. Learn more at xregexp.com.