Top 10 Examples of "xregexp in functional component" in JavaScript

issueObj['refreshed'] = true;
  issueObj['points'] = null;
  issueObj['boardState'] = null;

  //The data version module is used to identify when the data model has changed and it is necessary to clear the cache.
  // For now only doing this for issues
  issueObj['data_version'] = Meteor.settings.public.data_version;

  if (issueObj.labels !== undefined) {
    //Get points from labels
    // Regex to test: SP:[.\d]
    //let pointsExp = RegExp('SP:[.\\d]');
    let pointsExp = XRegExp('SP:[.\\d]');
    //let pointsLabelExp = RegExp('loe:(?.+)');
    //let boardExp = RegExp('(?AB):(?[.\\d]):(?.+)');
    let boardExp = XRegExp('(?AB):(?[.\\d]):(?.+)');
    for (var currentLabel of issueObj.labels.edges) {
      if (pointsExp.test(currentLabel.node.name)) {
        let points = parseInt(currentLabel.node.name.replace('SP:', ''));
        issueObj['points'] = points;
      } else if (pointsExp.test(currentLabel.node.description)) {
        let points = parseInt(currentLabel.node.description.replace('SP:', ''));
        issueObj['points'] = points;
      } else if (
        Meteor.settings.public.labels.effort !== undefined &&
        Meteor.settings.public.labels.effort[currentLabel.node.name] !==
          undefined &&
        Number.isInteger(
          Meteor.settings.public.labels.effort[currentLabel.node.name]
        )
      ) {
        // Interesting edge case, if the label is actually named "constructor"

function getFont(text) {
  // Once unicode regex scripts are fully supported we should be able to get rid of the dependency
  // on xRegExp library.  See https://github.com/tc39/proposal-regexp-unicode-property-escapes
  // for more information. We are matching Han characters which is one of the supported unicode scripts
  // (you can see the full list of supported scripts here: http://www.unicode.org/standard/supported.html).
  // This will match Chinese, Japanese, Korean and some other Asian languages.
  const isCKJ = xRegExp('\\p{Han}').test(text, 'g');
  if(isCKJ) {
    return 'noto-cjk';
  } else {
    return 'Roboto';
  }
}

// String optimized for compatibility, ie. CO₂ becomes CO2.
var scientific = "CO\u2082 and E=mc\u00B2";
console.log("- Example 3 -");
console.log(scientific);
console.log(scientific.normalize("NFKC"));

// NOTE: Rest of the example requires XRegExp: npm install xregexp

// Remove combining characters / marks from Swedish name, ie. ö becomes o.
// This is useful for indexing and searching internationalized text.
try {
	var xregexp = require("xregexp").XRegExp;
	var name = "\u00C5ngstr\u00F6m";
	console.log("- Example 4 -");
	console.log(name.normalize("NFKD"));
	console.log(name.normalize("NFKD").replace(xregexp("\\p{M}", "g"), ""));
} catch (ex) {}

// Here split some special cases like: period (`terminal.integrated`),
        // digit (`good2know`), dash (`wp-admin`) etc. Other consequence should
        // be that these words are spelled both as split and as the whole.
        var rother = XRegExp('([^\ \.0-9\-\(\)‘’]+)');
        var rsep = /[\ \.0-9\-\(\)‘’]/;
        var parts = [];

        // We need a phantom split (e.g. for "2sth", "(sth)" case).
        if (rsep.test(word)) {
            parts.push({
                word: '',
                offset: 0
            });
        }

        XRegExp.forEach(word, rother, (match, i) => {
            parts.push({
                word: match[0],
                offset: match.index
            });
        });

        return parts;
    }

SpellRight.prototype.splitSnakeCase = function (word) {

        // SnakeCase cases: HTML_Script, snake_Case, __test__.
        var rsnake = XRegExp('([^_]+)');
        var rsep = /_/;
        var parts = [];

        // We need a phantom split (e.g. for "_sth: case).
        if (rsep.test(word)) {
            parts.push({
                word: '',
                offset: 0
            });
        }

        XRegExp.forEach(word, rsnake, (match, i) => {
            parts.push({
                word: match[0],
                offset: match.index
            });
        });

        return parts;
    }

function execRegex (text, pattern, start) {
  var results = null

  if (pattern.xregexp) {
    // a regex that xregexp can handle right out of the gate.
    results = xregexp.exec(text, pattern, start)
  } else if (/^\(\?[><][=!]?/.exec(pattern.original)) {
    // a leading lookbehind regex.
    results = xregexp.execLb(text, pattern.original, start)
  } else if (/\(\?[><][=!]?/.exec(pattern.original)) {
    // allow for an alternation chracter followed by
    // a lookbehind regex.
    var splitPattern = pattern.original.split(/\|(\(\?[><][=!][^|]*)/g)
    if (splitPattern.length > 1) results = alternationPrefixedLookbehinds(text, splitPattern, start)
  }

  return results
}

segments.map(segment => {
              // determine if the segment is a die or not
              if (XRegExp.test(segment, dieRegex)) {
                // this is a die - parse it into an object and add to the list
                parsed.push(...parseDie(segment));
              } else {
                // not a die (ie. number, operator)
                if(diceUtils.isNumeric(segment)){
                  segment = parseFloat(segment);
                }

                // add to the list
                parsed.push(segment);
              }
            });
          }

')\\s*' +
        //   var foo = bar '=>' {}
        '=>\\s*'
    );

    var functionRegexMatch = null;
    var methodRegexMatch = null;
    var geterSetterMethodRegexMatch = null;
    var arrowFunctionRegexMatch = null;

    // XXX: Note assignments
    var matches = (
        (functionRegexMatch = xregexp.exec(line, functionRegex)) ||
            (methodRegexMatch = xregexp.exec(line, methodRegex)) ||
            (geterSetterMethodRegexMatch = xregexp.exec(line, geterSetterMethodRegex)) ||
            (arrowFunctionRegexMatch = xregexp.exec(line, arrowFunctionRegex))
    );

    if(matches === null) {
        return null;
    }
    // grab the name out of "name1 = function name2(foo)" preferring name1
    var name = matches.name1 || matches.name2 || '';
    var args = matches.args || matches.arg || null;

    // check for async method to set retval to promise
    var retval = null;
    if (matches.promise) {
        retval = 'Promise';
    } else if (matches.generator) {
        retval = 'Generator';
    }

CoffeeParser.prototype.parse_var = function(line) {
    //   var foo = blah,
    //       foo = blah;
    //   baz.foo = blah;
    //   baz = {
    //        foo : blah
    //   }
    var regex = xregexp(
        '(?P' + this.settings.varIdentifier + ')\\s*[=:]\\s*(?P.*?)(?:[;,]|$)'
    );
    var matches = xregexp.exec(line, regex);
    if(matches === null)
        return null;

    return [matches.name, matches.val.trim()];
};

for (var i = 0, pattern; (pattern = splitPattern[i]) !== undefined; i++) {
    if (/\(\?[><][=!]?/.exec(pattern)) {
      patterns.push(currentPattern)
      currentPattern = ''
    }
    currentPattern += pattern
  }
  patterns.push(currentPattern)

  // now apply each pattern.
  for (i = 0, pattern; (pattern = patterns[i]) !== undefined; i++) {
    try {
      if (/\(\?[><][=!]?/.exec(pattern)) {
        result = xregexp.execLb(text, pattern, start)
      } else {
        result = xregexp.exec(text, xregexp(pattern), start)
      }
      if (result) return result
    } catch (e) {
      // we're officially in uncharted territory.
      return null
    }
  }

  return null
}