@atlaskit/eslint-plugin-no-lookahead-lookbehind-regexp/dist/esm/helpers/analyzeRegExpForLookaheadAndLookbehind.js

Fork of https://github.com/JonasBa/eslint-plugin-no-lookahead-lookbehind-regexp

function analyzeRegExpForLookaheadAndLookbehind(input, rules) {
  // Lookahead and lookbehind require min 5 characters to be useful, however
  // an expression like /(?=)/ which uses only 4, although not useful, can still crash an application
  if (input.length < 4) {
    return [];
  }
  var current = 0;
  var peek = function peek() {
    return input.charAt(current + 1);
  };
  var advance = function advance() {
    return input.charAt(++current);
  };
  var isEnd = function isEnd() {
    return current > input.length;
  };
  var isEscaped = function isEscaped() {
    return input.charAt(current - 1) === '\\';
  };
  var matchedExpressions = [];
  while (!isEnd()) {
    var start = current;
    var char = input.charAt(start);
    switch (char) {
      case '(':
        {
          // If first char is ( then the sequence cannot be escaped.
          if (current > 0 && isEscaped()) {
            advance();
            break;
          }
          if (peek() === '?') {
            advance();

            // Lookahead
            if (peek() === '=') {
              if (rules['no-lookahead']) {
                matchedExpressions.push({
                  type: 'lookahead',
                  position: start
                });
              }
              advance();
              break;
            }
            // Negative lookahead
            if (peek() === '!') {
              if (rules['no-negative-lookahead']) {
                matchedExpressions.push({
                  type: 'lookahead',
                  negative: 1,
                  position: start
                });
              }
              advance();
              break;
            }

            // Lookbehind
            if (peek() === '<') {
              if (input.charAt(current + 2) === '=') {
                if (rules['no-lookbehind']) {
                  matchedExpressions.push({
                    type: 'lookbehind',
                    position: start
                  });
                  advance();
                  advance();
                  break;
                }
              }
              // Negative Lookbehind
              if (input.charAt(current + 2) === '!') {
                if (rules['no-negative-lookbehind']) {
                  matchedExpressions.push({
                    type: 'lookbehind',
                    negative: 1,
                    position: start
                  });
                  advance();
                  advance();
                  break;
                }
              }
            }
          } else {
            advance();
          }
          break;
        }
      default:
        {
          advance();
        }
    }
  }
  return matchedExpressions;
}
export { analyzeRegExpForLookaheadAndLookbehind };