Version history

XRegExp 2.0.0 – 2012-05-21

Version 2.0.0 is a breaking upgrade. For compatibility with XRegExp 1.x.x, include backcompat.js after loading xregexp.js.

• Major change: Don't override native methods or allow syntax extensions by default.
• New feature: Add function XRegExp.install with options 'natives' and 'extensibility' (accepted as an object or string). Allows you to selectively add these optional features on demand. Use the shorthand 'all' to install all optional features.
  • Option 'natives' overrides the native methods RegExp.prototype.exec/test and String.prototype.match/replace/split with fixed/extended versions that support named backreferences and fix numerous cross-browser bugs.
  • Option 'extensibility' enables XRegExp.addToken, which is used by addons to extend XRegExp syntax and flags.
• New feature: Add function XRegExp.uninstall with options 'natives' and 'extensibility' (accepted as an object or string). Use the shorthand 'all' to uninstall all optional features.
• New feature: Add function XRegExp.isInstalled as a way of checking whether specific optional features are installed.
• New feature: Add new regex flag n (also supported via a leading (?n)), based on .NET's ExplicitCapture/(?n) flag. When regexes are built with flag n, only explicitly named groups of the form (?<name>…) capture a value. This makes unnamed (…) parentheses act as noncapturing groups without the syntactic clumsiness of (?:…).
• New feature: Add function XRegExp.union, for safely merging strings and regexes into a single pattern. (Comes from Ruby, but one-ups Ruby by officially supporting backreference rewriting for merged patterns.)
• New feature: Add function XRegExp.replace. Like the fixed String.prototype.replace (which is available only after running XRegExp.install('natives')), this supports named backreferences in replacement strings and functions, and includes various browser fixes compared to the native replace. XRegExp.replace additionally includes an optional fourth scope argument (accepts values 'one' [default] and 'all') that overrides /g when explicitly specified and allows global replacements with nonregex searches.
• New feature: Add function XRegExp.split as an alias of the fixed String.prototype.split (which is available only after running XRegExp.install('natives')).
• New feature: Add function XRegExp.test. Like the fixed RegExp.prototype.test (which is available only after running XRegExp.install('natives')), this fixes browser bugs for the setting of lastIndex. It additionally includes optional pos and sticky arguments, and doesn't use lastIndex for its own handling of regexes with /g.
• New feature: Make XRegExp.forEach return the provided context object (allows simplified usage).
• New feature: Expose XRegExp as exports.XRegExp for CommonJS enviroments.
• New feature: Allow $0 (not followed by 1-9) and $00 in replacement text to insert the full match, as alternatives to $& and ${0} (which continue to work). IE (tested IE 9) already supports $0 natively.
• Fine tuning: Rename XRegExp.iterate as XRegExp.forEach.
• Fine tuning: Rename XRegExp.execAt as XRegExp.exec.
• Fine tuning: Rename XRegExp.copyAsGlobal as XRegExp.globalize.
• Fine tuning: Remove XRegExp.freezeTokens (replaced by XRegExp.uninstall).
• Fine tuning: Remove RegExp.prototype.apply/call (replaced by XRegExp.prototype.apply/call in the XRegExp Prototype Methods addon).
• Fine tuning: Throw a SyntaxError on any use of octals (except \0 not followed by 0-9) or as-yet-undefined backreferences in an XRegExp pattern, to avoid having the sky fall on your head when you do so. (ES3 removed octals except \0 from regex syntax, but browsers still support them.)
• Fine tuning: Make escaped letters without native functionality throw a SyntaxError (e.g., \z throws rather than matching 'z'), unless they are overridden by XRegExp addons. Make the same apply for \u not followed by four hex digits, \x not followed by two hex digits, and \c not followed by A-Z or a-z. This makes letter escapes safe for future use with new functionality.
• Fine tuning: Make e.g. $10 in replacement text throw a SyntaxError unless there are at least 10 capturing groups. Use e.g. ${1}0 for backreference 1 followed by a literal 0.
• Fine tuning: Make $ in replacement text throw a SyntaxError when followed by anything that does not make a valid replacement token (e.g., $? or ${undefinedName}), rather than being handled as literal text.
• Fine tuning: Change XRegExp.addToken to accept the optional scope and trigger arguments via an options object.
• Fine tuning: Remove the bitflags XRegExp.INSIDE_CLASS/OUTSIDE_CLASS. Change token scopes to 'default', 'class', and 'all'.
• Fine tuning: Continue to prevent running the XRegExp source script twice, but don't throw an error when it occurs.
• Fine tuning: Make XRegExp(regexp) and XRegExp.globalize copy regexes using the RegExp constructor rather than XRegExp if the provided regex was not built by XRegExp (i.e., don't look for special tokens).
• Fine tuning: Throw a SyntaxError when a regex is compiled with an invalid/unregistered flag. Also applies to flags set via a mode modifier.
• Fine tuning: Add a customFlags option to the XRegExp.addToken options object, which registers any custom flags used by the token. This avoids throwing a SyntaxError when the new flag or flags are used.
• Fine tuning: Throw a SyntaxError when duplicate flags are provided to the XRegExp constructor, as recent browsers do for RegExp.
• Fine tuning: Make XRegExp.exec's fourth argument (sticky) officially support the string 'sticky' as a way to enable sticky mode, as a more readable alternative to Boolean true. (Already works in previous versions since nonempty strings are truthy.)
• Fine tuning: Allow XRegExp(), equivalent to XRegExp('') (following RegExp).
• Fix: Assign any added XRegExp.prototype properties to new XRegExp regex instances. (This didn't automatically work before because of JavaScript's rules about constructors that return nonprimitive values.) RegExp objects copied via XRegExp(regexp) or XRegExp.globalize will also automatically get these properties.
• Fix: Make named backreferences consistently refer to the last group with a given name, if more than one named capture uses the same name. (XRegExp('(?<n>a)(?<n>b)\\k<n>').test('abb') == true, result.n is 'b', etc.)
• Fix: Let user-added custom flags be included in a leading mode modifier.
• Fix: Throw a SyntaxError if a bare integer is used as a capture name (e.g., (?<1>…)), to avoid incorrect lookups since named backreferences are added as properties of match arrays.
• Fix: Make \k<1> (where 1 is any integer) reference capturing group number 1 (even if the first capturing group has a defined name). Previously, it could only reference a capturing group explicitly named 1.
• Fix: Make \k<…> with a number or name that references an as-yet-undefined group an error. Previously, \k<name>(?<name>…) was not an error but did not work as expected.
• Fix: Make backreferences in replacement text that use the curly brace syntax and refer to nonparticipating capturing groups return an empty string rather than 'undefined'.
• Fix: Make the sticky argument of XRegExp.exec override flag y when explicitly specified as false.
• Fix: Correct the handling of split when it's provided a very large number as its limit argument (e.g., Infinity or Math.pow(2,32)+1), converting to a very small number per the spec rules.
• Under the hood: Make it easy for XRegExp to be renamed, by simply editing the variable definition at the top of the file. (Browser addons, etc. should do this, to avoid conflicting with differing versions of XRegExp on a webpage.)
• Under the hood: Move the (commented out) backward compatibility layer for 1.x.x to the new script backcompat.js.

Unicode Base 1.0.0, Categories 1.2.0, Scripts 1.2.0, Blocks 1.2.0

Changes since Unicode Base 0.6.0, Categories 1.1.0, Scripts 1.1.0, and Blocks 1.1.0:

• New feature: Add support for Unicode category aliases, such as \p{Letter} instead of \p{L}.
• Fix: Add scripted range inversion to allow negated Unicode properties in character classes. No more need to use [^\p{L}\p{N}] instead of [\P{L}\P{N}].
• Under the hood: Add support for XRegExp 2.0.0 making extensibility an optional feature.

XRegExp.matchRecursive 0.2.0

Changes since XRegExp.matchRecursive 0.1.1:

• Fine tuning: Make results in detail mode more user friendly by returning an array of objects with named properties rather than an array of arrays.
• Fine tuning: Remove the (never officially supported) ability to provide delimiters as regex objects.
• Fix: Allow flag m when using escapeChar (previously threw a descriptive error).
• Fix: Allow backreferences in the left and right delimiters when using escapeChar.

New XRegExp addons

• Added Unicode Properties 1.0.0 that includes the remaining nine properties required for Level-1 Unicode support: Alphabetic, Uppercase, Lowercase, White_Space, Noncharacter_Code_Point, Default_Ignorable_Code_Point, Any, ASCII, and Assigned.
• Added XRegExp.build 0.1.0 (inspired by Lea Verou's RegExp.create) for building regexes using named subpatterns.
• Added Prototypes 1.0.0 that adds a collection of methods to be inherited by XRegExp regexes: apply, call, forEach, globalize, xexec, and xtest.
• Added BackCompat 1.0.0 for backward compatibility with XRegExp 1.x.x.

XRegExp 1.5.1 – 2012-02-22

This is a bug fix release that addresses a number of issues reported by users and teased out via the new test suite.

• New feature: RegExp.prototype.exec, RegExp.prototype.test, String.prototype.match, and String.prototype.replace ignore the lastIndex property of nonglobal regexes, even in browsers that get this wrong natively.
• Fine tuning: XRegExp.execAt and XRegExp.iterate update the lastIndex property of global regexes (even though they don't use it) based on the spec for RegExp.prototype.exec and String.prototype.replace.
• Fine tuning: The original regex (rather than a copy) is provided to the callback funtion with XRegExp.iterate.
• Fix: RegExp.prototype.exec no longer throws an error in IE when it is simultaneously provided a nonstring argument and called on a regex with a capturing group that matches an empty string.
• Fix: If undefined or no replacement value is provided to String.prototype.replace, it is type converted to the string 'undefined'.
• Fix: The last argument provided to String.prototype.replace replacement functions (the full original string) is now a string primitive rather than a String object in IE8 and earlier.
• Fix: Corrected handling of RegExps provided to String.prototype.replace as the replacement value in old browsers that report typeof /regex/ as 'function'.

XRegExp 1.5.0 – 2010-03-24

This release significantly changes the API for XRegExp's suite of functions. A backward compatibility layer for XRegExp 1.0.0–1.2.0 is available at the end of the script (uncomment to enable).

• New feature: XRegExp.execAt function.
• New feature: XRegExp.matchChain can now pass forward and return named or numbered backreferences as match values.
• New feature: (?imsx) mode modifier supported at the start of patterns only.
• Fine tuning: Removed RegExp.prototype.addFlags and added XRegExp.copyAsGlobal to take over its common use case.
• Fine tuning: Removed RegExp.prototype.forEachExec and replaced it with XRegExp.iterate.
• Fine tuning: Renamed XRegExp.matchWithinChain to XRegExp.matchChain.
• Fine tuning: Removed XRegExp.matchChain's detailMode option.
• Fine tuning: Removed RegExp.prototype.validate since it had no strong use cases.
• Fine tuning: XRegExp.addToken adds /y to token regexes when supported natively, for improved performance.
• Fine tuning: Calling XRegExp.addToken after XRegExp.freezeTokens throws a descriptive error.
• Fine tuning: Changed several functions to accept regexes only rather than regexes or XRegExp pattern strings.
• Fine tuning: Loading XRegExp twice in the same frame throws an error.
• Fix: Errors thrown in token definition functions no longer cause subsequent valid XRegExp calls to throw.

XRegExp 1.2.0 – 2009-10-20

• Fine tuning: Removed RegExp.prototype.execAll since it is trivial to implement using RegExp.prototype.forEachExec.
• Fine tuning: XRegExp is no longer reliant on the global object being named window, which allows it to be used in nonbrowser contexts.
• Fix: Duplicate flags caused an error in Firefox 3.5.x and later.
• Fix: When replacement strings contained backreferences to nonparticipating groups, 'undefined' was inserted into the returned string in IE.

XRegExp 1.1.0 – 2009-07-04

• New feature: A bug in IE where the lastIndex property of regexes created with the /g flag is not always reset to zero after running String.prototype.replace or String.prototype.match is now fixed automatically.
• New feature: A bug in Firefox, IE, Safari, and Chrome where the lastIndex property of a regex is not updated during String.prototype.replace iterations (visible within replacement functions) is now fixed automatically.
• Fix: String.prototype.split and String.prototype.replace now consistently work with non-string context (this).
• Fix: The empty character class [] caused incorrect results in some edge cases in Firefox only, due to a Firefox bug in handling empty negative lookahead.

XRegExp 1.0.1 – 2009-06-26

• Fix: A leading zero is now allowed in two-digit $nn backreferences in replacement text.
• Fix: Several other bugs with String.prototype.replace were also fixed. Mostly, these were edge-case issues introduced in XRegExp 1.0.0.

XRegExp 1.0.0 – 2009-06-24

• New feature: XRegExp.addToken function.
• New feature: XRegExp.freezeTokens function.
• New feature: XRegExp.isRegExp function.
• New feature: XRegExp.matchWithinChain function.
• New feature: RegExp.prototype.validate method.
• New feature: RegExp.prototype.forEachExec method.
• New feature: RegExp.prototype.execAll method.
• New feature: The ${…} replacement text token now supports numbered backreferences (and thereby offers an otherwise-unavailable way to separate backreferences from literal numbers), in addition to named backreferences. This follows prior art in .NET, etc.
• New feature: Consistent cross-browser, ES3-compliant handling of $-prefix metasequences in replacement text when performing a replacement using a non-regex search value.
• New feature: Automatically fix incorrectly incremented lastIndex properties after zero-length matches are found by RegExp.prototype.test (already performed for RegExp.prototype.exec and String.prototype.match).
• New feature: XRegExp.version property.
• Fine tuning: Rewrote XRegExp's core to work with user-extendable regex syntax tokens.
• Fine tuning: Code cleanup, performance tweaks, and improved documentation.
• Fine tuning: Removed the XRegExp.matchRecursive function. It's now a standalone plugin.
• Fine tuning: Removed handling for native, infinitely-nesting character class intersection syntax (proposed for ES4 but not included in ES5).
• Fine tuning: Removed XRegExp.addPlugin, which was hard-coded to work with the Unicode plugin only. If you use this plugin, download an updated version (v0.3.0 or higher).
• Fix: The limit argument of String.prototype.split is now followed consistently.
• Fix: Types are now detected correctly for variables created in a frame other than where XRegExp is run.
• Fix: $n tokens in replacement text are now limited to two digits, even when there are more than 99 capturing groups in your regex. Use ${nnn} for three or more digit backreferences.

XRegExp 0.6.1 – 2008-08-01

• Fine tuning: Tweaked the barebones plugin architecture.

XRegExp 0.6.0 – 2008-07-23

• Fine tuning: Added support for the first plugin: Unicode.
• Fix: When using String.prototype.split, if the last match of the separator within the subject string ended at the end of the string, and the separator was capable of matching an empty string (e.g. /a?/), a trailing empty string value was not appended to the result array even when the separator did not match an empty string in that last case. This followed Firefox's native handling, but not the spec (which at least Opera follows correctly).

XRegExp 0.5.2 – 2008-05-14

• Fix: XRegExp.matchRecursive could not return more than one match when the sticky (y) and global (g) modifiers were combined without using valueNames.

XRegExp 0.5.1 – 2008-04-21

• Fix: RegExp.prototype.addFlags did not preserve previously applied, non-native modifiers (v0.5.0 only).

XRegExp 0.5.0 – 2008-04-20

• New feature: XRegExp.matchRecursive function.
• New feature: XRegExp.escape function.
• New feature: XRegExp.cache function.
• New feature: RegExp.prototype.call/apply methods.
• New feature: Comment pattern syntax: (?#…).
• New feature: Consistent cross-browser, ES3-compliant String.prototype.split method.
• New feature: Automatically fix incorrect RegExp.prototype.exec and String.prototype.match return values for nonparticipating capturing groups.
• New feature: Automatically fix incorrectly incremented lastIndex properties after zero-length matches are returned by RegExp.prototype.exec and String.prototype.match.
• Fine tuning: Changed named capture syntax from (<name>…) to (?<name>…), which is the standard syntax in .NET, Perl, and PCRE, and under consideration for ES4.
• Fine tuning: Named capture is now always available; no more k modifier.
• Fine tuning: Support for native, infinitely-nesting character class intersection syntax proposed for ES4.
• Fine tuning: Support for native sticky (y) and extended (x) modifiers. Sticky mode will be in JS1.8; both are proposed for ES4.
• Fine tuning: Passing a RegExp object to the XRegExp constructor now returns a new copy, like the native RegExp constructor.
• Fine tuning: Removed XRegExp.overrideNative. The RegExp constructor cannot be overriden in JS1.8 or current ES4 proposals.
• Fine tuning: Changed handling of empty character classes to follow ES3 cross-browser.

XRegExp 0.2.2 – 2007-07-12

• Fix: Safari 3 is now supported, after working around a WebKit parser bug.

XRegExp 0.2.1 – 2007-07-09

• Fix: XRegExp now works after being loaded twice (but you shouldn't do that).

XRegExp 0.2.0 – 2007-07-08

• New feature: Comprehensive named capture support, activated using the new k modifier.
  • Capture: (<name>…)
  • Backreference in regex: \k<name>
  • Backreference in replacement text: ${name}
  • Returned as: result.name, or arguments[0].name in replacement functions
• New feature: RegExp.prototype.addFlags method.
• Fine tuning: Removed the XRE global object. XRE.overrideNative is now XRegExp.overrideNative.
• Fine tuning: The x modifier now ignores whitespace between a regex token and its quantifier, rather than collapsing it to (?:).

XRegExp 0.1.0 – 2007-05-30 (initial release)

• Dotall (s, aka singleline) modifier.
• Free-spacing (x, aka extended) modifier.
• Consistent cross-browser handling for leading, unescaped ] in character classes.
• XRE.overrideNative function, which applies these regex extensions to the RegExp constructor.

◊