/**
   * Expose `pathtoRegexp`.
   */
  
  module.exports = pathtoRegexp;
  
  /**
   * Match matching groups in a regular expression.
   */
  var MATCHING_GROUP_REGEXP = /\((?!\?)/g;
  
  /**
   * Normalize the given path string,
   * returning a regular expression.
   *
   * An empty array should be passed,
   * which will contain the placeholder
   * key names. For example "/user/:id" will
   * then contain ["id"].
   *
   * @param  {String|RegExp|Array} path
   * @param  {Array} keys
   * @param  {Object} options
   * @return {RegExp}
   * @api private
   */
  
  function pathtoRegexp(path, keys, options) {
    options = options || {};
    keys = keys || [];
    var strict = options.strict;
    var end = options.end !== false;
    var flags = options.sensitive ? '' : 'i';
    var extraOffset = 0;
    var keysOffset = keys.length;
    var i = 0;
    var name = 0;
    var m;
  
    if (path instanceof RegExp) {
      while (m = MATCHING_GROUP_REGEXP.exec(path.source)) {
        keys.push({
          name: name++,
          optional: false,
          offset: m.index
        });
      }
  
      return path;
    }
  
    if (Array.isArray(path)) {
      // Map array parts into regexps and return their source. We also pass
      // the same keys and options instance into every generation to get
      // consistent matching groups before we join the sources together.
      path = path.map(function (value) {
        return pathtoRegexp(value, keys, options).source;
      });
  
      return new RegExp('(?:' + path.join('|') + ')', flags);
    }
  
    path = ('^' + path + (strict ? '' : path[path.length - 1] === '/' ? '?' : '/?'))
      .replace(/\/\(/g, '/(?:')
      .replace(/([\/\.])/g, '\\$1')
      .replace(/(\\\/)?(\\\.)?:(\w+)(\(.*?\))?(\*)?(\?)?/g, function (match, slash, format, key, capture, star, optional, offset) {
        slash = slash || '';
        format = format || '';
        capture = capture || '([^\\/' + format + ']+?)';
        optional = optional || '';
  
        keys.push({
          name: key,
          optional: !!optional,
          offset: offset + extraOffset
        });
  
        var result = ''
          + (optional ? '' : slash)
          + '(?:'
          + format + (optional ? slash : '') + capture
          + (star ? '((?:[\\/' + format + '].+?)?)' : '')
          + ')'
          + optional;
  
        extraOffset += result.length - match.length;
  
        return result;
      })
      .replace(/\*/g, function (star, index) {
        var len = keys.length
  
        while (len-- > keysOffset && keys[len].offset > index) {
          keys[len].offset += 3; // Replacement length minus asterisk length.
        }
  
        return '(.*)';
      });
  
    // This is a workaround for handling unnamed matching groups.
    while (m = MATCHING_GROUP_REGEXP.exec(path)) {
      var escapeCount = 0;
      var index = m.index;
  
      while (path.charAt(--index) === '\\') {
        escapeCount++;
      }
  
      // It's possible to escape the bracket.
      if (escapeCount % 2 === 1) {
        continue;
      }
  
      if (keysOffset + i === keys.length || keys[keysOffset + i].offset > m.index) {
        keys.splice(keysOffset + i, 0, {
          name: name++, // Unnamed matching groups must be consistently linear.
          optional: false,
          offset: m.index
        });
      }
  
      i++;
    }
  
    // If the path is non-ending, match until the end or a slash.
    path += (end ? '$' : (path[path.length - 1] === '/' ? '' : '(?=\\/|$)'));
  
    return new RegExp(path, flags);
  };