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