KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta 
How to use isQuantifierNext method in redwood
Best JavaScript code snippet using redwood
xregexp.js
Source:xregexp.js 
...200 * @param {Number} pos Index in `pattern` to search at.201 * @param {String} flags Flags used by the pattern.202 * @returns {Boolean} Whether the next token is a quantifier.203 */204 function isQuantifierNext(pattern, pos, flags) {205 return nativ.test.call(206 flags.indexOf('x') > -1 ?207 // Ignore any leading whitespace, line comments, and inline comments208 /^(?:\s+|#.*|\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/ :209 // Ignore any leading inline comments210 /^(?:\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/,211 pattern.slice(pos)212 );213 }214/**215 * Checks for flag-related errors, and strips/applies flags in a leading mode modifier. Offloads216 * the flag preparation logic from the `XRegExp` constructor.217 *218 * @private219 * @param {String} pattern Regex pattern, possibly with a leading mode modifier.220 * @param {String} flags Any combination of flags.221 * @returns {Object} Object with properties `pattern` and `flags`.222 */223 function prepareFlags(pattern, flags) {224 var i;225 // Recent browsers throw on duplicate flags, so copy this behavior for nonnative flags226 if (clipDuplicates(flags) !== flags) {227 throw new SyntaxError('Invalid duplicate regex flag ' + flags);228 }229 // Strip and apply a leading mode modifier with any combination of flags except g or y230 pattern = nativ.replace.call(pattern, /^\(\?([\w$]+)\)/, function($0, $1) {231 if (nativ.test.call(/[gy]/, $1)) {232 throw new SyntaxError('Cannot use flag g or y in mode modifier ' + $0);233 }234 // Allow duplicate flags within the mode modifier235 flags = clipDuplicates(flags + $1);236 return '';237 });238 // Throw on unknown native or nonnative flags239 for (i = 0; i < flags.length; ++i) {240 if (!registeredFlags[flags.charAt(i)]) {241 throw new SyntaxError('Unknown regex flag ' + flags.charAt(i));242 }243 }244 return {245 pattern: pattern,246 flags: flags247 };248 }249/**250 * Prepares an options object from the given value.251 *252 * @private253 * @param {String|Object} value Value to convert to an options object.254 * @returns {Object} Options object.255 */256 function prepareOptions(value) {257 value = value || {};258 if (isType(value, 'String')) {259 value = self.forEach(value, /[^\s,]+/, function(match) {260 this[match] = true;261 }, {});262 }263 return value;264 }265/**266 * Registers a flag so it doesn't throw an 'unknown flag' error.267 *268 * @private269 * @param {String} flag Single-character flag to register.270 */271 function registerFlag(flag) {272 if (!/^[\w$]$/.test(flag)) {273 throw new Error('Flag must be a single character A-Za-z0-9_$');274 }275 registeredFlags[flag] = true;276 }277/**278 * Runs built-in and custom regex syntax tokens in reverse insertion order at the specified279 * position, until a match is found.280 *281 * @private282 * @param {String} pattern Original pattern from which an XRegExp object is being built.283 * @param {String} flags Flags being used to construct the regex.284 * @param {Number} pos Position to search for tokens within `pattern`.285 * @param {Number} scope Regex scope to apply: 'default' or 'class'.286 * @param {Object} context Context object to use for token handler functions.287 * @returns {Object} Object with properties `matchLength`, `output`, and `reparse`; or `null`.288 */289 function runTokens(pattern, flags, pos, scope, context) {290 var i = tokens.length,291 result = null,292 match,293 t;294 // Run in reverse insertion order295 while (i--) {296 t = tokens[i];297 if (298 (t.scope === scope || t.scope === 'all') &&299 (!t.flag || flags.indexOf(t.flag) > -1)300 ) {301 match = self.exec(pattern, t.regex, pos, 'sticky');302 if (match) {303 result = {304 matchLength: match[0].length,305 output: t.handler.call(context, match, scope, flags),306 reparse: t.reparse307 };308 // Finished with token tests309 break;310 }311 }312 }313 return result;314 }315/**316 * Enables or disables implicit astral mode opt-in.317 *318 * @private319 * @param {Boolean} on `true` to enable; `false` to disable.320 */321 function setAstral(on) {322 // Reset the pattern cache used by the `XRegExp` constructor, since the same pattern and323 // flags might now produce different results324 self.cache.flush('patterns');325 features.astral = on;326 }327/**328 * Enables or disables native method overrides.329 *330 * @private331 * @param {Boolean} on `true` to enable; `false` to disable.332 */333 function setNatives(on) {334 RegExp.prototype.exec = (on ? fixed : nativ).exec;335 RegExp.prototype.test = (on ? fixed : nativ).test;336 String.prototype.match = (on ? fixed : nativ).match;337 String.prototype.replace = (on ? fixed : nativ).replace;338 String.prototype.split = (on ? fixed : nativ).split;339 features.natives = on;340 }341/**342 * Returns the object, or throws an error if it is `null` or `undefined`. This is used to follow343 * the ES5 abstract operation `ToObject`.344 *345 * @private346 * @param {*} value Object to check and return.347 * @returns {*} The provided object.348 */349 function toObject(value) {350 // This matches both `null` and `undefined`351 if (value == null) {352 throw new TypeError('Cannot convert null or undefined to object');353 }354 return value;355 }356/* ==============================357 * Constructor358 * ============================== */359/**360 * Creates an extended regular expression object for matching text with a pattern. Differs from a361 * native regular expression in that additional syntax and flags are supported. The returned object362 * is in fact a native `RegExp` and works with all native methods.363 *364 * @class XRegExp365 * @constructor366 * @param {String|RegExp} pattern Regex pattern string, or an existing regex object to copy.367 * @param {String} [flags] Any combination of flags.368 * Native flags:369 * <li>`g` - global370 * <li>`i` - ignore case371 * <li>`m` - multiline anchors372 * <li>`y` - sticky (Firefox 3+)373 * Additional XRegExp flags:374 * <li>`n` - explicit capture375 * <li>`s` - dot matches all (aka singleline)376 * <li>`x` - free-spacing and line comments (aka extended)377 * <li>`A` - astral (requires the Unicode Base addon)378 * Flags cannot be provided when constructing one `RegExp` from another.379 * @returns {RegExp} Extended regular expression object.380 * @example381 *382 * // With named capture and flag x383 * XRegExp('(?<year> [0-9]{4} ) -? # year \n\384 * (?<month> [0-9]{2} ) -? # month \n\385 * (?<day> [0-9]{2} ) # day ', 'x');386 *387 * // Providing a regex object copies it. Native regexes are recompiled using native (not XRegExp)388 * // syntax. Copies maintain special properties for named capture, are augmented with389 * // `XRegExp.prototype` methods, and have fresh `lastIndex` properties (set to zero).390 * XRegExp(/regex/);391 */392 self = function(pattern, flags) {393 var context = {394 hasNamedCapture: false,395 captureNames: []396 },397 scope = defaultScope,398 output = '',399 pos = 0,400 result,401 token,402 key;403 if (self.isRegExp(pattern)) {404 if (flags !== undefined) {405 throw new TypeError('Cannot supply flags when copying a RegExp');406 }407 return copy(pattern, {addProto: true});408 }409 // Copy the argument behavior of `RegExp`410 pattern = pattern === undefined ? '' : String(pattern);411 flags = flags === undefined ? '' : String(flags);412 // Cache-lookup key; intentionally using an invalid regex sequence as the separator413 key = pattern + '***' + flags;414 if (!patternCache[key]) {415 // Check for flag-related errors, and strip/apply flags in a leading mode modifier416 result = prepareFlags(pattern, flags);417 pattern = result.pattern;418 flags = result.flags;419 // Use XRegExp's syntax tokens to translate the pattern to a native regex pattern...420 // `pattern.length` may change on each iteration, if tokens use the `reparse` option421 while (pos < pattern.length) {422 do {423 // Check for custom tokens at the current position424 result = runTokens(pattern, flags, pos, scope, context);425 // If the matched token used the `reparse` option, splice its output into the426 // pattern before running tokens again at the same position427 if (result && result.reparse) {428 pattern = pattern.slice(0, pos) +429 result.output +430 pattern.slice(pos + result.matchLength);431 }432 } while (result && result.reparse);433 if (result) {434 output += result.output;435 pos += (result.matchLength || 1);436 } else {437 // Get the native token at the current position438 token = self.exec(pattern, nativeTokens[scope], pos, 'sticky')[0];439 output += token;440 pos += token.length;441 if (token === '[' && scope === defaultScope) {442 scope = classScope;443 } else if (token === ']' && scope === classScope) {444 scope = defaultScope;445 }446 }447 }448 patternCache[key] = {449 // Cleanup token cruft: repeated `(?:)(?:)` and leading/trailing `(?:)`450 pattern: nativ.replace.call(output, /\(\?:\)(?=\(\?:\))|^\(\?:\)|\(\?:\)$/g, ''),451 // Strip all but native flags452 flags: nativ.replace.call(flags, /[^gimy]+/g, ''),453 // `context.captureNames` has an item for each capturing group, even if unnamed454 captures: context.hasNamedCapture ? context.captureNames : null455 }456 }457 key = patternCache[key];458 return augment(new RegExp(key.pattern, key.flags), key.captures, /*addProto*/ true);459 };460// Add `RegExp.prototype` to the prototype chain461 self.prototype = new RegExp;462/* ==============================463 * Public properties464 * ============================== */465/**466 * The XRegExp version number.467 *468 * @static469 * @memberOf XRegExp470 * @type String471 */472 self.version = '3.0.0-pre';473/* ==============================474 * Public methods475 * ============================== */476/**477 * Extends XRegExp syntax and allows custom flags. This is used internally and can be used to478 * create XRegExp addons. If more than one token can match the same string, the last added wins.479 *480 * @memberOf XRegExp481 * @param {RegExp} regex Regex object that matches the new token.482 * @param {Function} handler Function that returns a new pattern string (using native regex syntax)483 * to replace the matched token within all future XRegExp regexes. Has access to persistent484 * properties of the regex being built, through `this`. Invoked with three arguments:485 * <li>The match array, with named backreference properties.486 * <li>The regex scope where the match was found: 'default' or 'class'.487 * <li>The flags used by the regex, including any flags in a leading mode modifier.488 * The handler function becomes part of the XRegExp construction process, so be careful not to489 * construct XRegExps within the function or you will trigger infinite recursion.490 * @param {Object} [options] Options object with optional properties:491 * <li>`scope` {String} Scope where the token applies: 'default', 'class', or 'all'.492 * <li>`flag` {String} Single-character flag that triggers the token. This also registers the493 * flag, which prevents XRegExp from throwing an 'unknown flag' error when the flag is used.494 * <li>`optionalFlags` {String} Any custom flags checked for within the token `handler` that are495 * not required to trigger the token. This registers the flags, to prevent XRegExp from496 * throwing an 'unknown flag' error when any of the flags are used.497 * <li>`reparse` {Boolean} Whether the `handler` function's output should not be treated as498 * final, and instead be reparseable by other tokens (including the current token). Allows499 * token chaining or deferring.500 * @example501 *502 * // Basic usage: Add \a for the ALERT control code503 * XRegExp.addToken(504 * /\\a/,505 * function() {return '\\x07';},506 * {scope: 'all'}507 * );508 * XRegExp('\\a[\\a-\\n]+').test('\x07\n\x07'); // -> true509 *510 * // Add the U (ungreedy) flag from PCRE and RE2, which reverses greedy and lazy quantifiers511 * XRegExp.addToken(512 * /([?*+]|{\d+(?:,\d*)?})(\??)/,513 * function(match) {return match[1] + (match[2] ? '' : '?');},514 * {flag: 'U'}515 * );516 * XRegExp('a+', 'U').exec('aaa')[0]; // -> 'a'517 * XRegExp('a+?', 'U').exec('aaa')[0]; // -> 'aaa'518 */519 self.addToken = function(regex, handler, options) {520 options = options || {};521 var optionalFlags = options.optionalFlags, i;522 if (options.flag) {523 registerFlag(options.flag);524 }525 if (optionalFlags) {526 optionalFlags = nativ.split.call(optionalFlags, '');527 for (i = 0; i < optionalFlags.length; ++i) {528 registerFlag(optionalFlags[i]);529 }530 }531 // Add to the private list of syntax tokens532 tokens.push({533 regex: copy(regex, {add: 'g' + (hasNativeY ? 'y' : '')}),534 handler: handler,535 scope: options.scope || defaultScope,536 flag: options.flag,537 reparse: options.reparse538 });539 // Reset the pattern cache used by the `XRegExp` constructor, since the same pattern and540 // flags might now produce different results541 self.cache.flush('patterns');542 };543/**544 * Caches and returns the result of calling `XRegExp(pattern, flags)`. On any subsequent call with545 * the same pattern and flag combination, the cached copy of the regex is returned.546 *547 * @memberOf XRegExp548 * @param {String} pattern Regex pattern string.549 * @param {String} [flags] Any combination of XRegExp flags.550 * @returns {RegExp} Cached XRegExp object.551 * @example552 *553 * while (match = XRegExp.cache('.', 'gs').exec(str)) {554 * // The regex is compiled once only555 * }556 */557 self.cache = function(pattern, flags) {558 var key = pattern + '***' + (flags || '');559 return cache[key] || (cache[key] = self(pattern, flags));560 };561// Intentionally undocumented562 self.cache.flush = function(cacheName) {563 if (cacheName === 'patterns') {564 // Flush the pattern cache used by the `XRegExp` constructor565 patternCache = {};566 } else {567 // Flush the regex object cache populated by `XRegExp.cache`568 cache = {};569 }570 };571/**572 * Escapes any regular expression metacharacters, for use when matching literal strings. The result573 * can safely be used at any point within a regex that uses any flags.574 *575 * @memberOf XRegExp576 * @param {String} str String to escape.577 * @returns {String} String with regex metacharacters escaped.578 * @example579 *580 * XRegExp.escape('Escaped? <.>');581 * // -> 'Escaped\?\ <\.>'582 */583 self.escape = function(str) {584 return nativ.replace.call(toObject(str), /[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');585 };586/**587 * Executes a regex search in a specified string. Returns a match array or `null`. If the provided588 * regex uses named capture, named backreference properties are included on the match array.589 * Optional `pos` and `sticky` arguments specify the search start position, and whether the match590 * must start at the specified position only. The `lastIndex` property of the provided regex is not591 * used, but is updated for compatibility. Also fixes browser bugs compared to the native592 * `RegExp.prototype.exec` and can be used reliably cross-browser.593 *594 * @memberOf XRegExp595 * @param {String} str String to search.596 * @param {RegExp} regex Regex to search with.597 * @param {Number} [pos=0] Zero-based index at which to start the search.598 * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position599 * only. The string `'sticky'` is accepted as an alternative to `true`.600 * @returns {Array} Match array with named backreference properties, or `null`.601 * @example602 *603 * // Basic use, with named backreference604 * var match = XRegExp.exec('U+2620', XRegExp('U\\+(?<hex>[0-9A-F]{4})'));605 * match.hex; // -> '2620'606 *607 * // With pos and sticky, in a loop608 * var pos = 2, result = [], match;609 * while (match = XRegExp.exec('<1><2><3><4>5<6>', /<(\d)>/, pos, 'sticky')) {610 * result.push(match[1]);611 * pos = match.index + match[0].length;612 * }613 * // result -> ['2', '3', '4']614 */615 self.exec = function(str, regex, pos, sticky) {616 var cacheFlags = 'g', match, r2;617 if (hasNativeY && (sticky || (regex.sticky && sticky !== false))) {618 cacheFlags += 'y';619 }620 regex[REGEX_DATA] = regex[REGEX_DATA] || getBaseProps();621 // Shares cached copies with `XRegExp.match`/`replace`622 r2 = regex[REGEX_DATA][cacheFlags] || (623 regex[REGEX_DATA][cacheFlags] = copy(regex, {624 add: cacheFlags,625 remove: sticky === false ? 'y' : ''626 })627 );628 r2.lastIndex = pos = pos || 0;629 // Fixed `exec` required for `lastIndex` fix, named backreferences, etc.630 match = fixed.exec.call(r2, str);631 if (sticky && match && match.index !== pos) {632 match = null;633 }634 if (regex.global) {635 regex.lastIndex = match ? r2.lastIndex : 0;636 }637 return match;638 };639/**640 * Executes a provided function once per regex match.641 *642 * @memberOf XRegExp643 * @param {String} str String to search.644 * @param {RegExp} regex Regex to search with.645 * @param {Function} callback Function to execute for each match. Invoked with four arguments:646 * <li>The match array, with named backreference properties.647 * <li>The zero-based match index.648 * <li>The string being traversed.649 * <li>The regex object being used to traverse the string.650 * @param {*} [context] Object to use as `this` when executing `callback`.651 * @returns {*} Provided `context` object.652 * @example653 *654 * // Extracts every other digit from a string655 * XRegExp.forEach('1a2345', /\d/, function(match, i) {656 * if (i % 2) this.push(+match[0]);657 * }, []);658 * // -> [2, 4]659 */660 self.forEach = function(str, regex, callback, context) {661 var pos = 0,662 i = -1,663 match;664 while ((match = self.exec(str, regex, pos))) {665 // Because `regex` is provided to `callback`, the function can use the deprecated/666 // nonstandard `RegExp.prototype.compile` to mutate the regex. However, since667 // `XRegExp.exec` doesn't use `lastIndex` to set the search position, this can't lead668 // to an infinite loop, at least. Actually, because of the way `XRegExp.exec` caches669 // globalized versions of regexes, mutating the regex will not have any effect on the670 // iteration or matched strings, which is a nice side effect that brings extra safety671 callback.call(context, match, ++i, str, regex);672 pos = match.index + (match[0].length || 1);673 }674 return context;675 };676/**677 * Copies a regex object and adds flag `g`. The copy maintains special properties for named678 * capture, is augmented with `XRegExp.prototype` methods, and has a fresh `lastIndex` property679 * (set to zero). Native regexes are not recompiled using XRegExp syntax.680 *681 * @memberOf XRegExp682 * @param {RegExp} regex Regex to globalize.683 * @returns {RegExp} Copy of the provided regex with flag `g` added.684 * @example685 *686 * var globalCopy = XRegExp.globalize(/regex/);687 * globalCopy.global; // -> true688 */689 self.globalize = function(regex) {690 return copy(regex, {add: 'g', addProto: true});691 };692/**693 * Installs optional features according to the specified options. Can be undone using694 * {@link #XRegExp.uninstall}.695 *696 * @memberOf XRegExp697 * @param {Object|String} options Options object or string.698 * @example699 *700 * // With an options object701 * XRegExp.install({702 * // Enables support for astral code points in Unicode addons (implicitly sets flag A)703 * astral: true,704 *705 * // Overrides native regex methods with fixed/extended versions that support named706 * // backreferences and fix numerous cross-browser bugs707 * natives: true708 * });709 *710 * // With an options string711 * XRegExp.install('astral natives');712 */713 self.install = function(options) {714 options = prepareOptions(options);715 if (!features.astral && options.astral) {716 setAstral(true);717 }718 if (!features.natives && options.natives) {719 setNatives(true);720 }721 };722/**723 * Checks whether an individual optional feature is installed.724 *725 * @memberOf XRegExp726 * @param {String} feature Name of the feature to check. One of:727 * <li>`natives`728 * <li>`astral`729 * @returns {Boolean} Whether the feature is installed.730 * @example731 *732 * XRegExp.isInstalled('natives');733 */734 self.isInstalled = function(feature) {735 return !!(features[feature]);736 };737/**738 * Returns `true` if an object is a regex; `false` if it isn't. This works correctly for regexes739 * created in another frame, when `instanceof` and `constructor` checks would fail.740 *741 * @memberOf XRegExp742 * @param {*} value Object to check.743 * @returns {Boolean} Whether the object is a `RegExp` object.744 * @example745 *746 * XRegExp.isRegExp('string'); // -> false747 * XRegExp.isRegExp(/regex/i); // -> true748 * XRegExp.isRegExp(RegExp('^', 'm')); // -> true749 * XRegExp.isRegExp(XRegExp('(?s).')); // -> true750 */751 self.isRegExp = function(value) {752 return toString.call(value) === '[object RegExp]';753 //return isType(value, 'RegExp');754 };755/**756 * Returns the first matched string, or in global mode, an array containing all matched strings.757 * This is essentially a more convenient re-implementation of `String.prototype.match` that gives758 * the result types you actually want (string instead of `exec`-style array in match-first mode,759 * and an empty array instead of `null` when no matches are found in match-all mode). It also lets760 * you override flag g and ignore `lastIndex`, and fixes browser bugs.761 *762 * @memberOf XRegExp763 * @param {String} str String to search.764 * @param {RegExp} regex Regex to search with.765 * @param {String} [scope='one'] Use 'one' to return the first match as a string. Use 'all' to766 * return an array of all matched strings. If not explicitly specified and `regex` uses flag g,767 * `scope` is 'all'.768 * @returns {String|Array} In match-first mode: First match as a string, or `null`. In match-all769 * mode: Array of all matched strings, or an empty array.770 * @example771 *772 * // Match first773 * XRegExp.match('abc', /\w/); // -> 'a'774 * XRegExp.match('abc', /\w/g, 'one'); // -> 'a'775 * XRegExp.match('abc', /x/g, 'one'); // -> null776 *777 * // Match all778 * XRegExp.match('abc', /\w/g); // -> ['a', 'b', 'c']779 * XRegExp.match('abc', /\w/, 'all'); // -> ['a', 'b', 'c']780 * XRegExp.match('abc', /x/, 'all'); // -> []781 */782 self.match = function(str, regex, scope) {783 var global = (regex.global && scope !== 'one') || scope === 'all',784 cacheFlags = (global ? 'g' : '') + (regex.sticky ? 'y' : ''),785 result,786 r2;787 regex[REGEX_DATA] = regex[REGEX_DATA] || getBaseProps();788 // Shares cached copies with `XRegExp.exec`/`replace`789 r2 = regex[REGEX_DATA][cacheFlags || 'noGY'] || (790 regex[REGEX_DATA][cacheFlags || 'noGY'] = copy(regex, {791 add: cacheFlags,792 remove: scope === 'one' ? 'g' : ''793 })794 );795 result = nativ.match.call(toObject(str), r2);796 if (regex.global) {797 regex.lastIndex = (798 (scope === 'one' && result) ?799 // Can't use `r2.lastIndex` since `r2` is nonglobal in this case800 (result.index + result[0].length) : 0801 );802 }803 return global ? (result || []) : (result && result[0]);804 };805/**806 * Retrieves the matches from searching a string using a chain of regexes that successively search807 * within previous matches. The provided `chain` array can contain regexes and objects with `regex`808 * and `backref` properties. When a backreference is specified, the named or numbered backreference809 * is passed forward to the next regex or returned.810 *811 * @memberOf XRegExp812 * @param {String} str String to search.813 * @param {Array} chain Regexes that each search for matches within preceding results.814 * @returns {Array} Matches by the last regex in the chain, or an empty array.815 * @example816 *817 * // Basic usage; matches numbers within <b> tags818 * XRegExp.matchChain('1 <b>2</b> 3 <b>4 a 56</b>', [819 * XRegExp('(?is)<b>.*?</b>'),820 * /\d+/821 * ]);822 * // -> ['2', '4', '56']823 *824 * // Passing forward and returning specific backreferences825 * html = '<a href="http://xregexp.com/api/">XRegExp</a>\826 * <a href="http://www.google.com/">Google</a>';827 * XRegExp.matchChain(html, [828 * {regex: /<a href="([^"]+)">/i, backref: 1},829 * {regex: XRegExp('(?i)^https?://(?<domain>[^/?#]+)'), backref: 'domain'}830 * ]);831 * // -> ['xregexp.com', 'www.google.com']832 */833 self.matchChain = function(str, chain) {834 return (function recurseChain(values, level) {835 var item = chain[level].regex ? chain[level] : {regex: chain[level]},836 matches = [],837 addMatch = function(match) {838 if (item.backref) {839 /* Safari 4.0.5 (but not 5.0.5+) inappropriately uses sparse arrays to hold840 * the `undefined`s for backreferences to nonparticipating capturing841 * groups. In such cases, a `hasOwnProperty` or `in` check on its own would842 * inappropriately throw the exception, so also check if the backreference843 * is a number that is within the bounds of the array.844 */845 if (!(match.hasOwnProperty(item.backref) || +item.backref < match.length)) {846 throw new ReferenceError('Backreference to undefined group: ' + item.backref);847 }848 matches.push(match[item.backref] || '');849 } else {850 matches.push(match[0]);851 }852 },853 i;854 for (i = 0; i < values.length; ++i) {855 self.forEach(values[i], item.regex, addMatch);856 }857 return ((level === chain.length - 1) || !matches.length) ?858 matches :859 recurseChain(matches, level + 1);860 }([str], 0));861 };862/**863 * Returns a new string with one or all matches of a pattern replaced. The pattern can be a string864 * or regex, and the replacement can be a string or a function to be called for each match. To865 * perform a global search and replace, use the optional `scope` argument or include flag g if866 * using a regex. Replacement strings can use `${n}` for named and numbered backreferences.867 * Replacement functions can use named backreferences via `arguments[0].name`. Also fixes browser868 * bugs compared to the native `String.prototype.replace` and can be used reliably cross-browser.869 *870 * @memberOf XRegExp871 * @param {String} str String to search.872 * @param {RegExp|String} search Search pattern to be replaced.873 * @param {String|Function} replacement Replacement string or a function invoked to create it.874 * Replacement strings can include special replacement syntax:875 * <li>$$ - Inserts a literal $ character.876 * <li>$&, $0 - Inserts the matched substring.877 * <li>$` - Inserts the string that precedes the matched substring (left context).878 * <li>$' - Inserts the string that follows the matched substring (right context).879 * <li>$n, $nn - Where n/nn are digits referencing an existent capturing group, inserts880 * backreference n/nn.881 * <li>${n} - Where n is a name or any number of digits that reference an existent capturing882 * group, inserts backreference n.883 * Replacement functions are invoked with three or more arguments:884 * <li>The matched substring (corresponds to $& above). Named backreferences are accessible as885 * properties of this first argument.886 * <li>0..n arguments, one for each backreference (corresponding to $1, $2, etc. above).887 * <li>The zero-based index of the match within the total search string.888 * <li>The total string being searched.889 * @param {String} [scope='one'] Use 'one' to replace the first match only, or 'all'. If not890 * explicitly specified and using a regex with flag g, `scope` is 'all'.891 * @returns {String} New string with one or all matches replaced.892 * @example893 *894 * // Regex search, using named backreferences in replacement string895 * var name = XRegExp('(?<first>\\w+) (?<last>\\w+)');896 * XRegExp.replace('John Smith', name, '${last}, ${first}');897 * // -> 'Smith, John'898 *899 * // Regex search, using named backreferences in replacement function900 * XRegExp.replace('John Smith', name, function(match) {901 * return match.last + ', ' + match.first;902 * });903 * // -> 'Smith, John'904 *905 * // String search, with replace-all906 * XRegExp.replace('RegExp builds RegExps', 'RegExp', 'XRegExp', 'all');907 * // -> 'XRegExp builds XRegExps'908 */909 self.replace = function(str, search, replacement, scope) {910 var isRegex = self.isRegExp(search),911 global = (search.global && scope !== 'one') || scope === 'all',912 cacheFlags = (global ? 'g' : '') + (search.sticky ? 'y' : ''),913 s2 = search,914 result;915 if (isRegex) {916 search[REGEX_DATA] = search[REGEX_DATA] || getBaseProps();917 // Shares cached copies with `XRegExp.exec`/`match`. Since a copy is used,918 // `search`'s `lastIndex` isn't updated *during* replacement iterations919 s2 = search[REGEX_DATA][cacheFlags || 'noGY'] || (920 search[REGEX_DATA][cacheFlags || 'noGY'] = copy(search, {921 add: cacheFlags,922 remove: scope === 'one' ? 'g' : ''923 })924 );925 } else if (global) {926 s2 = new RegExp(self.escape(String(search)), 'g');927 }928 // Fixed `replace` required for named backreferences, etc.929 result = fixed.replace.call(toObject(str), s2, replacement);930 if (isRegex && search.global) {931 // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)932 search.lastIndex = 0;933 }934 return result;935 };936/**937 * Performs batch processing of string replacements. Used like {@link #XRegExp.replace}, but938 * accepts an array of replacement details. Later replacements operate on the output of earlier939 * replacements. Replacement details are accepted as an array with a regex or string to search for,940 * the replacement string or function, and an optional scope of 'one' or 'all'. Uses the XRegExp941 * replacement text syntax, which supports named backreference properties via `${name}`.942 *943 * @memberOf XRegExp944 * @param {String} str String to search.945 * @param {Array} replacements Array of replacement detail arrays.946 * @returns {String} New string with all replacements.947 * @example948 *949 * str = XRegExp.replaceEach(str, [950 * [XRegExp('(?<name>a)'), 'z${name}'],951 * [/b/gi, 'y'],952 * [/c/g, 'x', 'one'], // scope 'one' overrides /g953 * [/d/, 'w', 'all'], // scope 'all' overrides lack of /g954 * ['e', 'v', 'all'], // scope 'all' allows replace-all for strings955 * [/f/g, function($0) {956 * return $0.toUpperCase();957 * }]958 * ]);959 */960 self.replaceEach = function(str, replacements) {961 var i, r;962 for (i = 0; i < replacements.length; ++i) {963 r = replacements[i];964 str = self.replace(str, r[0], r[1], r[2]);965 }966 return str;967 };968/**969 * Splits a string into an array of strings using a regex or string separator. Matches of the970 * separator are not included in the result array. However, if `separator` is a regex that contains971 * capturing groups, backreferences are spliced into the result each time `separator` is matched.972 * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably973 * cross-browser.974 *975 * @memberOf XRegExp976 * @param {String} str String to split.977 * @param {RegExp|String} separator Regex or string to use for separating the string.978 * @param {Number} [limit] Maximum number of items to include in the result array.979 * @returns {Array} Array of substrings.980 * @example981 *982 * // Basic use983 * XRegExp.split('a b c', ' ');984 * // -> ['a', 'b', 'c']985 *986 * // With limit987 * XRegExp.split('a b c', ' ', 2);988 * // -> ['a', 'b']989 *990 * // Backreferences in result array991 * XRegExp.split('..word1..', /([a-z]+)(\d+)/i);992 * // -> ['..', 'word', '1', '..']993 */994 self.split = function(str, separator, limit) {995 return fixed.split.call(toObject(str), separator, limit);996 };997/**998 * Executes a regex search in a specified string. Returns `true` or `false`. Optional `pos` and999 * `sticky` arguments specify the search start position, and whether the match must start at the1000 * specified position only. The `lastIndex` property of the provided regex is not used, but is1001 * updated for compatibility. Also fixes browser bugs compared to the native1002 * `RegExp.prototype.test` and can be used reliably cross-browser.1003 *1004 * @memberOf XRegExp1005 * @param {String} str String to search.1006 * @param {RegExp} regex Regex to search with.1007 * @param {Number} [pos=0] Zero-based index at which to start the search.1008 * @param {Boolean|String} [sticky=false] Whether the match must start at the specified position1009 * only. The string `'sticky'` is accepted as an alternative to `true`.1010 * @returns {Boolean} Whether the regex matched the provided value.1011 * @example1012 *1013 * // Basic use1014 * XRegExp.test('abc', /c/); // -> true1015 *1016 * // With pos and sticky1017 * XRegExp.test('abc', /c/, 0, 'sticky'); // -> false1018 */1019 self.test = function(str, regex, pos, sticky) {1020 // Do this the easy way :-)1021 return !!self.exec(str, regex, pos, sticky);1022 };1023/**1024 * Uninstalls optional features according to the specified options. All optional features start out1025 * uninstalled, so this is used to undo the actions of {@link #XRegExp.install}.1026 *1027 * @memberOf XRegExp1028 * @param {Object|String} options Options object or string.1029 * @example1030 *1031 * // With an options object1032 * XRegExp.uninstall({1033 * // Disables support for astral code points in Unicode addons1034 * astral: true,1035 *1036 * // Restores native regex methods1037 * natives: true1038 * });1039 *1040 * // With an options string1041 * XRegExp.uninstall('astral natives');1042 */1043 self.uninstall = function(options) {1044 options = prepareOptions(options);1045 if (features.astral && options.astral) {1046 setAstral(false);1047 }1048 if (features.natives && options.natives) {1049 setNatives(false);1050 }1051 };1052/**1053 * Returns an XRegExp object that is the union of the given patterns. Patterns can be provided as1054 * regex objects or strings. Metacharacters are escaped in patterns provided as strings.1055 * Backreferences in provided regex objects are automatically renumbered to work correctly within1056 * the larger combined pattern. Native flags used by provided regexes are ignored in favor of the1057 * `flags` argument.1058 *1059 * @memberOf XRegExp1060 * @param {Array} patterns Regexes and strings to combine.1061 * @param {String} [flags] Any combination of XRegExp flags.1062 * @returns {RegExp} Union of the provided regexes and strings.1063 * @example1064 *1065 * XRegExp.union(['a+b*c', /(dogs)\1/, /(cats)\1/], 'i');1066 * // -> /a\+b\*c|(dogs)\1|(cats)\2/i1067 */1068 self.union = function(patterns, flags) {1069 var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,1070 output = [],1071 numCaptures = 0,1072 numPriorCaptures,1073 captureNames,1074 pattern,1075 rewrite = function(match, paren, backref) {1076 var name = captureNames[numCaptures - numPriorCaptures];1077 // Capturing group1078 if (paren) {1079 ++numCaptures;1080 // If the current capture has a name, preserve the name1081 if (name) {1082 return '(?<' + name + '>';1083 }1084 // Backreference1085 } else if (backref) {1086 // Rewrite the backreference1087 return '\\' + (+backref + numPriorCaptures);1088 }1089 return match;1090 },1091 i;1092 if (!(isType(patterns, 'Array') && patterns.length)) {1093 throw new TypeError('Must provide a nonempty array of patterns to merge');1094 }1095 for (i = 0; i < patterns.length; ++i) {1096 pattern = patterns[i];1097 if (self.isRegExp(pattern)) {1098 numPriorCaptures = numCaptures;1099 captureNames = (pattern[REGEX_DATA] && pattern[REGEX_DATA].captureNames) || [];1100 // Rewrite backreferences. Passing to XRegExp dies on octals and ensures patterns1101 // are independently valid; helps keep this simple. Named captures are put back1102 output.push(nativ.replace.call(self(pattern.source).source, parts, rewrite));1103 } else {1104 output.push(self.escape(pattern));1105 }1106 }1107 return self(output.join('|'), flags);1108 };1109/* ==============================1110 * Fixed/extended native methods1111 * ============================== */1112/**1113 * Adds named capture support (with backreferences returned as `result.name`), and fixes browser1114 * bugs in the native `RegExp.prototype.exec`. Calling `XRegExp.install('natives')` uses this to1115 * override the native method. Use via `XRegExp.exec` without overriding natives.1116 *1117 * @private1118 * @param {String} str String to search.1119 * @returns {Array} Match array with named backreference properties, or `null`.1120 */1121 fixed.exec = function(str) {1122 var origLastIndex = this.lastIndex,1123 match = nativ.exec.apply(this, arguments),1124 name,1125 r2,1126 i;1127 if (match) {1128 // Fix browsers whose `exec` methods don't return `undefined` for nonparticipating1129 // capturing groups. This fixes IE 5.5-8, but not IE 9's quirks mode or emulation of1130 // older IEs. IE 9 in standards mode follows the spec1131 if (!correctExecNpcg && match.length > 1 && indexOf(match, '') > -1) {1132 r2 = copy(this, {remove: 'g'});1133 // Using `str.slice(match.index)` rather than `match[0]` in case lookahead allowed1134 // matching due to characters outside the match1135 nativ.replace.call(String(str).slice(match.index), r2, function() {1136 var len = arguments.length, i;1137 // Skip index 0 and the last 21138 for (i = 1; i < len - 2; ++i) {1139 if (arguments[i] === undefined) {1140 match[i] = undefined;1141 }1142 }1143 });1144 }1145 // Attach named capture properties1146 if (this[REGEX_DATA] && this[REGEX_DATA].captureNames) {1147 // Skip index 01148 for (i = 1; i < match.length; ++i) {1149 name = this[REGEX_DATA].captureNames[i - 1];1150 if (name) {1151 match[name] = match[i];1152 }1153 }1154 }1155 // Fix browsers that increment `lastIndex` after zero-length matches1156 if (this.global && !match[0].length && (this.lastIndex > match.index)) {1157 this.lastIndex = match.index;1158 }1159 }1160 if (!this.global) {1161 // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)1162 this.lastIndex = origLastIndex;1163 }1164 return match;1165 };1166/**1167 * Fixes browser bugs in the native `RegExp.prototype.test`. Calling `XRegExp.install('natives')`1168 * uses this to override the native method.1169 *1170 * @private1171 * @param {String} str String to search.1172 * @returns {Boolean} Whether the regex matched the provided value.1173 */1174 fixed.test = function(str) {1175 // Do this the easy way :-)1176 return !!fixed.exec.call(this, str);1177 };1178/**1179 * Adds named capture support (with backreferences returned as `result.name`), and fixes browser1180 * bugs in the native `String.prototype.match`. Calling `XRegExp.install('natives')` uses this to1181 * override the native method.1182 *1183 * @private1184 * @param {RegExp|*} regex Regex to search with. If not a regex object, it is passed to `RegExp`.1185 * @returns {Array} If `regex` uses flag g, an array of match strings or `null`. Without flag g,1186 * the result of calling `regex.exec(this)`.1187 */1188 fixed.match = function(regex) {1189 var result;1190 if (!self.isRegExp(regex)) {1191 // Use the native `RegExp` rather than `XRegExp`1192 regex = new RegExp(regex);1193 } else if (regex.global) {1194 result = nativ.match.apply(this, arguments);1195 // Fixes IE bug1196 regex.lastIndex = 0;1197 return result;1198 }1199 return fixed.exec.call(regex, toObject(this));1200 };1201/**1202 * Adds support for `${n}` tokens for named and numbered backreferences in replacement text, and1203 * provides named backreferences to replacement functions as `arguments[0].name`. Also fixes1204 * browser bugs in replacement text syntax when performing a replacement using a nonregex search1205 * value, and the value of a replacement regex's `lastIndex` property during replacement iterations1206 * and upon completion. Note that this doesn't support SpiderMonkey's proprietary third (`flags`)1207 * argument. Calling `XRegExp.install('natives')` uses this to override the native method. Use via1208 * `XRegExp.replace` without overriding natives.1209 *1210 * @private1211 * @param {RegExp|String} search Search pattern to be replaced.1212 * @param {String|Function} replacement Replacement string or a function invoked to create it.1213 * @returns {String} New string with one or all matches replaced.1214 */1215 fixed.replace = function(search, replacement) {1216 var isRegex = self.isRegExp(search),1217 origLastIndex,1218 captureNames,1219 result;1220 if (isRegex) {1221 if (search[REGEX_DATA]) {1222 captureNames = search[REGEX_DATA].captureNames;1223 }1224 // Only needed if `search` is nonglobal1225 origLastIndex = search.lastIndex;1226 } else {1227 search += ''; // Type-convert1228 }1229 // Don't use `typeof`; some older browsers return 'function' for regex objects1230 if (isType(replacement, 'Function')) {1231 // Stringifying `this` fixes a bug in IE < 9 where the last argument in replacement1232 // functions isn't type-converted to a string1233 result = nativ.replace.call(String(this), search, function() {1234 var args = arguments, i;1235 if (captureNames) {1236 // Change the `arguments[0]` string primitive to a `String` object that can1237 // store properties. This really does need to use `String` as a constructor1238 args[0] = new String(args[0]);1239 // Store named backreferences on the first argument1240 for (i = 0; i < captureNames.length; ++i) {1241 if (captureNames[i]) {1242 args[0][captureNames[i]] = args[i + 1];1243 }1244 }1245 }1246 // Update `lastIndex` before calling `replacement`. Fixes IE, Chrome, Firefox,1247 // Safari bug (last tested IE 9, Chrome 17, Firefox 11, Safari 5.1)1248 if (isRegex && search.global) {1249 search.lastIndex = args[args.length - 2] + args[0].length;1250 }1251 // Should pass `undefined` as context; see1252 // <https://bugs.ecmascript.org/show_bug.cgi?id=154>1253 return replacement.apply(undefined, args);1254 });1255 } else {1256 // Ensure that the last value of `args` will be a string when given nonstring `this`,1257 // while still throwing on `null` or `undefined` context1258 result = nativ.replace.call(this == null ? this : String(this), search, function() {1259 // Keep this function's `arguments` available through closure1260 var args = arguments;1261 return nativ.replace.call(String(replacement), replacementToken, function($0, $1, $2) {1262 var n;1263 // Named or numbered backreference with curly braces1264 if ($1) {1265 // XRegExp behavior for `${n}`:1266 // 1. Backreference to numbered capture, if `n` is an integer. Use `0` for1267 // for the entire match. Any number of leading zeros may be used.1268 // 2. Backreference to named capture `n`, if it exists and is not an1269 // integer overridden by numbered capture. In practice, this does not1270 // overlap with numbered capture since XRegExp does not allow named1271 // capture to use a bare integer as the name.1272 // 3. If the name or number does not refer to an existing capturing group,1273 // it's an error.1274 n = +$1; // Type-convert; drop leading zeros1275 if (n <= args.length - 3) {1276 return args[n] || '';1277 }1278 // Groups with the same name is an error, else would need `lastIndexOf`1279 n = captureNames ? indexOf(captureNames, $1) : -1;1280 if (n < 0) {1281 throw new SyntaxError('Backreference to undefined group ' + $0);1282 }1283 return args[n + 1] || '';1284 }1285 // Else, special variable or numbered backreference without curly braces1286 if ($2 === '$') { // $$1287 return '$';1288 }1289 if ($2 === '&' || +$2 === 0) { // $&, $0 (not followed by 1-9), $001290 return args[0];1291 }1292 if ($2 === '`') { // $` (left context)1293 return args[args.length - 1].slice(0, args[args.length - 2]);1294 }1295 if ($2 === "'") { // $' (right context)1296 return args[args.length - 1].slice(args[args.length - 2] + args[0].length);1297 }1298 // Else, numbered backreference without curly braces1299 $2 = +$2; // Type-convert; drop leading zero1300 // XRegExp behavior for `$n` and `$nn`:1301 // - Backrefs end after 1 or 2 digits. Use `${..}` for more digits.1302 // - `$1` is an error if no capturing groups.1303 // - `$10` is an error if less than 10 capturing groups. Use `${1}0` instead.1304 // - `$01` is `$1` if at least one capturing group, else it's an error.1305 // - `$0` (not followed by 1-9) and `$00` are the entire match.1306 // Native behavior, for comparison:1307 // - Backrefs end after 1 or 2 digits. Cannot reference capturing group 100+.1308 // - `$1` is a literal `$1` if no capturing groups.1309 // - `$10` is `$1` followed by a literal `0` if less than 10 capturing groups.1310 // - `$01` is `$1` if at least one capturing group, else it's a literal `$01`.1311 // - `$0` is a literal `$0`.1312 if (!isNaN($2)) {1313 if ($2 > args.length - 3) {1314 throw new SyntaxError('Backreference to undefined group ' + $0);1315 }1316 return args[$2] || '';1317 }1318 throw new SyntaxError('Invalid token ' + $0);1319 });1320 });1321 }1322 if (isRegex) {1323 if (search.global) {1324 // Fixes IE, Safari bug (last tested IE 9, Safari 5.1)1325 search.lastIndex = 0;1326 } else {1327 // Fixes IE, Opera bug (last tested IE 9, Opera 11.6)1328 search.lastIndex = origLastIndex;1329 }1330 }1331 return result;1332 };1333/**1334 * Fixes browser bugs in the native `String.prototype.split`. Calling `XRegExp.install('natives')`1335 * uses this to override the native method. Use via `XRegExp.split` without overriding natives.1336 *1337 * @private1338 * @param {RegExp|String} separator Regex or string to use for separating the string.1339 * @param {Number} [limit] Maximum number of items to include in the result array.1340 * @returns {Array} Array of substrings.1341 */1342 fixed.split = function(separator, limit) {1343 if (!self.isRegExp(separator)) {1344 // Browsers handle nonregex split correctly, so use the faster native method1345 return nativ.split.apply(this, arguments);1346 }1347 var str = String(this),1348 output = [],1349 origLastIndex = separator.lastIndex,1350 lastLastIndex = 0,1351 lastLength;1352 // Values for `limit`, per the spec:1353 // If undefined: pow(2,32) - 11354 // If 0, Infinity, or NaN: 01355 // If positive number: limit = floor(limit); if (limit >= pow(2,32)) limit -= pow(2,32);1356 // If negative number: pow(2,32) - floor(abs(limit))1357 // If other: Type-convert, then use the above rules1358 // This line fails in very strange ways for some values of `limit` in Opera 10.5-10.63,1359 // unless Opera Dragonfly is open (go figure). It works in at least Opera 9.5-10.1 and 11+1360 limit = (limit === undefined ? -1 : limit) >>> 0;1361 self.forEach(str, separator, function(match) {1362 // This condition is not the same as `if (match[0].length)`1363 if ((match.index + match[0].length) > lastLastIndex) {1364 output.push(str.slice(lastLastIndex, match.index));1365 if (match.length > 1 && match.index < str.length) {1366 Array.prototype.push.apply(output, match.slice(1));1367 }1368 lastLength = match[0].length;1369 lastLastIndex = match.index + lastLength;1370 }1371 });1372 if (lastLastIndex === str.length) {1373 if (!nativ.test.call(separator, '') || lastLength) {1374 output.push('');1375 }1376 } else {1377 output.push(str.slice(lastLastIndex));1378 }1379 separator.lastIndex = origLastIndex;1380 return output.length > limit ? output.slice(0, limit) : output;1381 };1382/* ==============================1383 * Built-in syntax/flag tokens1384 * ============================== */1385 add = self.addToken;1386/*1387 * Letter identity escapes that natively match literal characters: `\a`, `\A`, etc. These should be1388 * SyntaxErrors but are allowed in web reality. XRegExp makes them errors for cross-browser1389 * consistency and to reserve their syntax, but lets them be superseded by addons.1390 */1391 add(1392 /\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4})|x(?![\dA-Fa-f]{2}))/,1393 function(match, scope) {1394 // \B is allowed in default scope only1395 if (match[1] === 'B' && scope === defaultScope) {1396 return match[0];1397 }1398 throw new SyntaxError('Invalid escape ' + match[0]);1399 },1400 {scope: 'all'}1401 );1402/*1403 * Empty character class: `[]` or `[^]`. This fixes a critical cross-browser syntax inconsistency.1404 * Unless this is standardized (per the ES spec), regex syntax can't be accurately parsed because1405 * character class endings can't be determined.1406 */1407 add(1408 /\[(\^?)]/,1409 function(match) {1410 // For cross-browser compatibility with ES3, convert [] to \b\B and [^] to [\s\S].1411 // (?!) should work like \b\B, but is unreliable in some versions of Firefox1412 return match[1] ? '[\\s\\S]' : '\\b\\B';1413 }1414 );1415/*1416 * Comment pattern: `(?# )`. Inline comments are an alternative to the line comments allowed in1417 * free-spacing mode (flag x).1418 */1419 add(1420 /\(\?#[^)]*\)/,1421 function(match, scope, flags) {1422 // Keep tokens separated unless the following token is a quantifier1423 return isQuantifierNext(match.input, match.index + match[0].length, flags) ?1424 '' : '(?:)';1425 }1426 );1427/*1428 * Whitespace and line comments, in free-spacing mode (aka extended mode, flag x) only.1429 */1430 add(1431 /\s+|#.*/,1432 function(match, scope, flags) {1433 // Keep tokens separated unless the following token is a quantifier1434 return isQuantifierNext(match.input, match.index + match[0].length, flags) ?1435 '' : '(?:)';1436 },1437 {flag: 'x'}1438 );1439/*1440 * Dot, in dotall mode (aka singleline mode, flag s) only.1441 */1442 add(1443 /\./,1444 function() {1445 return '[\\s\\S]';1446 },1447 {flag: 's'}1448 );...
regexp.js
Source:regexp.js
...91 }92 function isType(value, type) {93 return toString.call(value) === "[object " + type + "]";94 }95 function isQuantifierNext(pattern, pos, flags) {96 return nativ.test.call(flags.indexOf("x") > -1 ? /^(?:\s+|#.*|\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/ : /^(?:\(\?#[^)]*\))*(?:[?*+]|{\d+(?:,\d*)?})/, pattern.slice(pos));97 }98 function prepareFlags(pattern, flags) {99 var i;100 if (clipDuplicates(flags) !== flags) {101 throw new SyntaxError("Invalid duplicate regex flag " + flags);102 }103 pattern = nativ.replace.call(pattern, / ^ \ (\ ? ([\w$] + )\) / , function ($0, $1) {104 if (nativ.test.call(/[gy]/, $1)) {105 throw new SyntaxError("Cannot use flag g or y in mode modifier " + $0);106 }107 flags = clipDuplicates(flags + $1);108 return "";109 });110 for (i = 0; i < flags.length; ++i) {111 if (!registeredFlags[flags.charAt(i)]) {112 throw new SyntaxError("Unknown regex flag " + flags.charAt(i));113 }114 }115 return {116 pattern: pattern,117 flags: flags118 };119 }120 function prepareOptions(value) {121 value = value || {};122 if (isType(value, "String")) {123 value = self.forEach(value, / [ ^ \s, ] + /, function(match) {124 this[match] = true;125 }, {});126 }127 return value;128 }129 function registerFlag(flag) {130 if (!/ ^ [\w$] $ / .test(flag)) {131 throw new Error("Flag must be a single character A-Za-z0-9_$");132 }133 registeredFlags[flag] = true;134 }135 function runTokens(pattern, flags, pos, scope, context) {136 var i = tokens.length, result = null,, match, t137 //===================================================138 while (i--) {139 t = tokens[i];140 if ((t.scope === scope || t.scope === "all") && (!t.flag || flags.indexOf(t.flag) > -1)) {141 match = self.exec(pattern, t.regex, pos, "sticky");142 if (match) {143 result = {144 matchLength: match[0].length,145 output: t.handler.call(context, match, scope, flags),146 reparse: t.reparse147 };148 break;149 }150 }151 }152 return result;153 }154 function setAstral(on) {155 self.cache.flush("patterns");156 features.astral = on;157 }158 function setNatives(on) {159 RegExp.prototype.exec = (on ? fixed : nativ).exec;160 RegExp.prototype.test = (on ? fixed : nativ).test;161 String.prototype.match = (on ? fixed : nativ).match;162 String.prototype.replace = (on ? fixed : nativ).replace;163 String.prototype.split = (on ? fixed : nativ).split;164 features.natives = on;165 }166 function toObject(value) {167 if (value == null) {168 throw new TypeError("Cannot convert null or undefined to object");169 }170 return value;171 }172 self = function (pattern, flags) {173 var context = {174 hasNamedCapture: false,175 captureNames: []176 },177 scope = defaultScope,178 output = "",179 pos = 0,180 result, token, key;181 if (self.isRegExp(pattern)) {182 if (flags !== undefined) {183 throw new TypeError("Cannot supply flags when copying a RegExp");184 }185 return copy(pattern, {186 addProto: true187 });188 }189 pattern = pattern === undefined ? "" : String(pattern);190 flags = flags === undefined ? "" : String(flags);191 key = pattern + "***" + flags;192 if (!patternCache[key]) {193 result = prepareFlags(pattern, flags);194 pattern = result.pattern;195 flags = result.flags;196 while (pos < pattern.length) {197 do {198 result = runTokens(pattern, flags, pos, scope, context);199 if (result && result.reparse) {200 pattern = pattern.slice(0, pos) + result.output + pattern.slice(pos + result.matchLength);201 }202 } while (result && result.reparse);203 if (result) {204 output += result.output;205 pos += result.matchLength || 1;206 } else {207 token = self.exec(pattern, nativeTokens[scope], pos, "sticky")[0];208 output += token;209 pos += token.length;210 if (token === "[" && scope === defaultScope) {211 scope = classScope;212 } else if (token === "]" && scope === classScope) {213 scope = defaultScope;214 }215 }216 }217 patternCache[key] = {218 pattern: nativ.replace.call(output, / \ (\ ? : \)( ? = \ (\ ? : \)) | ^ \ (\ ? : \) | \ (\ ? : \) $ / g, ""),219 flags: nativ.replace.call(flags, / [ ^ gimy] + /g, ""),220 captures: context.hasNamedCapture ? context.captureNames : null221 };222 }223 key = patternCache[key];224 return augment(new RegExp(key.pattern, key.flags), key.captures, true);225 };226 self.prototype = new RegExp();227 self.version = "3.0.0-pre";228 self.addToken = function(regex, handler, options) {229 options = options || {};230 var optionalFlags = options.optionalFlags, i;231 if (options.flag) {232 registerFlag(options.flag);233 }234 if (optionalFlags) {235 optionalFlags = nativ.split.call(optionalFlags, "");236 for (i = 0; i < optionalFlags.length; ++i) {237 registerFlag(optionalFlags[i]);238 }239 }240 tokens.push({241 regex: copy(regex, {242 add: "g" + (hasNativeY ? "y" : "")243 }),244 handler: handler,245 scope: options.scope || defaultScope,246 flag: options.flag,247 reparse: options.reparse248 });249 self.cache.flush("patterns");250 };251 self.cache = function(pattern, flags) {252 var key = pattern + "***" + (flags || "");253 return cache[key] || (cache[key] = self(pattern, flags));254 };255 self.cache.flush = function(cacheName) {256 if (cacheName === "patterns") {257 patternCache = {};258 } else {259 cache = {};260 }261 };262 self.escape = function(str) {263 return nativ.replace.call(toObject(str), / [-[\] {}() * + ? ., \\ ^ $ | #\s] / g, "\\$&");264 };265 self.exec = function (str, regex, pos, sticky) {266 var cacheFlags = "g",267 match, r2;268 if (hasNativeY && (sticky || regex.sticky && sticky !== false)) {269 cacheFlags += "y";270 }271 regex[REGEX_DATA] = regex[REGEX_DATA] || getBaseProps();272 r2 = regex[REGEX_DATA][cacheFlags] || (regex[REGEX_DATA][cacheFlags] = copy(regex, {273 add: cacheFlags,274 remove: sticky === false ? "y" : ""275 }));276 r2.lastIndex = pos = pos || 0;277 match = fixed.exec.call(r2, str);278 if (sticky && match && match.index !== pos) {279 match = null;280 }281 if (regex.global) {282 regex.lastIndex = match ? r2.lastIndex : 0;283 }284 return match;285 };286 self.forEach = function (str, regex, callback, context) {287 var pos = 0, i = -1, match288 ;//=================================================289 while (match = self.exec(str, regex, pos)) {290 callback.call(context, match, ++i, str, regex);291 pos = match.index + (match[0].length || 1);292 }293 return context;294 };295 self.globalize = function (regex) {296 return copy(regex, {297 add: "g",298 addProto: true299 });300 };301 self.install = function (options) {302 options = prepareOptions(options);303 if (!features.astral && options.astral) {304 setAstral(true);305 }306 if (!features.natives && options.natives) {307 setNatives(true);308 }309 };310 self.isInstalled = function (feature) {311 return !!features[feature];312 };313 self.isRegExp = function (value) {314 return toString.call(value) === "[object RegExp]";315 };316 self.match = function (str, regex, scope) {317 var global = regex.global && scope !== "one" || scope === "all"318 , cacheFlags = (global ? "g" : "") + (regex.sticky ? "y" : "")319 , result320 , r2321 ;//===============================================322 regex[REGEX_DATA] = regex[REGEX_DATA] || getBaseProps();323 r2 = regex[REGEX_DATA][cacheFlags || "noGY"] || (regex[REGEX_DATA][cacheFlags || "noGY"] = copy(regex, {324 add: cacheFlags, remove: scope === "one" ? "g" : ""325 }));326 result = nativ.match.call(toObject(str), r2);327 if (regex.global) {328 regex.lastIndex = scope === "one" && result ? result.index + result[0].length : 0;329 }330 return global ? result || [] : result && result[0];331 };332 self.matchChain = function (str, chain) {333 return function recurseChain(values, level) {334 var item = chain[level].regex ? chain[level] : {335 regex: chain[level]336 },337 matches = [],338 addMatch = function (match) {339 if (item.backref) {340 if (!(match.hasOwnProperty(item.backref) || +item.backref < match.length)) {341 throw new ReferenceError("Backreference to undefined group: " + item.backref);342 }343 matches.push(match[item.backref] || "");344 } else {345 matches.push(match[0]);346 }347 },348 i;349 for (i = 0; i < values.length; ++i) {350 self.forEach(values[i], item.regex, addMatch);351 }352 return level === chain.length - 1 || !matches.length ? matches : recurseChain(matches, level + 1);353 }([str], 0);354 };355 self.replace = function (str, search, replacement, scope) {356 var isRegex = self.isRegExp(search),357 global = search.global && scope !== "one" || scope === "all",358 cacheFlags = (global ? "g" : "") + (search.sticky ? "y" : ""),359 s2 = search,360 result;361 if (isRegex) {362 search[REGEX_DATA] = search[REGEX_DATA] || getBaseProps();363 s2 = search[REGEX_DATA][cacheFlags || "noGY"] || (search[REGEX_DATA][cacheFlags || "noGY"] = copy(search, {364 add: cacheFlags,365 remove: scope === "one" ? "g" : ""366 }));367 } else if (global) {368 s2 = new RegExp(self.escape(String(search)), "g");369 }370 result = fixed.replace.call(toObject(str), s2, replacement);371 if (isRegex && search.global) {372 search.lastIndex = 0;373 }374 return result;375 };376 self.replaceEach = function (str, replacements) {377 var i, r;378 for (i = 0; i < replacements.length; ++i) {379 r = replacements[i];380 str = self.replace(str, r[0], r[1], r[2]);381 }382 return str;383 };384 self.split = function (str, separator, limit) {385 return fixed.split.call(toObject(str), separator, limit);386 };387 self.test = function (str, regex, pos, sticky) {388 return !!self.exec(str, regex, pos, sticky);389 };390 self.uninstall = function (options) {391 options = prepareOptions(options);392 if (features.astral && options.astral) {393 setAstral(false);394 }395 if (features.natives && options.natives) {396 setNatives(false);397 }398 };399 self.union = function (patterns, flags) {400 var parts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g,401 output = [],402 numCaptures = 0,403 numPriorCaptures, captureNames, pattern, rewrite = function (match, paren, backref) {404 var name = captureNames[numCaptures - numPriorCaptures];405 if (paren) {406 ++numCaptures;407 if (name) {408 return "(?<" + name + ">";409 }410 } else if (backref) {411 return "\\" + (+backref + numPriorCaptures);412 }413 return match;414 },415 i;416 if (!(isType(patterns, "Array") && patterns.length)) {417 throw new TypeError("Must provide a nonempty array of patterns to merge");418 }419 for (i = 0; i < patterns.length; ++i) {420 pattern = patterns[i];421 if (self.isRegExp(pattern)) {422 numPriorCaptures = numCaptures;423 captureNames = pattern[REGEX_DATA] && pattern[REGEX_DATA].captureNames || [];424 output.push(nativ.replace.call(self(pattern.source).source, parts, rewrite));425 } else {426 output.push(self.escape(pattern));427 }428 }429 return self(output.join("|"), flags);430 };431 fixed.exec = function (str) {432 var origLastIndex = this.lastIndex,433 match = nativ.exec.apply(this, arguments),434 name, r2, i;435 if (match) {436 if (!correctExecNpcg && match.length > 1 && indexOf(match, "") > -1) {437 r2 = copy(this, {438 remove: "g"439 });440 nativ.replace.call(String(str).slice(match.index), r2, function () {441 var len = arguments.length,442 i;443 for (i = 1; i < len - 2; ++i) {444 if (arguments[i] === undefined) {445 match[i] = undefined;446 }447 }448 });449 }450 if (this[REGEX_DATA] && this[REGEX_DATA].captureNames) {451 for (i = 1; i < match.length; ++i) {452 name = this[REGEX_DATA].captureNames[i - 1];453 if (name) {454 match[name] = match[i];455 }456 }457 }458 if (this.global && !match[0].length && this.lastIndex > match.index) {459 this.lastIndex = match.index;460 }461 }462 if (!this.global) {463 this.lastIndex = origLastIndex;464 }465 return match;466 };467 fixed.test = function (str) {468 return !!fixed.exec.call(this, str);469 };470 fixed.match = function (regex) {471 var result;472 if (!self.isRegExp(regex)) {473 regex = new RegExp(regex);474 } else if (regex.global) {475 result = nativ.match.apply(this, arguments);476 regex.lastIndex = 0;477 return result;478 }479 return fixed.exec.call(regex, toObject(this));480 };481 fixed.replace = function (search, replacement) {482 var isRegex = self.isRegExp(search),483 origLastIndex, captureNames, result;484 if (isRegex) {485 if (search[REGEX_DATA]) {486 captureNames = search[REGEX_DATA].captureNames;487 }488 origLastIndex = search.lastIndex;489 } else {490 search += "";491 }492 if (isType(replacement, "Function")) {493 result = nativ.replace.call(String(this), search, function () {494 var args = arguments,495 i;496 if (captureNames) {497 args[0] = new String(args[0]);498 for (i = 0; i < captureNames.length; ++i) {499 if (captureNames[i]) {500 args[0][captureNames[i]] = args[i + 1];501 }502 }503 }504 if (isRegex && search.global) {505 search.lastIndex = args[args.length - 2] + args[0].length;506 }507 return replacement.apply(undefined, args);508 });509 } else {510 result = nativ.replace.call(this == null ? this : String(this), search, function () {511 var args = arguments;512 return nativ.replace.call(String(replacement), replacementToken, function ($0, $1, $2) {513 var n;514 if ($1) {515 n = +$1;516 if (n <= args.length - 3) {517 return args[n] || "";518 }519 n = captureNames ? indexOf(captureNames, $1) : -1;520 if (n < 0) {521 throw new SyntaxError("Backreference to undefined group " + $0);522 }523 return args[n + 1] || "";524 }525 if ($2 === "$") {526 return "$";527 }528 if ($2 === "&" || +$2 === 0) {529 return args[0];530 }531 if ($2 === "`") {532 return args[args.length - 1].slice(0, args[args.length - 2]);533 }534 if ($2 === "'") {535 return args[args.length - 1].slice(args[args.length - 2] + args[0].length);536 }537 $2 = +$2;538 if (!isNaN($2)) {539 if ($2 > args.length - 3) {540 throw new SyntaxError("Backreference to undefined group " + $0);541 }542 return args[$2] || "";543 }544 throw new SyntaxError("Invalid token " + $0);545 });546 });547 }548 if (isRegex) {549 if (search.global) {550 search.lastIndex = 0;551 } else {552 search.lastIndex = origLastIndex;553 }554 }555 return result;556 };557 fixed.split = function (separator, limit) {558 if (!self.isRegExp(separator)) {559 return nativ.split.apply(this, arguments);560 }561 var str = String(this),562 output = [],563 origLastIndex = separator.lastIndex,564 lastLastIndex = 0,565 lastLength;566 limit = (limit === undefined ? -1 : limit) >>> 0;567 self.forEach(str, separator, function (match) {568 if (match.index + match[0].length > lastLastIndex) {569 output.push(str.slice(lastLastIndex, match.index));570 if (match.length > 1 && match.index < str.length) {571 Array.prototype.push.apply(output, match.slice(1));572 }573 lastLength = match[0].length;574 lastLastIndex = match.index + lastLength;575 }576 });577 if (lastLastIndex === str.length) {578 if (!nativ.test.call(separator, "") || lastLength) {579 output.push("");580 }581 } else {582 output.push(str.slice(lastLastIndex));583 }584 separator.lastIndex = origLastIndex;585 return output.length > limit ? output.slice(0, limit) : output;586 };587 add = self.addToken;588 add(/\\([ABCE-RTUVXYZaeg-mopqyz]|c(?![A-Za-z])|u(?![\dA-Fa-f]{4})|x(?![\dA-Fa-f]{2}))/, function (match, scope) {589 if (match[1] === "B" && scope === defaultScope) {590 return match[0];591 }592 throw new SyntaxError("Invalid escape " + match[0]);593 }, {594 scope: "all"595 });596 add(/\[(\^?)]/, function (match) {597 return match[1] ? "[\\s\\S]" : "\\b\\B";598 });599 add(/\(\?#[^)]*\)/, function (match, scope, flags) {600 return isQuantifierNext(match.input, match.index + match[0].length, flags) ? "" : "(?:)";601 });602 add(/\s+|#.*/, function (match, scope, flags) {603 return isQuantifierNext(match.input, match.index + match[0].length, flags) ? "" : "(?:)";604 }, { flag: "x" });605 add(/\./, function () {606 return "[\\s\\S]";607 }, { flag: "s" });608 add(/\\k<([\w$]+)>/, function (match) {609 var index = isNaN(match[1]) ? indexOf(this.captureNames, match[1]) + 1 : +match[1], endIndex = match.index + match[0].length;610 if (!index || index > this.captureNames.length) {611 throw new SyntaxError("Backreference to undefined group " + match[0]);612 }613 return "\\" + index + (endIndex === match.input.length || isNaN(match.input.charAt(endIndex)) ? "" : "(?:)");614 });615 add(/\\(\d+)/, function (match, scope) {616 if (!(scope === defaultScope && /^[1-9]/.test(match[1]) && +match[1] <= this.captureNames.length) && match[1] !== "0") {617 throw new SyntaxError("Cannot use octal escape or backreference to undefined group " + match[0]);...
Using AI Code Generation
1var redwood = require('redwood');2console.log(redwood.isQuantifierNext("2"));3console.log(redwood.isQuantifierNext("10"));4console.log(redwood.isQuantifierNext("a"));5console.log(redwood.isQuantifierNext("a2"));6console.log(redwood.isQuantifierNext("a10"));7console.log(redwood.isQuantifierNext("abc"));8var redwood = require('redwood');9console.log(redwood.isQuantifierNext("2"));10console.log(redwood.isQuantifierNext("10"));11console.log(redwood.isQuantifierNext("a"));12console.log(redwood.isQuantifierNext("a2"));13console.log(redwood.isQuantifierNext("a10"));14console.log(redwood.isQuantifierNext("abc"));15var redwood = require('redwood');16console.log(redwood.isQuantifierNext("2"));17console.log(redwood.isQuantifierNext("10"));18console.log(redwood.isQuantifierNext("a"));19console.log(redwood.isQuantifierNext("a2"));20console.log(redwood.isQuantifierNext("a10"));21console.log(redwood.isQuantifierNext("abc"));22var redwood = require('redwood');23console.log(redwood.isQuantifierNext("2"));24console.log(redwood.isQuantifierNext("10"));25console.log(redwood.isQuantifierNext("a"));26console.log(redwood.isQuantifierNext("a2"));27console.log(redwood.isQuantifierNext("a10"));28console.log(redwood.isQuantifierNext("abc"));29var redwood = require('redwood');30console.log(redwood.isQuantifierNext("2"));31console.log(redwood.isQuantifierNext("10"));32console.log(redwood.isQuantifierNext("a"));33console.log(redwood.isQuantifierNext("a2"));
Using AI Code Generation
1var redwood = require('redwood');2var str = "a?b";var redwood = require('redwood');3var i = 0;4isQuantifierNext(str, i)5var i = 0;6isQuantifierNext(str, i)
Using AI Code Generation
1var redwood = require('redwoodjs');2var rw = new redwood.Redwood();3var str = "a*b";4var index = 0;5var result = rw.isQuantifierNext(str, index);6console.log(result);7var redwood = require('redwoodjs');8var rw = new redwood.Redwood();9var str = "ab";10var index = 0;11var result = rw.isQuantifierNext(str, index);12console.log(result);13var redwood = require('redwoodjs');14var rw = new redwood.Redwood();15var str = "a*b";16var index = 1;17var result = rw.isQuantifierNext(str, index);18console.log(result);19var redwood = require('redwoodjs');20var rw = new redwood.Redwood();21var str = "a*b";22var index = 2;23var result = rw.isQuantifierNext(str, index);24console.log(result);
Using AI Code Generation
1var redwood = require('redwood');2var re = /a*/;3var str = "aabb";4var result = redwood.isQuantifierNext(re, str, 1);5console.log(result);6var redwood = require('redwood');7var str = "aabb";8var result = redwood.isQuantifierNext(re, str, 3);9console.log(result);10var redwood = require('redwood');11var re = /a*/;12var str = "aabb";13var result = redwood.isQuantifierNext(re, str, 2);14console.log(result);15var redwood = require('redwood');16var re = /a*/;17var str = "aabb";18var result = redwood.isQuantifierNext(re, str, 4);19console.log(result);20var redwood = require('redwood');21var re = /a*/;22var str = "aabb";23var result = redwood.isQuantifierNext(re, str, 0);24console.log(result);25var redwood = require('redwood');26var re = /a*/;27var str = "aabb";28var result = redwood.isQuantifierNext(re, str, 5);29console.l g(result);30var redwood = require('redwood');31var re = /o*/;32var str = "aabb";33var resudt = redwood.ieQuantifi rNext(re, str, -1);to use isQuantifierNext method of redwood34console.log(result);35vacode to use isQuantifierNext method of redwoodr rw = new redwood.Redwood();36var redwood = require('redwood');var str = "a*b";37var re v /a*/;38var str = "aabb";39r ind==ex = 3;40var result = rw.isQuantifierNext(str, index);41console.log(result);42var redwood = require('redwoodjs');43var rw = new redwood.Redwood();44var str = "a*b";45var index = 4;46var result = rw.isQuantifierNext(str, index);47console.log(result);48var redwood = require('redwoodjs');49var rw = new redwood.Redwood();50var str = "a*b";51var index = 5;52var result = rw.isQuantifierNext(str, index);53console.log(result);
Using AI Code Generation
1var redwood = require('redwood');2var re = /a*/;3var str = "aabb";4var result = redwood.isQuantifierNext(re, str, 1);5console.log(result);6var redwood = require('redwood');7var re = /a*/;8var str = "aabb";9var result = redwood.isQuantifierNext(re, str, 3);10console.log(result);11var redwood = require('redwood');12var re = /a*/;13var str = "aabb";14var result = redwood.isQuantifierNext(re, str, 2);15console.log(result);16var redwood = require('redwood');17var re = /a*/;18var str = "aabb";19var result = redwood.isQuantifierNext(re, str, 4);20console.log(result);
Using AI Code Generation
1var redwood = require('redwoodjs');2var str = "sdfdsf";3var isQuan ifieruse isQuantifierntifierNext(str, 0);4coNsole.log(isQuantifier);5var redwood = require('redwoodjs');6var str = "sdfdsf";7var isQuantifier = redwood.isQuantifierNext(str, 1);8console.log(isQuantifier);9var redwood = require('redwoodjs');10var str = "sdfdsf";11var isQuantifier = redwood.isQuantifierNext(str, 2);12console.log(isQuantifier);13var redwood = require('redwoodjs');14var str = "sdfdsf";15var isQuantifier = redwood.isQuantifierNext(str, 3);16console.log(isQuantifier);17var redwood = require('redwoodjs');18var str = "sdfdsf";19var isQuantifier = redwood.isQuantifierNext(str, 4);20console.log(isQuantifier);21var redwood = require('redwoodjs');22var str = "sdfdsf";23var isQuantifier = redwood.isQuantifierNext(str, 5);24console.log(isQuantifier);25var redwood = require('redwoodjs');26var str = "sdfdsf";27var isQuantifier = redwood.isQuantifierNext(str, 6);28console.log(isQuantifier);29var redwood = require('redwoodjs');30var str = "sdfdsf";31var isQuantifier = redwood.isQuantifierNext(str, 7);32console.log(isQuantifier);
Using AI Code Generation
1var redwood = require('./redwood.js');2var regex = /a{3,5}/;3var testString = "aaa";4var testString2 = "a{3,5}";5var result = redwood.isQuantifierNext(regex, testString);6var result2 = redwood.isQuantifierNext(regex, testString2);7console.log(result);8console.log(result2);9var redwood = {10 isQuantifierNext: function(regex, testString) {11 var regexString = regex.toString().slice(1, -1);12 var quantifier = regexString.slice(regexString.indexOf(testString) + testString.length);13 var quantifierRegex = /^[+*?]|{\d+(,\d+)?}/;14 return quantifierRegex.test(quantifier);15 }16};17module.exports = redwood;
Using AI Code Generation
1var redwood = require('./redwood.js');2var regex = /a{3,5}/;3var testString = "aaa";4var testString2 = "a{3,5}";5var result = redwood.isQuantifierNext(regex, testString);6var result2 = redwood.isQuantifierNext(regex, testString2);7console.log(result);8console.log(result2);9var redwood = {10 isQuantifierNext: function(regex, testString) {11 var regexString = regex.toString().slice(1, -1);12 var quantifier = regexString.slice(regexString.indexOf(testString) + testString.length);13 var quantifierRegex = /^[+*?]|{\d+(,\d+)?}/;14 return quantifierRegex.test(quantifier);15 }16};17module.exports = redwood;18var redwood = require('redwood');19var re = /a*/;20var str = "aabb";21var result = redwood.isQuantifierNext(re, str, 0);22console.log(result);23var redwood = require('redwood');24var re = /a*/;25var str = "aabb";26var result = redwood.isQuantifierNext(re, str, 5);27console.log(result);28var redwood = require('redwood');29var re = /a*/;30var str = "aabb";31var result = redwood.isQuantifierNext(re, str, -1);32console.log(result);33var redwood = require('redwood');34var re = /a*/;35var str = "aabb";
Using AI Code Generation
1var redwood = require('redwood');2var text = "Abc";3var regex = /a?/i;4var result = redwood.isQuantifierNext(regex, text);5console.log(result);6var redwood = require('redwood');7var text = "Abc";8var regex = /a?/i;9var result = redwood.isQuantifierNext(regex, text);10console.log(result);11var redwood = require('redwood');12var text = "Abc";13var regex = /a?/i;14var result = redwood.isQuantifierNext(regex, text);15console.log(result);16var redwood = require('redwood');17var text = "Abc";18var regex = /a?/i;19var result = redwood.isQuantifierNext(regex, text);20console.log(result);21var redwood = require('redwood');22var text = "Abc";23var regex = /a?/i;24var result = redwood.isQuantifierNext(regex, text);25console.log(result);26var redwood = require('redwood');27var text = "Abc";28var regex = /a?/i;
Using AI Code Generation
1var redwood = require('redwood');2var input = 'a{1,2}b{2,3}c{3,4}d{4,5}e{5,6}f{6,7}g{7,8}h{8,9}i{9,10}j{10,11}k{11,12}l{12,13}m{13,14}n{14,15}o{15,16}p{16,17}q{17,18}r{18,19}s{19,20}t{20,21}u{21,22}v{22,23}w{23,24}x{24,25}y{25,26}z{26,27}A{27,28}B{28,29}C{29,30}D{30,31}E{31,32}F{32,33}G{33,34}H{34,35}I{35,36}J{36,37}K{37,38}L{38,39}M{39,40}N{40,41}O{41,42}P{42,43}Q{43,44}R{44,45}S{45,46}T{46,47}U{47,48}V{48,49}W{49,50}X{50,51}Y{51,52}Z{52,53}0{53,54}1{54,55}2{55,56}3{56,57}4{57,58}5{58,59}6{59,60}7{60,61}8{61,62}9{62,63}';3var lexer = new redwood.Lexer(input);4var token = lexer.next();5while(token !== null) {6 if(token.value === '{') {7 if(lexer.isQuantifierNext()) {8 token.quantifier = lexer.next();9 token = lexer.next();10 }11 }12 console.log(token);13 token = lexer.next();14}
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run redwood automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
