source: trip-planner-front/node_modules/to-regex-range/index.js@ 76712b2

Last change on this file since 76712b2 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 6.3 KB
Line 
1/*!
2 * to-regex-range <https://github.com/micromatch/to-regex-range>
3 *
4 * Copyright (c) 2015-present, Jon Schlinkert.
5 * Released under the MIT License.
6 */
7
8'use strict';
9
10const isNumber = require('is-number');
11
12const toRegexRange = (min, max, options) => {
13 if (isNumber(min) === false) {
14 throw new TypeError('toRegexRange: expected the first argument to be a number');
15 }
16
17 if (max === void 0 || min === max) {
18 return String(min);
19 }
20
21 if (isNumber(max) === false) {
22 throw new TypeError('toRegexRange: expected the second argument to be a number.');
23 }
24
25 let opts = { relaxZeros: true, ...options };
26 if (typeof opts.strictZeros === 'boolean') {
27 opts.relaxZeros = opts.strictZeros === false;
28 }
29
30 let relax = String(opts.relaxZeros);
31 let shorthand = String(opts.shorthand);
32 let capture = String(opts.capture);
33 let wrap = String(opts.wrap);
34 let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
35
36 if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
37 return toRegexRange.cache[cacheKey].result;
38 }
39
40 let a = Math.min(min, max);
41 let b = Math.max(min, max);
42
43 if (Math.abs(a - b) === 1) {
44 let result = min + '|' + max;
45 if (opts.capture) {
46 return `(${result})`;
47 }
48 if (opts.wrap === false) {
49 return result;
50 }
51 return `(?:${result})`;
52 }
53
54 let isPadded = hasPadding(min) || hasPadding(max);
55 let state = { min, max, a, b };
56 let positives = [];
57 let negatives = [];
58
59 if (isPadded) {
60 state.isPadded = isPadded;
61 state.maxLen = String(state.max).length;
62 }
63
64 if (a < 0) {
65 let newMin = b < 0 ? Math.abs(b) : 1;
66 negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
67 a = state.a = 0;
68 }
69
70 if (b >= 0) {
71 positives = splitToPatterns(a, b, state, opts);
72 }
73
74 state.negatives = negatives;
75 state.positives = positives;
76 state.result = collatePatterns(negatives, positives, opts);
77
78 if (opts.capture === true) {
79 state.result = `(${state.result})`;
80 } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
81 state.result = `(?:${state.result})`;
82 }
83
84 toRegexRange.cache[cacheKey] = state;
85 return state.result;
86};
87
88function collatePatterns(neg, pos, options) {
89 let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
90 let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
91 let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
92 let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
93 return subpatterns.join('|');
94}
95
96function splitToRanges(min, max) {
97 let nines = 1;
98 let zeros = 1;
99
100 let stop = countNines(min, nines);
101 let stops = new Set([max]);
102
103 while (min <= stop && stop <= max) {
104 stops.add(stop);
105 nines += 1;
106 stop = countNines(min, nines);
107 }
108
109 stop = countZeros(max + 1, zeros) - 1;
110
111 while (min < stop && stop <= max) {
112 stops.add(stop);
113 zeros += 1;
114 stop = countZeros(max + 1, zeros) - 1;
115 }
116
117 stops = [...stops];
118 stops.sort(compare);
119 return stops;
120}
121
122/**
123 * Convert a range to a regex pattern
124 * @param {Number} `start`
125 * @param {Number} `stop`
126 * @return {String}
127 */
128
129function rangeToPattern(start, stop, options) {
130 if (start === stop) {
131 return { pattern: start, count: [], digits: 0 };
132 }
133
134 let zipped = zip(start, stop);
135 let digits = zipped.length;
136 let pattern = '';
137 let count = 0;
138
139 for (let i = 0; i < digits; i++) {
140 let [startDigit, stopDigit] = zipped[i];
141
142 if (startDigit === stopDigit) {
143 pattern += startDigit;
144
145 } else if (startDigit !== '0' || stopDigit !== '9') {
146 pattern += toCharacterClass(startDigit, stopDigit, options);
147
148 } else {
149 count++;
150 }
151 }
152
153 if (count) {
154 pattern += options.shorthand === true ? '\\d' : '[0-9]';
155 }
156
157 return { pattern, count: [count], digits };
158}
159
160function splitToPatterns(min, max, tok, options) {
161 let ranges = splitToRanges(min, max);
162 let tokens = [];
163 let start = min;
164 let prev;
165
166 for (let i = 0; i < ranges.length; i++) {
167 let max = ranges[i];
168 let obj = rangeToPattern(String(start), String(max), options);
169 let zeros = '';
170
171 if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
172 if (prev.count.length > 1) {
173 prev.count.pop();
174 }
175
176 prev.count.push(obj.count[0]);
177 prev.string = prev.pattern + toQuantifier(prev.count);
178 start = max + 1;
179 continue;
180 }
181
182 if (tok.isPadded) {
183 zeros = padZeros(max, tok, options);
184 }
185
186 obj.string = zeros + obj.pattern + toQuantifier(obj.count);
187 tokens.push(obj);
188 start = max + 1;
189 prev = obj;
190 }
191
192 return tokens;
193}
194
195function filterPatterns(arr, comparison, prefix, intersection, options) {
196 let result = [];
197
198 for (let ele of arr) {
199 let { string } = ele;
200
201 // only push if _both_ are negative...
202 if (!intersection && !contains(comparison, 'string', string)) {
203 result.push(prefix + string);
204 }
205
206 // or _both_ are positive
207 if (intersection && contains(comparison, 'string', string)) {
208 result.push(prefix + string);
209 }
210 }
211 return result;
212}
213
214/**
215 * Zip strings
216 */
217
218function zip(a, b) {
219 let arr = [];
220 for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
221 return arr;
222}
223
224function compare(a, b) {
225 return a > b ? 1 : b > a ? -1 : 0;
226}
227
228function contains(arr, key, val) {
229 return arr.some(ele => ele[key] === val);
230}
231
232function countNines(min, len) {
233 return Number(String(min).slice(0, -len) + '9'.repeat(len));
234}
235
236function countZeros(integer, zeros) {
237 return integer - (integer % Math.pow(10, zeros));
238}
239
240function toQuantifier(digits) {
241 let [start = 0, stop = ''] = digits;
242 if (stop || start > 1) {
243 return `{${start + (stop ? ',' + stop : '')}}`;
244 }
245 return '';
246}
247
248function toCharacterClass(a, b, options) {
249 return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
250}
251
252function hasPadding(str) {
253 return /^-?(0+)\d/.test(str);
254}
255
256function padZeros(value, tok, options) {
257 if (!tok.isPadded) {
258 return value;
259 }
260
261 let diff = Math.abs(tok.maxLen - String(value).length);
262 let relax = options.relaxZeros !== false;
263
264 switch (diff) {
265 case 0:
266 return '';
267 case 1:
268 return relax ? '0?' : '0';
269 case 2:
270 return relax ? '0{0,2}' : '00';
271 default: {
272 return relax ? `0{0,${diff}}` : `0{${diff}}`;
273 }
274 }
275}
276
277/**
278 * Cache
279 */
280
281toRegexRange.cache = {};
282toRegexRange.clearCache = () => (toRegexRange.cache = {});
283
284/**
285 * Expose `toRegexRange`
286 */
287
288module.exports = toRegexRange;
Note: See TracBrowser for help on using the repository browser.