github-pages-deploy-action/node_modules/xregexp/lib/xregexp.js
2020-03-06 22:45:40 -05:00

2046 lines
72 KiB
JavaScript

"use strict";
var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
_Object$defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
var _create = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/create"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
var _getIterator2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js/get-iterator"));
var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
var _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/parse-int"));
var _slice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/slice"));
var _sort = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/sort"));
var _flags = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/flags"));
/*!
* XRegExp 4.3.0
* <xregexp.com>
* Steven Levithan (c) 2007-present MIT License
*/
/**
* XRegExp provides augmented, extensible regular expressions. You get additional regex syntax and
* flags, beyond what browsers support natively. XRegExp is also a regex utility belt with tools to
* make your client-side grepping simpler and more powerful, while freeing you from related
* cross-browser inconsistencies.
*/
// ==--------------------------==
// Private stuff
// ==--------------------------==
// Property name used for extended regex instance data
var REGEX_DATA = 'xregexp'; // Optional features that can be installed and uninstalled
var features = {
astral: false,
namespacing: false
}; // Native methods to use and restore ('native' is an ES3 reserved keyword)
var nativ = {
exec: RegExp.prototype.exec,
test: RegExp.prototype.test,
match: String.prototype.match,
replace: String.prototype.replace,
split: String.prototype.split
}; // Storage for fixed/extended native methods
var fixed = {}; // Storage for regexes cached by `XRegExp.cache`
var regexCache = {}; // Storage for pattern details cached by the `XRegExp` constructor
var patternCache = {}; // Storage for regex syntax tokens added internally or by `XRegExp.addToken`
var tokens = []; // Token scopes
var defaultScope = 'default';
var classScope = 'class'; // Regexes that match native regex syntax, including octals
var nativeTokens = {
// Any native multicharacter token in default scope, or any single character
'default': /\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|\(\?(?:[:=!]|<[=!])|[?*+]\?|{\d+(?:,\d*)?}\??|[\s\S]/,
// Any native multicharacter token in character class scope, or any single character
'class': /\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u(?:[\dA-Fa-f]{4}|{[\dA-Fa-f]+})|c[A-Za-z]|[\s\S])|[\s\S]/
}; // Any backreference or dollar-prefixed character in replacement strings
var replacementToken = /\$(?:{([\w$]+)}|<([\w$]+)>|(\d\d?|[\s\S]))/g; // Check for correct `exec` handling of nonparticipating capturing groups
var correctExecNpcg = nativ.exec.call(/()??/, '')[1] === undefined; // Check for ES6 `flags` prop support
var hasFlagsProp = (0, _flags.default)(/x/) !== undefined; // Shortcut to `Object.prototype.toString`
var _ref = {},
toString = _ref.toString;
function hasNativeFlag(flag) {
// Can't check based on the presence of properties/getters since browsers might support such
// properties even when they don't support the corresponding flag in regex construction (tested
// in Chrome 48, where `'unicode' in /x/` is true but trying to construct a regex with flag `u`
// throws an error)
var isSupported = true;
try {
// Can't use regex literals for testing even in a `try` because regex literals with
// unsupported flags cause a compilation error in IE
new RegExp('', flag);
} catch (exception) {
isSupported = false;
}
return isSupported;
} // Check for ES6 `u` flag support
var hasNativeU = hasNativeFlag('u'); // Check for ES6 `y` flag support
var hasNativeY = hasNativeFlag('y'); // Tracker for known flags, including addon flags
var registeredFlags = {
g: true,
i: true,
m: true,
u: hasNativeU,
y: hasNativeY
};
/**
* Attaches extended data and `XRegExp.prototype` properties to a regex object.
*
* @private
* @param {RegExp} regex Regex to augment.
* @param {Array} captureNames Array with capture names, or `null`.
* @param {String} xSource XRegExp pattern used to generate `regex`, or `null` if N/A.
* @param {String} xFlags XRegExp flags used to generate `regex`, or `null` if N/A.
* @param {Boolean} [isInternalOnly=false] Whether the regex will be used only for internal
* operations, and never exposed to users. For internal-only regexes, we can improve perf by
* skipping some operations like attaching `XRegExp.prototype` properties.
* @returns {RegExp} Augmented regex.
*/
function augment(regex, captureNames, xSource, xFlags, isInternalOnly) {
var _context;
regex[REGEX_DATA] = {
captureNames: captureNames
};
if (isInternalOnly) {
return regex;
} // Can't auto-inherit these since the XRegExp constructor returns a nonprimitive value
if (regex.__proto__) {
regex.__proto__ = XRegExp.prototype;
} else {
for (var p in XRegExp.prototype) {
// An `XRegExp.prototype.hasOwnProperty(p)` check wouldn't be worth it here, since this
// is performance sensitive, and enumerable `Object.prototype` or `RegExp.prototype`
// extensions exist on `regex.prototype` anyway
regex[p] = XRegExp.prototype[p];
}
}
regex[REGEX_DATA].source = xSource; // Emulate the ES6 `flags` prop by ensuring flags are in alphabetical order
regex[REGEX_DATA].flags = xFlags ? (0, _sort.default)(_context = xFlags.split('')).call(_context).join('') : xFlags;
return regex;
}
/**
* Removes any duplicate characters from the provided string.
*
* @private
* @param {String} str String to remove duplicate characters from.
* @returns {String} String with any duplicate characters removed.
*/
function clipDuplicates(str) {
return nativ.replace.call(str, /([\s\S])(?=[\s\S]*\1)/g, '');
}
/**
* Copies a regex object while preserving extended data and augmenting with `XRegExp.prototype`
* properties. The copy has a fresh `lastIndex` property (set to zero). Allows adding and removing
* flags g and y while copying the regex.
*
* @private
* @param {RegExp} regex Regex to copy.
* @param {Object} [options] Options object with optional properties:
* - `addG` {Boolean} Add flag g while copying the regex.
* - `addY` {Boolean} Add flag y while copying the regex.
* - `removeG` {Boolean} Remove flag g while copying the regex.
* - `removeY` {Boolean} Remove flag y while copying the regex.
* - `isInternalOnly` {Boolean} Whether the copied regex will be used only for internal
* operations, and never exposed to users. For internal-only regexes, we can improve perf by
* skipping some operations like attaching `XRegExp.prototype` properties.
* - `source` {String} Overrides `<regex>.source`, for special cases.
* @returns {RegExp} Copy of the provided regex, possibly with modified flags.
*/
function copyRegex(regex, options) {
var _context2;
if (!XRegExp.isRegExp(regex)) {
throw new TypeError('Type RegExp expected');
}
var xData = regex[REGEX_DATA] || {};
var flags = getNativeFlags(regex);
var flagsToAdd = '';
var flagsToRemove = '';
var xregexpSource = null;
var xregexpFlags = null;
options = options || {};
if (options.removeG) {
flagsToRemove += 'g';
}
if (options.removeY) {
flagsToRemove += 'y';
}
if (flagsToRemove) {
flags = nativ.replace.call(flags, new RegExp("[".concat(flagsToRemove, "]+"), 'g'), '');
}
if (options.addG) {
flagsToAdd += 'g';
}
if (options.addY) {
flagsToAdd += 'y';
}
if (flagsToAdd) {
flags = clipDuplicates(flags + flagsToAdd);
}
if (!options.isInternalOnly) {
if (xData.source !== undefined) {
xregexpSource = xData.source;
} // null or undefined; don't want to add to `flags` if the previous value was null, since
// that indicates we're not tracking original precompilation flags
if ((0, _flags.default)(xData) != null) {
// Flags are only added for non-internal regexes by `XRegExp.globalize`. Flags are never
// removed for non-internal regexes, so don't need to handle it
xregexpFlags = flagsToAdd ? clipDuplicates((0, _flags.default)(xData) + flagsToAdd) : (0, _flags.default)(xData);
}
} // Augment with `XRegExp.prototype` properties, but use the native `RegExp` constructor to avoid
// searching for special tokens. That would be wrong for regexes constructed by `RegExp`, and
// unnecessary for regexes constructed by `XRegExp` because the regex has already undergone the
// translation to native regex syntax
regex = augment(new RegExp(options.source || regex.source, flags), hasNamedCapture(regex) ? (0, _slice.default)(_context2 = xData.captureNames).call(_context2, 0) : null, xregexpSource, xregexpFlags, options.isInternalOnly);
return regex;
}
/**
* Converts hexadecimal to decimal.
*
* @private
* @param {String} hex
* @returns {Number}
*/
function dec(hex) {
return (0, _parseInt2.default)(hex, 16);
}
/**
* Returns a pattern that can be used in a native RegExp in place of an ignorable token such as an
* inline comment or whitespace with flag x. This is used directly as a token handler function
* passed to `XRegExp.addToken`.
*
* @private
* @param {String} match Match arg of `XRegExp.addToken` handler
* @param {String} scope Scope arg of `XRegExp.addToken` handler
* @param {String} flags Flags arg of `XRegExp.addToken` handler
* @returns {String} Either '' or '(?:)', depending on which is needed in the context of the match.
*/
function getContextualTokenSeparator(match, scope, flags) {
if ( // No need to separate tokens if at the beginning or end of a group
match.input[match.index - 1] === '(' || match.input[match.index + match[0].length] === ')' || // No need to separate tokens if before or after a `|`
match.input[match.index - 1] === '|' || match.input[match.index + match[0].length] === '|' || // No need to separate tokens if at the beginning or end of the pattern
match.index < 1 || match.index + match[0].length >= match.input.length || // No need to separate tokens if at the beginning of a noncapturing group or lookahead.
// The way this is written relies on:
// - The search regex matching only 3-char strings.
// - Although `substr` gives chars from the end of the string if given a negative index,
// the resulting substring will be too short to match. Ex: `'abcd'.substr(-1, 3) === 'd'`
nativ.test.call(/^\(\?[:=!]/, match.input.substr(match.index - 3, 3)) || // Avoid separating tokens when the following token is a quantifier
isQuantifierNext(match.input, match.index + match[0].length, flags)) {
return '';
} // Keep tokens separated. This avoids e.g. inadvertedly changing `\1 1` or `\1(?#)1` to `\11`.
// This also ensures all tokens remain as discrete atoms, e.g. it avoids converting the syntax
// error `(? :` into `(?:`.
return '(?:)';
}
/**
* Returns native `RegExp` flags used by a regex object.
*
* @private
* @param {RegExp} regex Regex to check.
* @returns {String} Native flags in use.
*/
function getNativeFlags(regex) {
return hasFlagsProp ? (0, _flags.default)(regex) : // Explicitly using `RegExp.prototype.toString` (rather than e.g. `String` or concatenation
// with an empty string) allows this to continue working predictably when
// `XRegExp.proptotype.toString` is overridden
nativ.exec.call(/\/([a-z]*)$/i, RegExp.prototype.toString.call(regex))[1];
}
/**
* Determines whether a regex has extended instance data used to track capture names.
*
* @private
* @param {RegExp} regex Regex to check.
* @returns {Boolean} Whether the regex uses named capture.
*/
function hasNamedCapture(regex) {
return !!(regex[REGEX_DATA] && regex[REGEX_DATA].captureNames);
}
/**
* Converts decimal to hexadecimal.
*
* @private
* @param {Number|String} dec
* @returns {String}
*/
function hex(dec) {
return (0, _parseInt2.default)(dec, 10).toString(16);
}
/**
* Checks whether the next nonignorable token after the specified position is a quantifier.
*
* @private
* @param {String} pattern Pattern to search within.
* @param {Number} pos Index in `pattern` to search at.
* @param {String} flags Flags used by the pattern.
* @returns {Boolean} Whether the next nonignorable token is a quantifier.
*/
function isQuantifierNext(pattern, pos, flags) {
var inlineCommentPattern = '\\(\\?#[^)]*\\)';
var lineCommentPattern = '#[^#\\n]*';
var quantifierPattern = '[?*+]|{\\d+(?:,\\d*)?}';
return nativ.test.call((0, _includes.default)(flags).call(flags, 'x') ? // Ignore any leading whitespace, line comments, and inline comments
/^(?:\s|#[^#\n]*|\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/ : // Ignore any leading inline comments
/^(?:\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/, (0, _slice.default)(pattern).call(pattern, pos));
}
/**
* Determines whether a value is of the specified type, by resolving its internal [[Class]].
*
* @private
* @param {*} value Object to check.
* @param {String} type Type to check for, in TitleCase.
* @returns {Boolean} Whether the object matches the type.
*/
function isType(value, type) {
return toString.call(value) === "[object ".concat(type, "]");
}
/**
* Adds leading zeros if shorter than four characters. Used for fixed-length hexadecimal values.
*
* @private
* @param {String} str
* @returns {String}
*/
function pad4(str) {
while (str.length < 4) {
str = "0".concat(str);
}
return str;
}
/**
* Checks for flag-related errors, and strips/applies flags in a leading mode modifier. Offloads
* the flag preparation logic from the `XRegExp` constructor.
*
* @private
* @param {String} pattern Regex pattern, possibly with a leading mode modifier.
* @param {String} flags Any combination of flags.
* @returns {Object} Object with properties `pattern` and `flags`.
*/
function prepareFlags(pattern, flags) {
// Recent browsers throw on duplicate flags, so copy this behavior for nonnative flags
if (clipDuplicates(flags) !== flags) {
throw new SyntaxError("Invalid duplicate regex flag ".concat(flags));
} // Strip and apply a leading mode modifier with any combination of flags except g or y
pattern = nativ.replace.call(pattern, /^\(\?([\w$]+)\)/, function ($0, $1) {
if (nativ.test.call(/[gy]/, $1)) {
throw new SyntaxError("Cannot use flag g or y in mode modifier ".concat($0));
} // Allow duplicate flags within the mode modifier
flags = clipDuplicates(flags + $1);
return '';
}); // Throw on unknown native or nonnative flags
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = (0, _getIterator2.default)(flags), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var flag = _step.value;
if (!registeredFlags[flag]) {
throw new SyntaxError("Unknown regex flag ".concat(flag));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return {
pattern: pattern,
flags: flags
};
}
/**
* Prepares an options object from the given value.
*
* @private
* @param {String|Object} value Value to convert to an options object.
* @returns {Object} Options object.
*/
function prepareOptions(value) {
var options = {};
if (isType(value, 'String')) {
(0, _forEach.default)(XRegExp).call(XRegExp, value, /[^\s,]+/, function (match) {
options[match] = true;
});
return options;
}
return value;
}
/**
* Registers a flag so it doesn't throw an 'unknown flag' error.
*
* @private
* @param {String} flag Single-character flag to register.
*/
function registerFlag(flag) {
if (!/^[\w$]$/.test(flag)) {
throw new Error('Flag must be a single character A-Za-z0-9_$');
}
registeredFlags[flag] = true;
}
/**
* Runs built-in and custom regex syntax tokens in reverse insertion order at the specified
* position, until a match is found.
*
* @private
* @param {String} pattern Original pattern from which an XRegExp object is being built.
* @param {String} flags Flags being used to construct the regex.
* @param {Number} pos Position to search for tokens within `pattern`.
* @param {Number} scope Regex scope to apply: 'default' or 'class'.
* @param {Object} context Context object to use for token handler functions.
* @returns {Object} Object with properties `matchLength`, `output`, and `reparse`; or `null`.
*/
function runTokens(pattern, flags, pos, scope, context) {
var i = tokens.length;
var leadChar = pattern[pos];
var result = null;
var match;
var t; // Run in reverse insertion order
while (i--) {
t = tokens[i];
if (t.leadChar && t.leadChar !== leadChar || t.scope !== scope && t.scope !== 'all' || t.flag && !(0, _includes.default)(flags).call(flags, t.flag)) {
continue;
}
match = XRegExp.exec(pattern, t.regex, pos, 'sticky');
if (match) {
result = {
matchLength: match[0].length,
output: t.handler.call(context, match, scope, flags),
reparse: t.reparse
}; // Finished with token tests
break;
}
}
return result;
}
/**
* Enables or disables implicit astral mode opt-in. When enabled, flag A is automatically added to
* all new regexes created by XRegExp. This causes an error to be thrown when creating regexes if
* the Unicode Base addon is not available, since flag A is registered by that addon.
*
* @private
* @param {Boolean} on `true` to enable; `false` to disable.
*/
function setAstral(on) {
features.astral = on;
}
/**
* Adds named capture groups to the `groups` property of match arrays. See here for details:
* https://github.com/tc39/proposal-regexp-named-groups
*
* @private
* @param {Boolean} on `true` to enable; `false` to disable.
*/
function setNamespacing(on) {
features.namespacing = on;
}
/**
* Returns the object, or throws an error if it is `null` or `undefined`. This is used to follow
* the ES5 abstract operation `ToObject`.
*
* @private
* @param {*} value Object to check and return.
* @returns {*} The provided object.
*/
function toObject(value) {
// null or undefined
if (value == null) {
throw new TypeError('Cannot convert null or undefined to object');
}
return value;
} // ==--------------------------==
// Constructor
// ==--------------------------==
/**
* Creates an extended regular expression object for matching text with a pattern. Differs from a
* native regular expression in that additional syntax and flags are supported. The returned object
* is in fact a native `RegExp` and works with all native methods.
*
* @class XRegExp
* @constructor
* @param {String|RegExp} pattern Regex pattern string, or an existing regex object to copy.
* @param {String} [flags] Any combination of flags.
* Native flags:
* - `g` - global
* - `i` - ignore case
* - `m` - multiline anchors
* - `u` - unicode (ES6)
* - `y` - sticky (Firefox 3+, ES6)
* Additional XRegExp flags:
* - `n` - explicit capture
* - `s` - dot matches all (aka singleline)
* - `x` - free-spacing and line comments (aka extended)
* - `A` - astral (requires the Unicode Base addon)
* Flags cannot be provided when constructing one `RegExp` from another.
* @returns {RegExp} Extended regular expression object.
* @example
*
* // With named capture and flag x
* XRegExp(`(?<year> [0-9]{4} ) -? # year
* (?<month> [0-9]{2} ) -? # month
* (?<day> [0-9]{2} ) # day`, 'x');
*
* // Providing a regex object copies it. Native regexes are recompiled using native (not XRegExp)
* // syntax. Copies maintain extended data, are augmented with `XRegExp.prototype` properties, and
* // have fresh `lastIndex` properties (set to zero).
* XRegExp(/regex/);
*/
function XRegExp(pattern, flags) {
if (XRegExp.isRegExp(pattern)) {
if (flags !== undefined) {
throw new TypeError('Cannot supply flags when copying a RegExp');
}
return copyRegex(pattern);
} // Copy the argument behavior of `RegExp`
pattern = pattern === undefined ? '' : String(pattern);
flags = flags === undefined ? '' : String(flags);
if (XRegExp.isInstalled('astral') && !(0, _includes.default)(flags).call(flags, 'A')) {
// This causes an error to be thrown if the Unicode Base addon is not available
flags += 'A';
}
if (!patternCache[pattern]) {
patternCache[pattern] = {};
}
if (!patternCache[pattern][flags]) {
var context = {
hasNamedCapture: false,
captureNames: []
};
var scope = defaultScope;
var output = '';
var pos = 0;
var result; // Check for flag-related errors, and strip/apply flags in a leading mode modifier
var applied = prepareFlags(pattern, flags);
var appliedPattern = applied.pattern;
var appliedFlags = (0, _flags.default)(applied); // Use XRegExp's tokens to translate the pattern to a native regex pattern.
// `appliedPattern.length` may change on each iteration if tokens use `reparse`
while (pos < appliedPattern.length) {
do {
// Check for custom tokens at the current position
result = runTokens(appliedPattern, appliedFlags, pos, scope, context); // If the matched token used the `reparse` option, splice its output into the
// pattern before running tokens again at the same position
if (result && result.reparse) {
appliedPattern = (0, _slice.default)(appliedPattern).call(appliedPattern, 0, pos) + result.output + (0, _slice.default)(appliedPattern).call(appliedPattern, pos + result.matchLength);
}
} while (result && result.reparse);
if (result) {
output += result.output;
pos += result.matchLength || 1;
} else {
// Get the native token at the current position
var _XRegExp$exec = XRegExp.exec(appliedPattern, nativeTokens[scope], pos, 'sticky'),
_XRegExp$exec2 = (0, _slicedToArray2.default)(_XRegExp$exec, 1),
token = _XRegExp$exec2[0];
output += token;
pos += token.length;
if (token === '[' && scope === defaultScope) {
scope = classScope;
} else if (token === ']' && scope === classScope) {
scope = defaultScope;
}
}
}
patternCache[pattern][flags] = {
// Use basic cleanup to collapse repeated empty groups like `(?:)(?:)` to `(?:)`. Empty
// groups are sometimes inserted during regex transpilation in order to keep tokens
// separated. However, more than one empty group in a row is never needed.
pattern: nativ.replace.call(output, /(?:\(\?:\))+/g, '(?:)'),
// Strip all but native flags
flags: nativ.replace.call(appliedFlags, /[^gimuy]+/g, ''),
// `context.captureNames` has an item for each capturing group, even if unnamed
captures: context.hasNamedCapture ? context.captureNames : null
};
}
var generated = patternCache[pattern][flags];
return augment(new RegExp(generated.pattern, (0, _flags.default)(generated)), generated.captures, pattern, flags);
} // Add `RegExp.prototype` to the prototype chain
XRegExp.prototype = /(?:)/; // ==--------------------------==
// Public properties
// ==--------------------------==
/**
* The XRegExp version number as a string containing three dot-separated parts. For example,
* '2.0.0-beta-3'.
*
* @static
* @memberOf XRegExp
* @type String
*/
XRegExp.version = '4.3.0'; // ==--------------------------==
// Public methods
// ==--------------------------==
// Intentionally undocumented; used in tests and addons
XRegExp._clipDuplicates = clipDuplicates;
XRegExp._hasNativeFlag = hasNativeFlag;
XRegExp._dec = dec;
XRegExp._hex = hex;
XRegExp._pad4 = pad4;
/**
* Extends XRegExp syntax and allows custom flags. This is used internally and can be used to
* create XRegExp addons. If more than one token can match the same string, the last added wins.
*
* @memberOf XRegExp
* @param {RegExp} regex Regex object that matches the new token.
* @param {Function} handler Function that returns a new pattern string (using native regex syntax)
* to replace the matched token within all future XRegExp regexes. Has access to persistent
* properties of the regex being built, through `this`. Invoked with three arguments:
* - The match array, with named backreference properties.
* - The regex scope where the match was found: 'default' or 'class'.
* - The flags used by the regex, including any flags in a leading mode modifier.
* The handler function becomes part of the XRegExp construction process, so be careful not to
* construct XRegExps within the function or you will trigger infinite recursion.
* @param {Object} [options] Options object with optional properties:
* - `scope` {String} Scope where the token applies: 'default', 'class', or 'all'.
* - `flag` {String} Single-character flag that triggers the token. This also registers the
* flag, which prevents XRegExp from throwing an 'unknown flag' error when the flag is used.
* - `optionalFlags` {String} Any custom flags checked for within the token `handler` that are
* not required to trigger the token. This registers the flags, to prevent XRegExp from
* throwing an 'unknown flag' error when any of the flags are used.
* - `reparse` {Boolean} Whether the `handler` function's output should not be treated as
* final, and instead be reparseable by other tokens (including the current token). Allows
* token chaining or deferring.
* - `leadChar` {String} Single character that occurs at the beginning of any successful match
* of the token (not always applicable). This doesn't change the behavior of the token unless
* you provide an erroneous value. However, providing it can increase the token's performance
* since the token can be skipped at any positions where this character doesn't appear.
* @example
*
* // Basic usage: Add \a for the ALERT control code
* XRegExp.addToken(
* /\\a/,
* () => '\\x07',
* {scope: 'all'}
* );
* XRegExp('\\a[\\a-\\n]+').test('\x07\n\x07'); // -> true
*
* // Add the U (ungreedy) flag from PCRE and RE2, which reverses greedy and lazy quantifiers.
* // Since `scope` is not specified, it uses 'default' (i.e., transformations apply outside of
* // character classes only)
* XRegExp.addToken(
* /([?*+]|{\d+(?:,\d*)?})(\??)/,
* (match) => `${match[1]}${match[2] ? '' : '?'}`,
* {flag: 'U'}
* );
* XRegExp('a+', 'U').exec('aaa')[0]; // -> 'a'
* XRegExp('a+?', 'U').exec('aaa')[0]; // -> 'aaa'
*/
XRegExp.addToken = function (regex, handler, options) {
options = options || {};
var _options = options,
optionalFlags = _options.optionalFlags;
if (options.flag) {
registerFlag(options.flag);
}
if (optionalFlags) {
optionalFlags = nativ.split.call(optionalFlags, '');
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = (0, _getIterator2.default)(optionalFlags), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var flag = _step2.value;
registerFlag(flag);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
} // Add to the private list of syntax tokens
tokens.push({
regex: copyRegex(regex, {
addG: true,
addY: hasNativeY,
isInternalOnly: true
}),
handler: handler,
scope: options.scope || defaultScope,
flag: options.flag,
reparse: options.reparse,
leadChar: options.leadChar
}); // Reset the pattern cache used by the `XRegExp` constructor, since the same pattern and flags
// might now produce different results
XRegExp.cache.flush('patterns');
};
/**
* Caches and returns the result of calling `XRegExp(pattern, flags)`. On any subsequent call with
* the same pattern and flag combination, the cached copy of the regex is returned.
*
* @memberOf XRegExp
* @param {String} pattern Regex pattern string.
* @param {String} [flags] Any combination of XRegExp flags.
* @returns {RegExp} Cached XRegExp object.
* @example
*
* while (match = XRegExp.cache('.', 'gs').exec(str)) {
* // The regex is compiled once only
* }
*/
XRegExp.cache = function (pattern, flags) {
if (!regexCache[pattern]) {
regexCache[pattern] = {};
}
return regexCache[pattern][flags] || (regexCache[pattern][flags] = XRegExp(pattern, flags));
}; // Intentionally undocumented; used in tests
XRegExp.cache.flush = function (cacheName) {
if (cacheName === 'patterns') {
// Flush the pattern cache used by the `XRegExp` constructor
patternCache = {};
} else {
// Flush the regex cache populated by `XRegExp.cache`
regexCache = {};
}
};
/**
* Escapes any regular expression metacharacters, for use when matching literal strings. The result
* can safely be used at any point within a regex that uses any flags.
*
* @memberOf XRegExp
* @param {String} str String to escape.
* @returns {String} String with regex metacharacters escaped.
* @example
*
* XRegExp.escape('Escaped? <.>');
* // -> 'Escaped\?\ <\.>'
*/
XRegExp.escape = function (str) {
return nativ.replace.call(toObject(str), /[-\[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
};
/**
* Executes a regex search in a specified string. Returns a match array or `null`. If the provided
* regex uses named capture, named backreference properties are included on the match array.
* Optional `pos` and `sticky` arguments specify the search start position, and whether the match
* must start at the specified position only. The `lastIndex` property of the provided regex is not
* used, but is updated for compatibility. Also fixes browser bugs compared to the native
* `RegExp.prototype.exec` and can be used reliably cross-browser.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {RegExp} regex Regex to search with.
* @param {Number} [pos=0] Zero-based index at which to start the search.
* @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
* only. The string `'sticky'` is accepted as an alternative to `true`.
* @returns {Array} Match array with named backreference properties, or `null`.
* @example
*
* // Basic use, with named backreference
* let match = XRegExp.exec('U+2620', XRegExp('U\\+(?<hex>[0-9A-F]{4})'));
* match.hex; // -> '2620'
*
* // With pos and sticky, in a loop
* let pos = 2, result = [], match;
* while (match = XRegExp.exec('<1><2><3><4>5<6>', /<(\d)>/, pos, 'sticky')) {
* result.push(match[1]);
* pos = match.index + match[0].length;
* }
* // result -> ['2', '3', '4']
*/
XRegExp.exec = function (str, regex, pos, sticky) {
var cacheKey = 'g';
var addY = false;
var fakeY = false;
var match;
addY = hasNativeY && !!(sticky || regex.sticky && sticky !== false);
if (addY) {
cacheKey += 'y';
} else if (sticky) {
// Simulate sticky matching by appending an empty capture to the original regex. The
// resulting regex will succeed no matter what at the current index (set with `lastIndex`),
// and will not search the rest of the subject string. We'll know that the original regex
// has failed if that last capture is `''` rather than `undefined` (i.e., if that last
// capture participated in the match).
fakeY = true;
cacheKey += 'FakeY';
}
regex[REGEX_DATA] = regex[REGEX_DATA] || {}; // Shares cached copies with `XRegExp.match`/`replace`
var r2 = regex[REGEX_DATA][cacheKey] || (regex[REGEX_DATA][cacheKey] = copyRegex(regex, {
addG: true,
addY: addY,
source: fakeY ? "".concat(regex.source, "|()") : undefined,
removeY: sticky === false,
isInternalOnly: true
}));
pos = pos || 0;
r2.lastIndex = pos; // Fixed `exec` required for `lastIndex` fix, named backreferences, etc.
match = fixed.exec.call(r2, str); // Get rid of the capture added by the pseudo-sticky matcher if needed. An empty string means
// the original regexp failed (see above).
if (fakeY && match && match.pop() === '') {
match = null;
}
if (regex.global) {
regex.lastIndex = match ? r2.lastIndex : 0;
}
return match;
};
/**
* Executes a provided function once per regex match. Searches always start at the beginning of the
* string and continue until the end, regardless of the state of the regex's `global` property and
* initial `lastIndex`.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {RegExp} regex Regex to search with.
* @param {Function} callback Function to execute for each match. Invoked with four arguments:
* - The match array, with named backreference properties.
* - The zero-based match index.
* - The string being traversed.
* - The regex object being used to traverse the string.
* @example
*
* // Extracts every other digit from a string
* const evens = [];
* XRegExp.forEach('1a2345', /\d/, (match, i) => {
* if (i % 2) evens.push(+match[0]);
* });
* // evens -> [2, 4]
*/
XRegExp.forEach = function (str, regex, callback) {
var pos = 0;
var i = -1;
var match;
while (match = XRegExp.exec(str, regex, pos)) {
// Because `regex` is provided to `callback`, the function could use the deprecated/
// nonstandard `RegExp.prototype.compile` to mutate the regex. However, since `XRegExp.exec`
// doesn't use `lastIndex` to set the search position, this can't lead to an infinite loop,
// at least. Actually, because of the way `XRegExp.exec` caches globalized versions of
// regexes, mutating the regex will not have any effect on the iteration or matched strings,
// which is a nice side effect that brings extra safety.
callback(match, ++i, str, regex);
pos = match.index + (match[0].length || 1);
}
};
/**
* Copies a regex object and adds flag `g`. The copy maintains extended data, is augmented with
* `XRegExp.prototype` properties, and has a fresh `lastIndex` property (set to zero). Native
* regexes are not recompiled using XRegExp syntax.
*
* @memberOf XRegExp
* @param {RegExp} regex Regex to globalize.
* @returns {RegExp} Copy of the provided regex with flag `g` added.
* @example
*
* const globalCopy = XRegExp.globalize(/regex/);
* globalCopy.global; // -> true
*/
XRegExp.globalize = function (regex) {
return copyRegex(regex, {
addG: true
});
};
/**
* Installs optional features according to the specified options. Can be undone using
* `XRegExp.uninstall`.
*
* @memberOf XRegExp
* @param {Object|String} options Options object or string.
* @example
*
* // With an options object
* XRegExp.install({
* // Enables support for astral code points in Unicode addons (implicitly sets flag A)
* astral: true,
*
* // Adds named capture groups to the `groups` property of matches
* namespacing: true
* });
*
* // With an options string
* XRegExp.install('astral namespacing');
*/
XRegExp.install = function (options) {
options = prepareOptions(options);
if (!features.astral && options.astral) {
setAstral(true);
}
if (!features.namespacing && options.namespacing) {
setNamespacing(true);
}
};
/**
* Checks whether an individual optional feature is installed.
*
* @memberOf XRegExp
* @param {String} feature Name of the feature to check. One of:
* - `astral`
* - `namespacing`
* @returns {Boolean} Whether the feature is installed.
* @example
*
* XRegExp.isInstalled('astral');
*/
XRegExp.isInstalled = function (feature) {
return !!features[feature];
};
/**
* Returns `true` if an object is a regex; `false` if it isn't. This works correctly for regexes
* created in another frame, when `instanceof` and `constructor` checks would fail.
*
* @memberOf XRegExp
* @param {*} value Object to check.
* @returns {Boolean} Whether the object is a `RegExp` object.
* @example
*
* XRegExp.isRegExp('string'); // -> false
* XRegExp.isRegExp(/regex/i); // -> true
* XRegExp.isRegExp(RegExp('^', 'm')); // -> true
* XRegExp.isRegExp(XRegExp('(?s).')); // -> true
*/
XRegExp.isRegExp = function (value) {
return toString.call(value) === '[object RegExp]';
}; // isType(value, 'RegExp');
/**
* Returns the first matched string, or in global mode, an array containing all matched strings.
* This is essentially a more convenient re-implementation of `String.prototype.match` that gives
* the result types you actually want (string instead of `exec`-style array in match-first mode,
* and an empty array instead of `null` when no matches are found in match-all mode). It also lets
* you override flag g and ignore `lastIndex`, and fixes browser bugs.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {RegExp} regex Regex to search with.
* @param {String} [scope='one'] Use 'one' to return the first match as a string. Use 'all' to
* return an array of all matched strings. If not explicitly specified and `regex` uses flag g,
* `scope` is 'all'.
* @returns {String|Array} In match-first mode: First match as a string, or `null`. In match-all
* mode: Array of all matched strings, or an empty array.
* @example
*
* // Match first
* XRegExp.match('abc', /\w/); // -> 'a'
* XRegExp.match('abc', /\w/g, 'one'); // -> 'a'
* XRegExp.match('abc', /x/g, 'one'); // -> null
*
* // Match all
* XRegExp.match('abc', /\w/g); // -> ['a', 'b', 'c']
* XRegExp.match('abc', /\w/, 'all'); // -> ['a', 'b', 'c']
* XRegExp.match('abc', /x/, 'all'); // -> []
*/
XRegExp.match = function (str, regex, scope) {
var global = regex.global && scope !== 'one' || scope === 'all';
var cacheKey = (global ? 'g' : '') + (regex.sticky ? 'y' : '') || 'noGY';
regex[REGEX_DATA] = regex[REGEX_DATA] || {}; // Shares cached copies with `XRegExp.exec`/`replace`
var r2 = regex[REGEX_DATA][cacheKey] || (regex[REGEX_DATA][cacheKey] = copyRegex(regex, {
addG: !!global,
removeG: scope === 'one',
isInternalOnly: true
}));
var result = nativ.match.call(toObject(str), r2);
if (regex.global) {
regex.lastIndex = scope === 'one' && result ? // Can't use `r2.lastIndex` since `r2` is nonglobal in this case
result.index + result[0].length : 0;
}
return global ? result || [] : result && result[0];
};
/**
* Retrieves the matches from searching a string using a chain of regexes that successively search
* within previous matches. The provided `chain` array can contain regexes and or objects with
* `regex` and `backref` properties. When a backreference is specified, the named or numbered
* backreference is passed forward to the next regex or returned.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {Array} chain Regexes that each search for matches within preceding results.
* @returns {Array} Matches by the last regex in the chain, or an empty array.
* @example
*
* // Basic usage; matches numbers within <b> tags
* XRegExp.matchChain('1 <b>2</b> 3 <b>4 a 56</b>', [
* XRegExp('(?is)<b>.*?</b>'),
* /\d+/
* ]);
* // -> ['2', '4', '56']
*
* // Passing forward and returning specific backreferences
* html = '<a href="http://xregexp.com/api/">XRegExp</a>\
* <a href="http://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']
*/
XRegExp.matchChain = function (str, chain) {
return function recurseChain(values, level) {
var item = chain[level].regex ? chain[level] : {
regex: chain[level]
};
var matches = [];
function addMatch(match) {
if (item.backref) {
var ERR_UNDEFINED_GROUP = "Backreference to undefined group: ".concat(item.backref);
var isNamedBackref = isNaN(item.backref);
if (isNamedBackref && XRegExp.isInstalled('namespacing')) {
// `groups` has `null` as prototype, so using `in` instead of `hasOwnProperty`
if (!(item.backref in match.groups)) {
throw new ReferenceError(ERR_UNDEFINED_GROUP);
}
} else if (!match.hasOwnProperty(item.backref)) {
throw new ReferenceError(ERR_UNDEFINED_GROUP);
}
var backrefValue = isNamedBackref && XRegExp.isInstalled('namespacing') ? match.groups[item.backref] : match[item.backref];
matches.push(backrefValue || '');
} else {
matches.push(match[0]);
}
}
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = (0, _getIterator2.default)(values), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var value = _step3.value;
(0, _forEach.default)(XRegExp).call(XRegExp, value, item.regex, addMatch);
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return level === chain.length - 1 || !matches.length ? matches : recurseChain(matches, level + 1);
}([str], 0);
};
/**
* Returns a new string with one or all matches of a pattern replaced. The pattern can be a string
* or regex, and the replacement can be a string or a function to be called for each match. To
* perform a global search and replace, use the optional `scope` argument or include flag g if using
* a regex. Replacement strings can use `${n}` or `$<n>` for named and numbered backreferences.
* Replacement functions can use named backreferences via `arguments[0].name`. Also fixes browser
* bugs compared to the native `String.prototype.replace` and can be used reliably cross-browser.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {RegExp|String} search Search pattern to be replaced.
* @param {String|Function} replacement Replacement string or a function invoked to create it.
* Replacement strings can include special replacement syntax:
* - $$ - Inserts a literal $ character.
* - $&, $0 - Inserts the matched substring.
* - $` - Inserts the string that precedes the matched substring (left context).
* - $' - Inserts the string that follows the matched substring (right context).
* - $n, $nn - Where n/nn are digits referencing an existent capturing group, inserts
* backreference n/nn.
* - ${n}, $<n> - Where n is a name or any number of digits that reference an existent capturing
* group, inserts backreference n.
* Replacement functions are invoked with three or more arguments:
* - The matched substring (corresponds to $& above). Named backreferences are accessible as
* properties of this first argument.
* - 0..n arguments, one for each backreference (corresponding to $1, $2, etc. above).
* - The zero-based index of the match within the total search string.
* - The total string being searched.
* @param {String} [scope='one'] Use 'one' to replace the first match only, or 'all'. If not
* explicitly specified and using a regex with flag g, `scope` is 'all'.
* @returns {String} New string with one or all matches replaced.
* @example
*
* // Regex search, using named backreferences in replacement string
* const name = XRegExp('(?<first>\\w+) (?<last>\\w+)');
* XRegExp.replace('John Smith', name, '$<last>, $<first>');
* // -> 'Smith, John'
*
* // Regex search, using named backreferences in replacement function
* XRegExp.replace('John Smith', name, (match) => `${match.last}, ${match.first}`);
* // -> 'Smith, John'
*
* // String search, with replace-all
* XRegExp.replace('RegExp builds RegExps', 'RegExp', 'XRegExp', 'all');
* // -> 'XRegExp builds XRegExps'
*/
XRegExp.replace = function (str, search, replacement, scope) {
var isRegex = XRegExp.isRegExp(search);
var global = search.global && scope !== 'one' || scope === 'all';
var cacheKey = (global ? 'g' : '') + (search.sticky ? 'y' : '') || 'noGY';
var s2 = search;
if (isRegex) {
search[REGEX_DATA] = search[REGEX_DATA] || {}; // Shares cached copies with `XRegExp.exec`/`match`. Since a copy is used, `search`'s
// `lastIndex` isn't updated *during* replacement iterations
s2 = search[REGEX_DATA][cacheKey] || (search[REGEX_DATA][cacheKey] = copyRegex(search, {
addG: !!global,
removeG: scope === 'one',
isInternalOnly: true
}));
} else if (global) {
s2 = new RegExp(XRegExp.escape(String(search)), 'g');
} // Fixed `replace` required for named backreferences, etc.
var result = fixed.replace.call(toObject(str), s2, replacement);
if (isRegex && search.global) {
// Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
search.lastIndex = 0;
}
return result;
};
/**
* Performs batch processing of string replacements. Used like `XRegExp.replace`, but accepts an
* array of replacement details. Later replacements operate on the output of earlier replacements.
* Replacement details are accepted as an array with a regex or string to search for, the
* replacement string or function, and an optional scope of 'one' or 'all'. Uses the XRegExp
* replacement text syntax, which supports named backreference properties via `${name}` or
* `$<name>`.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {Array} replacements Array of replacement detail arrays.
* @returns {String} New string with all replacements.
* @example
*
* str = XRegExp.replaceEach(str, [
* [XRegExp('(?<name>a)'), 'z${name}'],
* [/b/gi, 'y'],
* [/c/g, 'x', 'one'], // scope 'one' overrides /g
* [/d/, 'w', 'all'], // scope 'all' overrides lack of /g
* ['e', 'v', 'all'], // scope 'all' allows replace-all for strings
* [/f/g, ($0) => $0.toUpperCase()]
* ]);
*/
XRegExp.replaceEach = function (str, replacements) {
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 = (0, _getIterator2.default)(replacements), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var r = _step4.value;
str = XRegExp.replace(str, r[0], r[1], r[2]);
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
return str;
};
/**
* Splits a string into an array of strings using a regex or string separator. Matches of the
* separator are not included in the result array. However, if `separator` is a regex that contains
* capturing groups, backreferences are spliced into the result each time `separator` is matched.
* Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
* cross-browser.
*
* @memberOf XRegExp
* @param {String} str String to split.
* @param {RegExp|String} separator Regex or string to use for separating the string.
* @param {Number} [limit] Maximum number of items to include in the result array.
* @returns {Array} Array of substrings.
* @example
*
* // Basic use
* XRegExp.split('a b c', ' ');
* // -> ['a', 'b', 'c']
*
* // With limit
* XRegExp.split('a b c', ' ', 2);
* // -> ['a', 'b']
*
* // Backreferences in result array
* XRegExp.split('..word1..', /([a-z]+)(\d+)/i);
* // -> ['..', 'word', '1', '..']
*/
XRegExp.split = function (str, separator, limit) {
return fixed.split.call(toObject(str), separator, limit);
};
/**
* Executes a regex search in a specified string. Returns `true` or `false`. Optional `pos` and
* `sticky` arguments specify the search start position, and whether the match must start at the
* specified position only. The `lastIndex` property of the provided regex is not used, but is
* updated for compatibility. Also fixes browser bugs compared to the native
* `RegExp.prototype.test` and can be used reliably cross-browser.
*
* @memberOf XRegExp
* @param {String} str String to search.
* @param {RegExp} regex Regex to search with.
* @param {Number} [pos=0] Zero-based index at which to start the search.
* @param {Boolean|String} [sticky=false] Whether the match must start at the specified position
* only. The string `'sticky'` is accepted as an alternative to `true`.
* @returns {Boolean} Whether the regex matched the provided value.
* @example
*
* // Basic use
* XRegExp.test('abc', /c/); // -> true
*
* // With pos and sticky
* XRegExp.test('abc', /c/, 0, 'sticky'); // -> false
* XRegExp.test('abc', /c/, 2, 'sticky'); // -> true
*/
// Do this the easy way :-)
XRegExp.test = function (str, regex, pos, sticky) {
return !!XRegExp.exec(str, regex, pos, sticky);
};
/**
* Uninstalls optional features according to the specified options. All optional features start out
* uninstalled, so this is used to undo the actions of `XRegExp.install`.
*
* @memberOf XRegExp
* @param {Object|String} options Options object or string.
* @example
*
* // With an options object
* XRegExp.uninstall({
* // Disables support for astral code points in Unicode addons
* astral: true,
*
* // Don't add named capture groups to the `groups` property of matches
* namespacing: true
* });
*
* // With an options string
* XRegExp.uninstall('astral namespacing');
*/
XRegExp.uninstall = function (options) {
options = prepareOptions(options);
if (features.astral && options.astral) {
setAstral(false);
}
if (features.namespacing && options.namespacing) {
setNamespacing(false);
}
};
/**
* Returns an XRegExp object that is the union of the given patterns. Patterns can be provided as
* regex objects or strings. Metacharacters are escaped in patterns provided as strings.
* Backreferences in provided regex objects are automatically renumbered to work correctly within
* the larger combined pattern. Native flags used by provided regexes are ignored in favor of the
* `flags` argument.
*
* @memberOf XRegExp
* @param {Array} patterns Regexes and strings to combine.
* @param {String} [flags] Any combination of XRegExp flags.
* @param {Object} [options] Options object with optional properties:
* - `conjunction` {String} Type of conjunction to use: 'or' (default) or 'none'.
* @returns {RegExp} Union of the provided regexes and strings.
* @example
*
* XRegExp.union(['a+b*c', /(dogs)\1/, /(cats)\1/], 'i');
* // -> /a\+b\*c|(dogs)\1|(cats)\2/i
*
* XRegExp.union([/man/, /bear/, /pig/], 'i', {conjunction: 'none'});
* // -> /manbearpig/i
*/
XRegExp.union = function (patterns, flags, options) {
options = options || {};
var conjunction = options.conjunction || 'or';
var numCaptures = 0;
var numPriorCaptures;
var captureNames;
function rewrite(match, paren, backref) {
var name = captureNames[numCaptures - numPriorCaptures]; // Capturing group
if (paren) {
++numCaptures; // If the current capture has a name, preserve the name
if (name) {
return "(?<".concat(name, ">");
} // Backreference
} else if (backref) {
// Rewrite the backreference
return "\\".concat(+backref + numPriorCaptures);
}
return match;
}
if (!(isType(patterns, 'Array') && patterns.length)) {
throw new TypeError('Must provide a nonempty array of patterns to merge');
}
var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
var output = [];
var _iteratorNormalCompletion5 = true;
var _didIteratorError5 = false;
var _iteratorError5 = undefined;
try {
for (var _iterator5 = (0, _getIterator2.default)(patterns), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
var pattern = _step5.value;
if (XRegExp.isRegExp(pattern)) {
numPriorCaptures = numCaptures;
captureNames = pattern[REGEX_DATA] && pattern[REGEX_DATA].captureNames || []; // Rewrite backreferences. Passing to XRegExp dies on octals and ensures patterns are
// independently valid; helps keep this simple. Named captures are put back
output.push(nativ.replace.call(XRegExp(pattern.source).source, parts, rewrite));
} else {
output.push(XRegExp.escape(pattern));
}
}
} catch (err) {
_didIteratorError5 = true;
_iteratorError5 = err;
} finally {
try {
if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
_iterator5.return();
}
} finally {
if (_didIteratorError5) {
throw _iteratorError5;
}
}
}
var separator = conjunction === 'none' ? '' : '|';
return XRegExp(output.join(separator), flags);
}; // ==--------------------------==
// Fixed/extended native methods
// ==--------------------------==
/**
* Adds named capture support (with backreferences returned as `result.name`), and fixes browser
* bugs in the native `RegExp.prototype.exec`. Use via `XRegExp.exec`.
*
* @memberOf RegExp
* @param {String} str String to search.
* @returns {Array} Match array with named backreference properties, or `null`.
*/
fixed.exec = function (str) {
var origLastIndex = this.lastIndex;
var match = nativ.exec.apply(this, arguments);
if (match) {
// Fix browsers whose `exec` methods don't return `undefined` for nonparticipating capturing
// groups. This fixes IE 5.5-8, but not IE 9's quirks mode or emulation of older IEs. IE 9
// in standards mode follows the spec.
if (!correctExecNpcg && match.length > 1 && (0, _includes.default)(match).call(match, '')) {
var _context3;
var r2 = copyRegex(this, {
removeG: true,
isInternalOnly: true
}); // Using `str.slice(match.index)` rather than `match[0]` in case lookahead allowed
// matching due to characters outside the match
nativ.replace.call((0, _slice.default)(_context3 = String(str)).call(_context3, match.index), r2, function () {
var len = arguments.length; // Skip index 0 and the last 2
for (var i = 1; i < len - 2; ++i) {
if ((i < 0 || arguments.length <= i ? undefined : arguments[i]) === undefined) {
match[i] = undefined;
}
}
});
} // Attach named capture properties
var groupsObject = match;
if (XRegExp.isInstalled('namespacing')) {
// https://tc39.github.io/proposal-regexp-named-groups/#sec-regexpbuiltinexec
match.groups = (0, _create.default)(null);
groupsObject = match.groups;
}
if (this[REGEX_DATA] && this[REGEX_DATA].captureNames) {
// Skip index 0
for (var i = 1; i < match.length; ++i) {
var name = this[REGEX_DATA].captureNames[i - 1];
if (name) {
groupsObject[name] = match[i];
}
}
} // Fix browsers that increment `lastIndex` after zero-length matches
if (this.global && !match[0].length && this.lastIndex > match.index) {
this.lastIndex = match.index;
}
}
if (!this.global) {
// Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
this.lastIndex = origLastIndex;
}
return match;
};
/**
* Fixes browser bugs in the native `RegExp.prototype.test`.
*
* @memberOf RegExp
* @param {String} str String to search.
* @returns {Boolean} Whether the regex matched the provided value.
*/
fixed.test = function (str) {
// Do this the easy way :-)
return !!fixed.exec.call(this, str);
};
/**
* Adds named capture support (with backreferences returned as `result.name`), and fixes browser
* bugs in the native `String.prototype.match`.
*
* @memberOf String
* @param {RegExp|*} regex Regex to search with. If not a regex object, it is passed to `RegExp`.
* @returns {Array} If `regex` uses flag g, an array of match strings or `null`. Without flag g,
* the result of calling `regex.exec(this)`.
*/
fixed.match = function (regex) {
if (!XRegExp.isRegExp(regex)) {
// Use the native `RegExp` rather than `XRegExp`
regex = new RegExp(regex);
} else if (regex.global) {
var result = nativ.match.apply(this, arguments); // Fixes IE bug
regex.lastIndex = 0;
return result;
}
return fixed.exec.call(regex, toObject(this));
};
/**
* Adds support for `${n}` (or `$<n>`) tokens for named and numbered backreferences in replacement
* text, and provides named backreferences to replacement functions as `arguments[0].name`. Also
* fixes browser bugs in replacement text syntax when performing a replacement using a nonregex
* search value, and the value of a replacement regex's `lastIndex` property during replacement
* iterations and upon completion. Note that this doesn't support SpiderMonkey's proprietary third
* (`flags`) argument. Use via `XRegExp.replace`.
*
* @memberOf String
* @param {RegExp|String} search Search pattern to be replaced.
* @param {String|Function} replacement Replacement string or a function invoked to create it.
* @returns {String} New string with one or all matches replaced.
*/
fixed.replace = function (search, replacement) {
var isRegex = XRegExp.isRegExp(search);
var origLastIndex;
var captureNames;
var result;
if (isRegex) {
if (search[REGEX_DATA]) {
captureNames = search[REGEX_DATA].captureNames;
} // Only needed if `search` is nonglobal
origLastIndex = search.lastIndex;
} else {
search += ''; // Type-convert
} // Don't use `typeof`; some older browsers return 'function' for regex objects
if (isType(replacement, 'Function')) {
// Stringifying `this` fixes a bug in IE < 9 where the last argument in replacement
// functions isn't type-converted to a string
result = nativ.replace.call(String(this), search, function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
if (captureNames) {
var groupsObject;
if (XRegExp.isInstalled('namespacing')) {
// https://tc39.github.io/proposal-regexp-named-groups/#sec-regexpbuiltinexec
groupsObject = (0, _create.default)(null);
args.push(groupsObject);
} else {
// Change the `args[0]` string primitive to a `String` object that can store
// properties. This really does need to use `String` as a constructor
args[0] = new String(args[0]);
groupsObject = args[0];
} // Store named backreferences
for (var i = 0; i < captureNames.length; ++i) {
if (captureNames[i]) {
groupsObject[captureNames[i]] = args[i + 1];
}
}
} // Update `lastIndex` before calling `replacement`. Fixes IE, Chrome, Firefox, Safari
// bug (last tested IE 9, Chrome 17, Firefox 11, Safari 5.1)
if (isRegex && search.global) {
search.lastIndex = args[args.length - 2] + args[0].length;
} // ES6 specs the context for replacement functions as `undefined`
return replacement.apply(void 0, args);
});
} else {
// Ensure that the last value of `args` will be a string when given nonstring `this`,
// while still throwing on null or undefined context
result = nativ.replace.call(this == null ? this : String(this), search, function () {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return nativ.replace.call(String(replacement), replacementToken, replacer);
function replacer($0, bracketed, angled, dollarToken) {
bracketed = bracketed || angled; // Named or numbered backreference with curly or angled braces
if (bracketed) {
// XRegExp behavior for `${n}` or `$<n>`:
// 1. Backreference to numbered capture, if `n` is an integer. Use `0` for the
// entire match. Any number of leading zeros may be used.
// 2. Backreference to named capture `n`, if it exists and is not an integer
// overridden by numbered capture. In practice, this does not overlap with
// numbered capture since XRegExp does not allow named capture to use a bare
// integer as the name.
// 3. If the name or number does not refer to an existing capturing group, it's
// an error.
var n = +bracketed; // Type-convert; drop leading zeros
if (n <= args.length - 3) {
return args[n] || '';
} // Groups with the same name is an error, else would need `lastIndexOf`
n = captureNames ? (0, _indexOf.default)(captureNames).call(captureNames, bracketed) : -1;
if (n < 0) {
throw new SyntaxError("Backreference to undefined group ".concat($0));
}
return args[n + 1] || '';
} // Else, special variable or numbered backreference without curly braces
if (dollarToken === '$') {
// $$
return '$';
}
if (dollarToken === '&' || +dollarToken === 0) {
// $&, $0 (not followed by 1-9), $00
return args[0];
}
if (dollarToken === '`') {
var _context4;
// $` (left context)
return (0, _slice.default)(_context4 = args[args.length - 1]).call(_context4, 0, args[args.length - 2]);
}
if (dollarToken === "'") {
var _context5;
// $' (right context)
return (0, _slice.default)(_context5 = args[args.length - 1]).call(_context5, args[args.length - 2] + args[0].length);
} // Else, numbered backreference without braces
dollarToken = +dollarToken; // Type-convert; drop leading zero
// XRegExp behavior for `$n` and `$nn`:
// - Backrefs end after 1 or 2 digits. Use `${..}` or `$<..>` for more digits.
// - `$1` is an error if no capturing groups.
// - `$10` is an error if less than 10 capturing groups. Use `${1}0` or `$<1>0`
// instead.
// - `$01` is `$1` if at least one capturing group, else it's an error.
// - `$0` (not followed by 1-9) and `$00` are the entire match.
// Native behavior, for comparison:
// - Backrefs end after 1 or 2 digits. Cannot reference capturing group 100+.
// - `$1` is a literal `$1` if no capturing groups.
// - `$10` is `$1` followed by a literal `0` if less than 10 capturing groups.
// - `$01` is `$1` if at least one capturing group, else it's a literal `$01`.
// - `$0` is a literal `$0`.
if (!isNaN(dollarToken)) {
if (dollarToken > args.length - 3) {
throw new SyntaxError("Backreference to undefined group ".concat($0));
}
return args[dollarToken] || '';
} // `$` followed by an unsupported char is an error, unlike native JS
throw new SyntaxError("Invalid token ".concat($0));
}
});
}
if (isRegex) {
if (search.global) {
// Fixes IE, Safari bug (last tested IE 9, Safari 5.1)
search.lastIndex = 0;
} else {
// Fixes IE, Opera bug (last tested IE 9, Opera 11.6)
search.lastIndex = origLastIndex;
}
}
return result;
};
/**
* Fixes browser bugs in the native `String.prototype.split`. Use via `XRegExp.split`.
*
* @memberOf String
* @param {RegExp|String} separator Regex or string to use for separating the string.
* @param {Number} [limit] Maximum number of items to include in the result array.
* @returns {Array} Array of substrings.
*/
fixed.split = function (separator, limit) {
if (!XRegExp.isRegExp(separator)) {
// Browsers handle nonregex split correctly, so use the faster native method
return nativ.split.apply(this, arguments);
}
var str = String(this);
var output = [];
var origLastIndex = separator.lastIndex;
var lastLastIndex = 0;
var lastLength; // Values for `limit`, per the spec:
// If undefined: pow(2,32) - 1
// If 0, Infinity, or NaN: 0
// If positive number: limit = floor(limit); if (limit >= pow(2,32)) limit -= pow(2,32);
// If negative number: pow(2,32) - floor(abs(limit))
// If other: Type-convert, then use the above rules
// This line fails in very strange ways for some values of `limit` in Opera 10.5-10.63, unless
// Opera Dragonfly is open (go figure). It works in at least Opera 9.5-10.1 and 11+
limit = (limit === undefined ? -1 : limit) >>> 0;
(0, _forEach.default)(XRegExp).call(XRegExp, str, separator, function (match) {
// This condition is not the same as `if (match[0].length)`
if (match.index + match[0].length > lastLastIndex) {
output.push((0, _slice.default)(str).call(str, lastLastIndex, match.index));
if (match.length > 1 && match.index < str.length) {
Array.prototype.push.apply(output, (0, _slice.default)(match).call(match, 1));
}
lastLength = match[0].length;
lastLastIndex = match.index + lastLength;
}
});
if (lastLastIndex === str.length) {
if (!nativ.test.call(separator, '') || lastLength) {
output.push('');
}
} else {
output.push((0, _slice.default)(str).call(str, lastLastIndex));
}
separator.lastIndex = origLastIndex;
return output.length > limit ? (0, _slice.default)(output).call(output, 0, limit) : output;
}; // ==--------------------------==
// Built-in syntax/flag tokens
// ==--------------------------==
/*
* Letter escapes that natively match literal characters: `\a`, `\A`, etc. These should be
* SyntaxErrors but are allowed in web reality. XRegExp makes them errors for cross-browser
* consistency and to reserve their syntax, but lets them be superseded by addons.
*/
XRegExp.addToken(/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4}|{[\dA-Fa-f]+})|x(?![\dA-Fa-f]{2}))/, function (match, scope) {
// \B is allowed in default scope only
if (match[1] === 'B' && scope === defaultScope) {
return match[0];
}
throw new SyntaxError("Invalid escape ".concat(match[0]));
}, {
scope: 'all',
leadChar: '\\'
});
/*
* Unicode code point escape with curly braces: `\u{N..}`. `N..` is any one or more digit
* hexadecimal number from 0-10FFFF, and can include leading zeros. Requires the native ES6 `u` flag
* to support code points greater than U+FFFF. Avoids converting code points above U+FFFF to
* surrogate pairs (which could be done without flag `u`), since that could lead to broken behavior
* if you follow a `\u{N..}` token that references a code point above U+FFFF with a quantifier, or
* if you use the same in a character class.
*/
XRegExp.addToken(/\\u{([\dA-Fa-f]+)}/, function (match, scope, flags) {
var code = dec(match[1]);
if (code > 0x10FFFF) {
throw new SyntaxError("Invalid Unicode code point ".concat(match[0]));
}
if (code <= 0xFFFF) {
// Converting to \uNNNN avoids needing to escape the literal character and keep it
// separate from preceding tokens
return "\\u".concat(pad4(hex(code)));
} // If `code` is between 0xFFFF and 0x10FFFF, require and defer to native handling
if (hasNativeU && (0, _includes.default)(flags).call(flags, 'u')) {
return match[0];
}
throw new SyntaxError('Cannot use Unicode code point above \\u{FFFF} without flag u');
}, {
scope: 'all',
leadChar: '\\'
});
/*
* Empty character class: `[]` or `[^]`. This fixes a critical cross-browser syntax inconsistency.
* Unless this is standardized (per the ES spec), regex syntax can't be accurately parsed because
* character class endings can't be determined.
*/
XRegExp.addToken(/\[(\^?)\]/, // For cross-browser compatibility with ES3, convert [] to \b\B and [^] to [\s\S].
// (?!) should work like \b\B, but is unreliable in some versions of Firefox
/* eslint-disable no-confusing-arrow */
function (match) {
return match[1] ? '[\\s\\S]' : '\\b\\B';
},
/* eslint-enable no-confusing-arrow */
{
leadChar: '['
});
/*
* Comment pattern: `(?# )`. Inline comments are an alternative to the line comments allowed in
* free-spacing mode (flag x).
*/
XRegExp.addToken(/\(\?#[^)]*\)/, getContextualTokenSeparator, {
leadChar: '('
});
/*
* Whitespace and line comments, in free-spacing mode (aka extended mode, flag x) only.
*/
XRegExp.addToken(/\s+|#[^\n]*\n?/, getContextualTokenSeparator, {
flag: 'x'
});
/*
* Dot, in dotall mode (aka singleline mode, flag s) only.
*/
XRegExp.addToken(/\./, function () {
return '[\\s\\S]';
}, {
flag: 's',
leadChar: '.'
});
/*
* Named backreference: `\k<name>`. Backreference names can use the characters A-Z, a-z, 0-9, _,
* and $ only. Also allows numbered backreferences as `\k<n>`.
*/
XRegExp.addToken(/\\k<([\w$]+)>/, function (match) {
var _context6, _context7;
// Groups with the same name is an error, else would need `lastIndexOf`
var index = isNaN(match[1]) ? (0, _indexOf.default)(_context6 = this.captureNames).call(_context6, match[1]) + 1 : +match[1];
var endIndex = match.index + match[0].length;
if (!index || index > this.captureNames.length) {
throw new SyntaxError("Backreference to undefined group ".concat(match[0]));
} // Keep backreferences separate from subsequent literal numbers. This avoids e.g.
// inadvertedly changing `(?<n>)\k<n>1` to `()\11`.
return (0, _concat.default)(_context7 = "\\".concat(index)).call(_context7, endIndex === match.input.length || isNaN(match.input[endIndex]) ? '' : '(?:)');
}, {
leadChar: '\\'
});
/*
* Numbered backreference or octal, plus any following digits: `\0`, `\11`, etc. Octals except `\0`
* not followed by 0-9 and backreferences to unopened capture groups throw an error. Other matches
* are returned unaltered. IE < 9 doesn't support backreferences above `\99` in regex syntax.
*/
XRegExp.addToken(/\\(\d+)/, function (match, scope) {
if (!(scope === defaultScope && /^[1-9]/.test(match[1]) && +match[1] <= this.captureNames.length) && match[1] !== '0') {
throw new SyntaxError("Cannot use octal escape or backreference to undefined group ".concat(match[0]));
}
return match[0];
}, {
scope: 'all',
leadChar: '\\'
});
/*
* Named capturing group; match the opening delimiter only: `(?<name>`. Capture names can use the
* characters A-Z, a-z, 0-9, _, and $ only. Names can't be integers. Supports Python-style
* `(?P<name>` as an alternate syntax to avoid issues in some older versions of Opera which natively
* supported the Python-style syntax. Otherwise, XRegExp might treat numbered backreferences to
* Python-style named capture as octals.
*/
XRegExp.addToken(/\(\?P?<([\w$]+)>/, function (match) {
var _context8;
// Disallow bare integers as names because named backreferences are added to match arrays
// and therefore numeric properties may lead to incorrect lookups
if (!isNaN(match[1])) {
throw new SyntaxError("Cannot use integer as capture name ".concat(match[0]));
}
if (!XRegExp.isInstalled('namespacing') && (match[1] === 'length' || match[1] === '__proto__')) {
throw new SyntaxError("Cannot use reserved word as capture name ".concat(match[0]));
}
if ((0, _includes.default)(_context8 = this.captureNames).call(_context8, match[1])) {
throw new SyntaxError("Cannot use same name for multiple groups ".concat(match[0]));
}
this.captureNames.push(match[1]);
this.hasNamedCapture = true;
return '(';
}, {
leadChar: '('
});
/*
* Capturing group; match the opening parenthesis only. Required for support of named capturing
* groups. Also adds explicit capture mode (flag n).
*/
XRegExp.addToken(/\((?!\?)/, function (match, scope, flags) {
if ((0, _includes.default)(flags).call(flags, 'n')) {
return '(?:';
}
this.captureNames.push(null);
return '(';
}, {
optionalFlags: 'n',
leadChar: '('
});
var _default = XRegExp;
exports.default = _default;
module.exports = exports["default"];