| /*! |
| * 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 |
| const REGEX_DATA = 'xregexp'; |
| // Optional features that can be installed and uninstalled |
| const features = { |
| astral: false, |
| namespacing: false |
| }; |
| // Native methods to use and restore ('native' is an ES3 reserved keyword) |
| const 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 |
| const fixed = {}; |
| // Storage for regexes cached by `XRegExp.cache` |
| let regexCache = {}; |
| // Storage for pattern details cached by the `XRegExp` constructor |
| let patternCache = {}; |
| // Storage for regex syntax tokens added internally or by `XRegExp.addToken` |
| const tokens = []; |
| // Token scopes |
| const defaultScope = 'default'; |
| const classScope = 'class'; |
| // Regexes that match native regex syntax, including octals |
| const 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 |
| const replacementToken = /\$(?:{([\w$]+)}|<([\w$]+)>|(\d\d?|[\s\S]))/g; |
| // Check for correct `exec` handling of nonparticipating capturing groups |
| const correctExecNpcg = nativ.exec.call(/()??/, '')[1] === undefined; |
| // Check for ES6 `flags` prop support |
| const hasFlagsProp = /x/.flags !== undefined; |
| // Shortcut to `Object.prototype.toString` |
| const {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) |
| let 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 |
| const hasNativeU = hasNativeFlag('u'); |
| // Check for ES6 `y` flag support |
| const hasNativeY = hasNativeFlag('y'); |
| // Tracker for known flags, including addon flags |
| const 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) { |
| regex[REGEX_DATA] = { |
| 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 (const 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 ? xFlags.split('').sort().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) { |
| if (!XRegExp.isRegExp(regex)) { |
| throw new TypeError('Type RegExp expected'); |
| } |
| |
| const xData = regex[REGEX_DATA] || {}; |
| let flags = getNativeFlags(regex); |
| let flagsToAdd = ''; |
| let flagsToRemove = ''; |
| let xregexpSource = null; |
| let xregexpFlags = null; |
| |
| options = options || {}; |
| |
| if (options.removeG) {flagsToRemove += 'g';} |
| if (options.removeY) {flagsToRemove += 'y';} |
| if (flagsToRemove) { |
| flags = nativ.replace.call(flags, new RegExp(`[${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 (xData.flags != 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(xData.flags + flagsToAdd) : xData.flags; |
| } |
| } |
| |
| // 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) ? xData.captureNames.slice(0) : null, |
| xregexpSource, |
| xregexpFlags, |
| options.isInternalOnly |
| ); |
| |
| return regex; |
| } |
| |
| /** |
| * Converts hexadecimal to decimal. |
| * |
| * @private |
| * @param {String} hex |
| * @returns {Number} |
| */ |
| function dec(hex) { |
| return parseInt(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 ? |
| regex.flags : |
| // 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 parseInt(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) { |
| const inlineCommentPattern = '\\(\\?#[^)]*\\)'; |
| const lineCommentPattern = '#[^#\\n]*'; |
| const quantifierPattern = '[?*+]|{\\d+(?:,\\d*)?}'; |
| return nativ.test.call( |
| flags.includes('x') ? |
| // Ignore any leading whitespace, line comments, and inline comments |
| new RegExp(`^(?:\\s|${lineCommentPattern}|${inlineCommentPattern})*(?:${quantifierPattern})`) : |
| // Ignore any leading inline comments |
| new RegExp(`^(?:${inlineCommentPattern})*(?:${quantifierPattern})`), |
| pattern.slice(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 ${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${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 ${flags}`); |
| } |
| |
| // Strip and apply a leading mode modifier with any combination of flags except g or y |
| pattern = nativ.replace.call(pattern, /^\(\?([\w$]+)\)/, ($0, $1) => { |
| if (nativ.test.call(/[gy]/, $1)) { |
| throw new SyntaxError(`Cannot use flag g or y in mode modifier ${$0}`); |
| } |
| // Allow duplicate flags within the mode modifier |
| flags = clipDuplicates(flags + $1); |
| return ''; |
| }); |
| |
| // Throw on unknown native or nonnative flags |
| for (const flag of flags) { |
| if (!registeredFlags[flag]) { |
| throw new SyntaxError(`Unknown regex flag ${flag}`); |
| } |
| } |
| |
| return { |
| pattern, |
| 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) { |
| const options = {}; |
| |
| if (isType(value, 'String')) { |
| XRegExp.forEach(value, /[^\s,]+/, (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) { |
| let i = tokens.length; |
| const leadChar = pattern[pos]; |
| let result = null; |
| let match; |
| let 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 && !flags.includes(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') && !flags.includes('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]) { |
| const context = { |
| hasNamedCapture: false, |
| captureNames: [] |
| }; |
| let scope = defaultScope; |
| let output = ''; |
| let pos = 0; |
| let result; |
| |
| // Check for flag-related errors, and strip/apply flags in a leading mode modifier |
| const applied = prepareFlags(pattern, flags); |
| let appliedPattern = applied.pattern; |
| const appliedFlags = applied.flags; |
| |
| // 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 = appliedPattern.slice(0, pos) + |
| result.output + |
| appliedPattern.slice(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 |
| const [token] = XRegExp.exec(appliedPattern, nativeTokens[scope], pos, 'sticky'); |
| 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 |
| }; |
| } |
| |
| const generated = patternCache[pattern][flags]; |
| return augment( |
| new RegExp(generated.pattern, generated.flags), |
| generated.captures, |
| pattern, |
| flags |
| ); |
| } |
| |
| // Add `RegExp.prototype` to the prototype chain |
| XRegExp.prototype = new RegExp(); |
| |
| // ==--------------------------== |
| // 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 = (regex, handler, options) => { |
| options = options || {}; |
| let {optionalFlags} = options; |
| |
| if (options.flag) { |
| registerFlag(options.flag); |
| } |
| |
| if (optionalFlags) { |
| optionalFlags = nativ.split.call(optionalFlags, ''); |
| for (const flag of optionalFlags) { |
| registerFlag(flag); |
| } |
| } |
| |
| // Add to the private list of syntax tokens |
| tokens.push({ |
| regex: copyRegex(regex, { |
| addG: true, |
| addY: hasNativeY, |
| isInternalOnly: true |
| }), |
| 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 = (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 = (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 = (str) => 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 = (str, regex, pos, sticky) => { |
| let cacheKey = 'g'; |
| let addY = false; |
| let fakeY = false; |
| let 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` |
| const r2 = regex[REGEX_DATA][cacheKey] || ( |
| regex[REGEX_DATA][cacheKey] = copyRegex(regex, { |
| addG: true, |
| addY, |
| source: fakeY ? `${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 = (str, regex, callback) => { |
| let pos = 0; |
| let i = -1; |
| let 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 = (regex) => 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 = (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 = (feature) => !!(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 = (value) => 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 = (str, regex, scope) => { |
| const global = (regex.global && scope !== 'one') || scope === 'all'; |
| const cacheKey = ((global ? 'g' : '') + (regex.sticky ? 'y' : '')) || 'noGY'; |
| |
| regex[REGEX_DATA] = regex[REGEX_DATA] || {}; |
| |
| // Shares cached copies with `XRegExp.exec`/`replace` |
| const r2 = regex[REGEX_DATA][cacheKey] || ( |
| regex[REGEX_DATA][cacheKey] = copyRegex(regex, { |
| addG: !!global, |
| removeG: scope === 'one', |
| isInternalOnly: true |
| }) |
| ); |
| |
| const 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 = (str, chain) => (function recurseChain(values, level) { |
| const item = chain[level].regex ? chain[level] : {regex: chain[level]}; |
| const matches = []; |
| |
| function addMatch(match) { |
| if (item.backref) { |
| const ERR_UNDEFINED_GROUP = `Backreference to undefined group: ${item.backref}`; |
| const 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); |
| } |
| |
| const backrefValue = isNamedBackref && XRegExp.isInstalled('namespacing') ? |
| match.groups[item.backref] : |
| match[item.backref]; |
| |
| matches.push(backrefValue || ''); |
| } else { |
| matches.push(match[0]); |
| } |
| } |
| |
| for (const value of values) { |
| XRegExp.forEach(value, item.regex, addMatch); |
| } |
| |
| 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 = (str, search, replacement, scope) => { |
| const isRegex = XRegExp.isRegExp(search); |
| const global = (search.global && scope !== 'one') || scope === 'all'; |
| const cacheKey = ((global ? 'g' : '') + (search.sticky ? 'y' : '')) || 'noGY'; |
| let 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. |
| const 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 = (str, replacements) => { |
| for (const r of replacements) { |
| str = XRegExp.replace(str, r[0], r[1], r[2]); |
| } |
| |
| 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 = (str, separator, limit) => 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 = (str, regex, pos, sticky) => !!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 = (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 = (patterns, flags, options) => { |
| options = options || {}; |
| const conjunction = options.conjunction || 'or'; |
| let numCaptures = 0; |
| let numPriorCaptures; |
| let captureNames; |
| |
| function rewrite(match, paren, backref) { |
| const name = captureNames[numCaptures - numPriorCaptures]; |
| |
| // Capturing group |
| if (paren) { |
| ++numCaptures; |
| // If the current capture has a name, preserve the name |
| if (name) { |
| return `(?<${name}>`; |
| } |
| // Backreference |
| } else if (backref) { |
| // Rewrite the backreference |
| return `\\${+backref + numPriorCaptures}`; |
| } |
| |
| return match; |
| } |
| |
| if (!(isType(patterns, 'Array') && patterns.length)) { |
| throw new TypeError('Must provide a nonempty array of patterns to merge'); |
| } |
| |
| const parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g; |
| const output = []; |
| for (const pattern of patterns) { |
| 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)); |
| } |
| } |
| |
| const 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) { |
| const origLastIndex = this.lastIndex; |
| const 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 && match.includes('')) { |
| const 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(String(str).slice(match.index), r2, (...args) => { |
| const len = args.length; |
| // Skip index 0 and the last 2 |
| for (let i = 1; i < len - 2; ++i) { |
| if (args[i] === undefined) { |
| match[i] = undefined; |
| } |
| } |
| }); |
| } |
| |
| // Attach named capture properties |
| let groupsObject = match; |
| if (XRegExp.isInstalled('namespacing')) { |
| // https://tc39.github.io/proposal-regexp-named-groups/#sec-regexpbuiltinexec |
| match.groups = Object.create(null); |
| groupsObject = match.groups; |
| } |
| if (this[REGEX_DATA] && this[REGEX_DATA].captureNames) { |
| // Skip index 0 |
| for (let i = 1; i < match.length; ++i) { |
| const 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) { |
| const 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) { |
| const isRegex = XRegExp.isRegExp(search); |
| let origLastIndex; |
| let captureNames; |
| let result; |
| |
| if (isRegex) { |
| if (search[REGEX_DATA]) { |
| ({captureNames} = search[REGEX_DATA]); |
| } |
| // 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, (...args) => { |
| if (captureNames) { |
| let groupsObject; |
| |
| if (XRegExp.isInstalled('namespacing')) { |
| // https://tc39.github.io/proposal-regexp-named-groups/#sec-regexpbuiltinexec |
| groupsObject = Object.create(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; |
| } |
| |
| // Store named backreferences |
| for (let 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(...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, (...args) => { |
| 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. |
| let 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 ? captureNames.indexOf(bracketed) : -1; |
| if (n < 0) { |
| throw new SyntaxError(`Backreference to undefined group ${$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 === '`') { // $` (left context) |
| return args[args.length - 1].slice(0, args[args.length - 2]); |
| } |
| if (dollarToken === "'") { // $' (right context) |
| return args[args.length - 1].slice(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 ${$0}`); |
| } |
| return args[dollarToken] || ''; |
| } |
| // `$` followed by an unsupported char is an error, unlike native JS |
| throw new SyntaxError(`Invalid token ${$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); |
| } |
| |
| const str = String(this); |
| const output = []; |
| const origLastIndex = separator.lastIndex; |
| let lastLastIndex = 0; |
| let 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; |
| |
| XRegExp.forEach(str, separator, (match) => { |
| // This condition is not the same as `if (match[0].length)` |
| if ((match.index + match[0].length) > lastLastIndex) { |
| output.push(str.slice(lastLastIndex, match.index)); |
| if (match.length > 1 && match.index < str.length) { |
| Array.prototype.push.apply(output, match.slice(1)); |
| } |
| lastLength = match[0].length; |
| lastLastIndex = match.index + lastLength; |
| } |
| }); |
| |
| if (lastLastIndex === str.length) { |
| if (!nativ.test.call(separator, '') || lastLength) { |
| output.push(''); |
| } |
| } else { |
| output.push(str.slice(lastLastIndex)); |
| } |
| |
| separator.lastIndex = origLastIndex; |
| return output.length > limit ? output.slice(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}))/, |
| (match, scope) => { |
| // \B is allowed in default scope only |
| if (match[1] === 'B' && scope === defaultScope) { |
| return match[0]; |
| } |
| throw new SyntaxError(`Invalid escape ${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]+)}/, |
| (match, scope, flags) => { |
| const code = dec(match[1]); |
| if (code > 0x10FFFF) { |
| throw new SyntaxError(`Invalid Unicode code point ${match[0]}`); |
| } |
| if (code <= 0xFFFF) { |
| // Converting to \uNNNN avoids needing to escape the literal character and keep it |
| // separate from preceding tokens |
| return `\\u${pad4(hex(code))}`; |
| } |
| // If `code` is between 0xFFFF and 0x10FFFF, require and defer to native handling |
| if (hasNativeU && flags.includes('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 */ |
| (match) => (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( |
| /\./, |
| () => '[\\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) { |
| // Groups with the same name is an error, else would need `lastIndexOf` |
| const index = isNaN(match[1]) ? (this.captureNames.indexOf(match[1]) + 1) : +match[1]; |
| const endIndex = match.index + match[0].length; |
| if (!index || index > this.captureNames.length) { |
| throw new SyntaxError(`Backreference to undefined group ${match[0]}`); |
| } |
| // Keep backreferences separate from subsequent literal numbers. This avoids e.g. |
| // inadvertedly changing `(?<n>)\k<n>1` to `()\11`. |
| return `\\${index}${ |
| 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 ${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) { |
| // 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 ${match[0]}`); |
| } |
| if (!XRegExp.isInstalled('namespacing') && (match[1] === 'length' || match[1] === '__proto__')) { |
| throw new SyntaxError(`Cannot use reserved word as capture name ${match[0]}`); |
| } |
| if (this.captureNames.includes(match[1])) { |
| throw new SyntaxError(`Cannot use same name for multiple groups ${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 (flags.includes('n')) { |
| return '(?:'; |
| } |
| this.captureNames.push(null); |
| return '('; |
| }, |
| { |
| optionalFlags: 'n', |
| leadChar: '(' |
| } |
| ); |
| |
| export default XRegExp; |
