FM / lib

/var/www/cobraambalaj/node_modules/ret/lib/

/var/www/cobraambalaj/node_modules/ret/lib

Name	Size	Mode	Actions
index.js	6555	0644	edit dl rm
positions.js	367	0644	edit dl rm
sets.js	2230	0644	edit dl rm
types.js	166	0644	edit dl rm
util.js	2616	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/ret/lib/index.js (6555B)

var util      = require('./util');
var types     = require('./types');
var sets      = require('./sets');
var positions = require('./positions');

module.exports = function(regexpStr) {
  var i = 0, l, c,
      start = { type: types.ROOT, stack: []},

// Keep track of last clause/group and stack.
      lastGroup = start,
      last = start.stack,
      groupStack = [];

var repeatErr = function(i) {
    util.error(regexpStr, 'Nothing to repeat at column ' + (i - 1));
  };

// Decode a few escaped characters.
  var str = util.strToChars(regexpStr);
  l = str.length;

// Iterate through each character in string.
  while (i < l) {
    c = str[i++];

switch (c) {
      // Handle escaped characters, inclues a few sets.
      case '\\':
        c = str[i++];

switch (c) {
          case 'b':
            last.push(positions.wordBoundary());
            break;

case 'B':
            last.push(positions.nonWordBoundary());
            break;

case 'w':
            last.push(sets.words());
            break;

case 'W':
            last.push(sets.notWords());
            break;

case 'd':
            last.push(sets.ints());
            break;

case 'D':
            last.push(sets.notInts());
            break;

case 's':
            last.push(sets.whitespace());
            break;

case 'S':
            last.push(sets.notWhitespace());
            break;

default:
            // Check if c is integer.
            // In which case it's a reference.
            if (/\d/.test(c)) {
              last.push({ type: types.REFERENCE, value: parseInt(c, 10) });

// Escaped character.
            } else {
              last.push({ type: types.CHAR, value: c.charCodeAt(0) });
            }
        }

break;

// Positionals.
      case '^':
          last.push(positions.begin());
        break;

case '$':
          last.push(positions.end());
        break;

// Handle custom sets.
      case '[':
        // Check if this class is 'anti' i.e. [^abc].
        var not;
        if (str[i] === '^') {
          not = true;
          i++;
        } else {
          not = false;
        }

// Get all the characters in class.
        var classTokens = util.tokenizeClass(str.slice(i), regexpStr);

// Increase index by length of class.
        i += classTokens[1];
        last.push({
          type: types.SET,
          set: classTokens[0],
          not: not,
        });

break;

// Class of any character except \n.
      case '.':
        last.push(sets.anyChar());
        break;

// Push group onto stack.
      case '(':
        // Create group.
        var group = {
          type: types.GROUP,
          stack: [],
          remember: true,
        };

c = str[i];

// If if this is a special kind of group.
        if (c === '?') {
          c = str[i + 1];
          i += 2;

// Match if followed by.
          if (c === '=') {
            group.followedBy = true;

// Match if not followed by.
          } else if (c === '!') {
            group.notFollowedBy = true;

} else if (c !== ':') {
            util.error(regexpStr,
              'Invalid group, character \'' + c +
              '\' after \'?\' at column ' + (i - 1));
          }

group.remember = false;
        }

// Insert subgroup into current group stack.
        last.push(group);

// Remember the current group for when the group closes.
        groupStack.push(lastGroup);

// Make this new group the current group.
        lastGroup = group;
        last = group.stack;
        break;

// Pop group out of stack.
      case ')':
        if (groupStack.length === 0) {
          util.error(regexpStr, 'Unmatched ) at column ' + (i - 1));
        }
        lastGroup = groupStack.pop();

// Check if this group has a PIPE.
        // To get back the correct last stack.
        last = lastGroup.options ?
          lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
        break;

// Use pipe character to give more choices.
      case '|':
        // Create array where options are if this is the first PIPE
        // in this clause.
        if (!lastGroup.options) {
          lastGroup.options = [lastGroup.stack];
          delete lastGroup.stack;
        }

// Create a new stack and add to options for rest of clause.
        var stack = [];
        lastGroup.options.push(stack);
        last = stack;
        break;

// Repetition.
      // For every repetition, remove last element from last stack
      // then insert back a RANGE object.
      // This design is chosen because there could be more than
      // one repetition symbols in a regex i.e. `a?+{2,3}`.
      case '{':
        var rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)), min, max;
        if (rs !== null) {
          if (last.length === 0) {
            repeatErr(i);
          }
          min = parseInt(rs[1], 10);
          max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;
          i += rs[0].length;

last.push({
            type: types.REPETITION,
            min: min,
            max: max,
            value: last.pop(),
          });
        } else {
          last.push({
            type: types.CHAR,
            value: 123,
          });
        }
        break;

case '?':
        if (last.length === 0) {
          repeatErr(i);
        }
        last.push({
          type: types.REPETITION,
          min: 0,
          max: 1,
          value: last.pop(),
        });
        break;

case '+':
        if (last.length === 0) {
          repeatErr(i);
        }
        last.push({
          type: types.REPETITION,
          min: 1,
          max: Infinity,
          value: last.pop(),
        });
        break;

case '*':
        if (last.length === 0) {
          repeatErr(i);
        }
        last.push({
          type: types.REPETITION,
          min: 0,
          max: Infinity,
          value: last.pop(),
        });
        break;

// Default is a character that is not `\[](){}?+*^$`.
      default:
        last.push({
          type: types.CHAR,
          value: c.charCodeAt(0),
        });
    }

}

// Check if any groups have not been closed.
  if (groupStack.length !== 0) {
    util.error(regexpStr, 'Unterminated group');
  }

return start;
};

module.exports.types = types;

cmd: