1. module path-to-regexp
   1. function path-to-regexp (path, keys, options)
   2. function path-to-regexp.compile (str, options)
   3. function path-to-regexp.parse (str, options)
   4. function path-to-regexp.tokensToFunction (tokens)
   5. function path-to-regexp.tokensToRegExp (tokens, keys, options)

module path-to-regexp

function path-to-regexp (path, keys, options)

• description and source-code

  function pathToRegexp(path, keys, options) {
    if (!isarray(keys)) {
      options = /** @type {!Object} */ (keys || options)
      keys = []
    }
  
    options = options || {}
  
    if (path instanceof RegExp) {
      return regexpToRegexp(path, /** @type {!Array} */ (keys))
    }
  
    if (isarray(path)) {
      return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)
    }
  
    return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)
  }

• example usage

  n/a

function path-to-regexp.compile (str, options)

• description and source-code

  function compile(str, options) {
    return tokensToFunction(parse(str, options))
  }

• example usage

  ...
  ## Usage
  
  ```javascript
  var pathToRegexp = require('path-to-regexp')
  
  // pathToRegexp(path, keys, options)
  // pathToRegexp.parse(path)
  // pathToRegexp.compile(path)
  ```
  
  - **path** An Express-style string, an array of strings, or a regular expression.
  - **keys** An array to be populated with the keys found in the path.
  - **options**
  - **sensitive** When `true` the route will be case sensitive. (default: `false`)
  - **strict** When `false` the trailing slash is optional. (default: `false`)
  ...

function path-to-regexp.parse (str, options)

• description and source-code

  function parse(str, options) {
    var tokens = []
    var key = 0
    var index = 0
    var path = ''
    var defaultDelimiter = options && options.delimiter || '/'
    var res
  
    while ((res = PATH_REGEXP.exec(str)) != null) {
      var m = res[0]
      var escaped = res[1]
      var offset = res.index
      path += str.slice(index, offset)
      index = offset + m.length
  
      // Ignore already escaped sequences.
      if (escaped) {
        path += escaped[1]
        continue
      }
  
      var next = str[index]
      var prefix = res[2]
      var name = res[3]
      var capture = res[4]
      var group = res[5]
      var modifier = res[6]
      var asterisk = res[7]
  
      // Push the current path onto the tokens.
      if (path) {
        tokens.push(path)
        path = ''
      }
  
      var partial = prefix != null && next != null && next !== prefix
      var repeat = modifier === '+' || modifier === '*'
      var optional = modifier === '?' || modifier === '*'
      var delimiter = res[2] || defaultDelimiter
      var pattern = capture || group
  
      tokens.push({
        name: name || key++,
        prefix: prefix || '',
        delimiter: delimiter,
        optional: optional,
        repeat: repeat,
        partial: partial,
        asterisk: !!asterisk,
        pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')
      })
    }
  
    // Match any characters still remaining.
    if (index < str.length) {
      path += str.substr(index)
    }
  
    // If the path exists, push it onto the end.
    if (path) {
      tokens.push(path)
    }
  
    return tokens
  }

• example usage

  ...
  
  ## Usage
  
  ```javascript
  var pathToRegexp = require('path-to-regexp')
  
  // pathToRegexp(path, keys, options)
  // pathToRegexp.parse(path)
  // pathToRegexp.compile(path)
  ```
  
  - **path** An Express-style string, an array of strings, or a regular expression.
  - **keys** An array to be populated with the keys found in the path.
  - **options**
  - **sensitive** When `true` the route will be case sensitive. (default: `false`)
  ...

function path-to-regexp.tokensToFunction (tokens)

• description and source-code

  function tokensToFunction(tokens) {
    // Compile all the tokens into regexps.
    var matches = new Array(tokens.length)
  
    // Compile all the patterns before compilation.
    for (var i = 0; i < tokens.length; i++) {
      if (typeof tokens[i] === 'object') {
        matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$')
      }
    }
  
    return function (obj, opts) {
      var path = ''
      var data = obj || {}
      var options = opts || {}
      var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent
  
      for (var i = 0; i < tokens.length; i++) {
        var token = tokens[i]
  
        if (typeof token === 'string') {
          path += token
  
          continue
        }
  
        var value = data[token.name]
        var segment
  
        if (value == null) {
          if (token.optional) {
            // Prepend partial segment prefixes.
            if (token.partial) {
              path += token.prefix
            }
  
            continue
          } else {
            throw new TypeError('Expected "' + token.name + '" to be defined')
          }
        }
  
        if (isarray(value)) {
          if (!token.repeat) {
            throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`')
          }
  
          if (value.length === 0) {
            if (token.optional) {
              continue
            } else {
              throw new TypeError('Expected "' + token.name + '" to not be empty')
            }
          }
  
          for (var j = 0; j < value.length; j++) {
            segment = encode(value[j])
  
            if (!matches[i].test(segment)) {
              throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify
  (segment) + '`')
            }
  
            path += (j === 0 ? token.prefix : token.delimiter) + segment
          }
  
          continue
        }
  
        segment = token.asterisk ? encodeAsterisk(value) : encode(value)
  
        if (!matches[i].test(segment)) {
          throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"')
        }
  
        path += token.prefix + segment
      }
  
      return path
    }
  }

• example usage

  ...
  **Note:** The generated function will throw on invalid input. It will do all necessary checks to ensure the generated path is valid
  . This method only works with strings.
  
  ### Working with Tokens
  
  Path-To-RegExp exposes the two functions used internally that accept an array of tokens.
  
  * `pathToRegexp.tokensToRegExp(tokens, options)` Transform an array of tokens into a matching regular expression.
  * `pathToRegexp.tokensToFunction(tokens)` Transform an array of tokens into a path generator
   function.
  
  #### Token Information
  
  * `name` The name of the token (`string` for named or `number` for index)
  * `prefix` The prefix character for the segment (`/` or `.`)
  * `delimiter` The delimiter for the segment (same as prefix or `/`)
  * `optional` Indicates the token is optional (`boolean`)
  ...

function path-to-regexp.tokensToRegExp (tokens, keys, options)

• description and source-code

  function tokensToRegExp(tokens, keys, options) {
    if (!isarray(keys)) {
      options = /** @type {!Object} */ (keys || options)
      keys = []
    }
  
    options = options || {}
  
    var strict = options.strict
    var end = options.end !== false
    var route = ''
  
    // Iterate over the tokens and create our regexp string.
    for (var i = 0; i < tokens.length; i++) {
      var token = tokens[i]
  
      if (typeof token === 'string') {
        route += escapeString(token)
      } else {
        var prefix = escapeString(token.prefix)
        var capture = '(?:' + token.pattern + ')'
  
        keys.push(token)
  
        if (token.repeat) {
          capture += '(?:' + prefix + capture + ')*'
        }
  
        if (token.optional) {
          if (!token.partial) {
            capture = '(?:' + prefix + '(' + capture + '))?'
          } else {
            capture = prefix + '(' + capture + ')?'
          }
        } else {
          capture = prefix + '(' + capture + ')'
        }
  
        route += capture
      }
    }
  
    var delimiter = escapeString(options.delimiter || '/')
    var endsWithDelimiter = route.slice(-delimiter.length) === delimiter
  
    // In non-strict mode we allow a slash at the end of match. If the path to
    // match already ends with a slash, we remove it for consistency. The slash
    // is valid at the end of a path match, not in the middle. This is important
    // in non-ending mode, where "/test/" shouldn't match "/test//route".
    if (!strict) {
      route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?'
    }
  
    if (end) {
      route += '$'
    } else {
      // In non-ending mode, we need the capturing groups to match as much as
      // possible by using a positive lookahead to the end or next path segment.
      route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)'
    }
  
    return attachKeys(new RegExp('^' + route, flags(options)), keys)
  }

• example usage

  ...
  
  **Note:** The generated function will throw on invalid input. It will do all necessary checks to ensure the generated path is valid
  . This method only works with strings.
  
  ### Working with Tokens
  
  Path-To-RegExp exposes the two functions used internally that accept an array of tokens.
  
  * `pathToRegexp.tokensToRegExp(tokens, options)` Transform an array of tokens into a
  matching regular expression.
  * `pathToRegexp.tokensToFunction(tokens)` Transform an array of tokens into a path generator function.
  
  #### Token Information
  
  * `name` The name of the token (`string` for named or `number` for index)
  * `prefix` The prefix character for the segment (`/` or `.`)
  * `delimiter` The delimiter for the segment (same as prefix or `/`)
  ...