testing new parallax image
[josuexyz/.git] / node_modules / path-to-regexp / index.js
1 /**
2  * Expose `pathtoRegexp`.
3  */
4
5 module.exports = pathtoRegexp;
6
7 /**
8  * Match matching groups in a regular expression.
9  */
10 var MATCHING_GROUP_REGEXP = /\((?!\?)/g;
11
12 /**
13  * Normalize the given path string,
14  * returning a regular expression.
15  *
16  * An empty array should be passed,
17  * which will contain the placeholder
18  * key names. For example "/user/:id" will
19  * then contain ["id"].
20  *
21  * @param  {String|RegExp|Array} path
22  * @param  {Array} keys
23  * @param  {Object} options
24  * @return {RegExp}
25  * @api private
26  */
27
28 function pathtoRegexp(path, keys, options) {
29   options = options || {};
30   keys = keys || [];
31   var strict = options.strict;
32   var end = options.end !== false;
33   var flags = options.sensitive ? '' : 'i';
34   var extraOffset = 0;
35   var keysOffset = keys.length;
36   var i = 0;
37   var name = 0;
38   var m;
39
40   if (path instanceof RegExp) {
41     while (m = MATCHING_GROUP_REGEXP.exec(path.source)) {
42       keys.push({
43         name: name++,
44         optional: false,
45         offset: m.index
46       });
47     }
48
49     return path;
50   }
51
52   if (Array.isArray(path)) {
53     // Map array parts into regexps and return their source. We also pass
54     // the same keys and options instance into every generation to get
55     // consistent matching groups before we join the sources together.
56     path = path.map(function (value) {
57       return pathtoRegexp(value, keys, options).source;
58     });
59
60     return new RegExp('(?:' + path.join('|') + ')', flags);
61   }
62
63   path = ('^' + path + (strict ? '' : path[path.length - 1] === '/' ? '?' : '/?'))
64     .replace(/\/\(/g, '/(?:')
65     .replace(/([\/\.])/g, '\\$1')
66     .replace(/(\\\/)?(\\\.)?:(\w+)(\(.*?\))?(\*)?(\?)?/g, function (match, slash, format, key, capture, star, optional, offset) {
67       slash = slash || '';
68       format = format || '';
69       capture = capture || '([^\\/' + format + ']+?)';
70       optional = optional || '';
71
72       keys.push({
73         name: key,
74         optional: !!optional,
75         offset: offset + extraOffset
76       });
77
78       var result = ''
79         + (optional ? '' : slash)
80         + '(?:'
81         + format + (optional ? slash : '') + capture
82         + (star ? '((?:[\\/' + format + '].+?)?)' : '')
83         + ')'
84         + optional;
85
86       extraOffset += result.length - match.length;
87
88       return result;
89     })
90     .replace(/\*/g, function (star, index) {
91       var len = keys.length
92
93       while (len-- > keysOffset && keys[len].offset > index) {
94         keys[len].offset += 3; // Replacement length minus asterisk length.
95       }
96
97       return '(.*)';
98     });
99
100   // This is a workaround for handling unnamed matching groups.
101   while (m = MATCHING_GROUP_REGEXP.exec(path)) {
102     var escapeCount = 0;
103     var index = m.index;
104
105     while (path.charAt(--index) === '\\') {
106       escapeCount++;
107     }
108
109     // It's possible to escape the bracket.
110     if (escapeCount % 2 === 1) {
111       continue;
112     }
113
114     if (keysOffset + i === keys.length || keys[keysOffset + i].offset > m.index) {
115       keys.splice(keysOffset + i, 0, {
116         name: name++, // Unnamed matching groups must be consistently linear.
117         optional: false,
118         offset: m.index
119       });
120     }
121
122     i++;
123   }
124
125   // If the path is non-ending, match until the end or a slash.
126   path += (end ? '$' : (path[path.length - 1] === '/' ? '' : '(?=\\/|$)'));
127
128   return new RegExp(path, flags);
129 };