| /** |
| * 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); |
| }; |