UNPKG

11.3 kBJavaScriptView Raw
1
2//needs rewritten, but it works
3/**
4 * Function to transform a range to a regular expression
5 * @function fswquery.range
6 * @param {(number|string)} min - either a decimal number or hexidecimal string
7 * @param {(number|string)} max - either a decimal number or hexidecimal string
8 * @param {boolean?} hex - if true, the regular expression will match a hexidecimal range
9 * @returns {string} a regular expression that matches a range
10 * @example
11 * fswquery.range(500,750)
12 *
13 * return '(([56][0-9][0-9])|(7[0-4][0-9])|(750))'
14 * @example
15 * fswquery.range('100','10e',true)
16 *
17 * return '10[0-9a-e]'
18 */
19const range = (min, max, hex) => {
20 let pattern;
21 let re;
22 let diff;
23 let tmax;
24 let cnt;
25 let minV;
26 let maxV;
27 if (!hex) {
28 hex = '';
29 }
30 min = ("000" + min).slice(-3);
31 max = '' + max;
32 pattern = '';
33
34 if (min === max) { return min; }
35
36 //ending pattern will be series of connected OR ranges
37 re = [];
38
39 //first pattern+ 10's don't match and the min 1's are not zero
40 //odd number to 9
41 if (!(min[0] == max[0] && min[1] == max[1])) {
42 if (min[2] != '0') {
43 pattern = min[0] + min[1];
44 if (hex) {
45 //switch for dex
46 switch (min[2]) {
47 case "f":
48 pattern += 'f';
49 break;
50 case "e":
51 pattern += '[ef]';
52 break;
53 case "d":
54 case "c":
55 case "b":
56 case "a":
57 pattern += '[' + min[2] + '-f]';
58 break;
59 default:
60 switch (min[2]) {
61 case "9":
62 pattern += '[9a-f]';
63 break;
64 case "8":
65 pattern += '[89a-f]';
66 break;
67 default:
68 pattern += '[' + min[2] + '-9a-f]';
69 break;
70 }
71 break;
72 }
73 diff = 15 - parseInt(min[2], 16) + 1;
74 min = '' + ((parseInt(min, 16) + diff)).toString(16);
75 re.push(pattern);
76 } else {
77 //switch for dex
78 switch (min[2]) {
79 case "9":
80 pattern += '9';
81 break;
82 case "8":
83 pattern += '[89]';
84 break;
85 default:
86 pattern += '[' + min[2] + '-9]';
87 break;
88 }
89 diff = 9 - min[2] + 1;
90 min = '' + (min * 1 + diff);
91 re.push(pattern);
92 }
93 }
94 }
95 pattern = '';
96
97 //if hundreds are different, get odd to 99 or ff
98 if (min[0] != max[0]) {
99 if (min[1] != '0') {
100 if (hex) {
101 //scrape to ff
102 pattern = min[0];
103 switch (min[1]) {
104 case "f":
105 pattern += 'f';
106 break;
107 case "e":
108 pattern += '[ef]';
109 break;
110 case "d":
111 case "c":
112 case "b":
113 case "a":
114 pattern += '[' + min[1] + '-f]';
115 break;
116 case "9":
117 pattern += '[9a-f]';
118 break;
119 case "8":
120 pattern += '[89a-f]';
121 break;
122 default:
123 pattern += '[' + min[1] + '-9a-f]';
124 break;
125 }
126 pattern += '[0-9a-f]';
127 diff = 15 - parseInt(min[1], 16) + 1;
128 min = '' + (parseInt(min, 16) + diff * 16).toString(16);
129 re.push(pattern);
130 } else {
131 //scrape to 99
132 pattern = min[0];
133 diff = 9 - min[1] + 1;
134 switch (min[1]) {
135 case "9":
136 pattern += '9';
137 break;
138 case "8":
139 pattern += '[89]';
140 break;
141 default:
142 pattern += '[' + min[1] + '-9]';
143 break;
144 }
145 pattern += '[0-9]';
146 diff = 9 - min[1] + 1;
147 min = '' + (min * 1 + diff * 10);
148 re.push(pattern);
149 }
150 }
151 }
152 pattern = '';
153
154 //if hundreds are different, get to same
155 if (min[0] != max[0]) {
156 if (hex) {
157 diff = parseInt(max[0], 16) - parseInt(min[0], 16);
158 tmax = (parseInt(min[0], 16) + diff - 1).toString(16);
159
160 switch (diff) {
161 case 1:
162 pattern = min[0];
163 break;
164 case 2:
165 pattern = '[' + min[0] + tmax + ']';
166 break;
167 default:
168 if (parseInt(min[0], 16) > 9) {
169 minV = 'h';
170 } else {
171 minV = 'd';
172 }
173 if (parseInt(tmax, 16) > 9) {
174 maxV = 'h';
175 } else {
176 maxV = 'd';
177 }
178 switch (minV + maxV) {
179 case "dd":
180 pattern += '[' + min[0] + '-' + tmax + ']';
181 break;
182 case "dh":
183 diff = 9 - min[0];
184 //firs get up to 9
185 switch (diff) {
186 case 0:
187 pattern += '[9';
188 break;
189 case 1:
190 pattern += '[89';
191 break;
192 default:
193 pattern += '[' + min[0] + '-9';
194 break;
195 }
196 switch (tmax[0]) {
197 case 'a':
198 pattern += 'a]';
199 break;
200 case 'b':
201 pattern += 'ab]';
202 break;
203 default:
204 pattern += 'a-' + tmax + ']';
205 break;
206 }
207 break;
208 case "hh":
209 pattern += '[' + min[0] + '-' + tmax + ']';
210 break;
211 }
212 }
213
214 pattern += '[0-9a-f][0-9a-f]';
215 diff = parseInt(max[0], 16) - parseInt(min[0], 16);
216 min = '' + (parseInt(min, 16) + diff * 256).toString(16);
217 re.push(pattern);
218 } else {
219 diff = max[0] - min[0];
220 tmax = min[0] * 1 + diff - 1;
221
222 switch (diff) {
223 case 1:
224 pattern = min[0];
225 break;
226 case 2:
227 pattern = '[' + min[0] + tmax + ']';
228 break;
229 default:
230 pattern = '[' + min[0] + '-' + tmax + ']';
231 break;
232 }
233 pattern += '[0-9][0-9]';
234 min = '' + (min * 1 + diff * 100);
235 re.push(pattern);
236 }
237 }
238 pattern = '';
239
240 //if tens are different, get to same
241 if (min[1] != max[1]) {
242 if (hex) {
243 diff = parseInt(max[1], 16) - parseInt(min[1], 16);
244 tmax = (parseInt(min[1], 16) + diff - 1).toString(16);
245 pattern = min[0];
246 switch (diff) {
247 case 1:
248 pattern += min[1];
249 break;
250 case 2:
251 pattern += '[' + min[1] + tmax + ']';
252 break;
253 default:
254
255 if (parseInt(min[1], 16) > 9) {
256 minV = 'h';
257 } else {
258 minV = 'd';
259 }
260 if (parseInt(tmax, 16) > 9) {
261 maxV = 'h';
262 } else {
263 maxV = 'd';
264 }
265 switch (minV + maxV) {
266 case "dd":
267 pattern += '[' + min[1];
268 if (diff > 1) {
269 pattern += '-';
270 }
271 pattern += tmax + ']';
272 break;
273 case "dh":
274 diff = 9 - min[1];
275 //firs get up to 9
276 switch (diff) {
277 case 0:
278 pattern += '[9';
279 break;
280 case 1:
281 pattern += '[89';
282 break;
283 default:
284 pattern += '[' + min[1] + '-9';
285 break;
286 }
287 switch (max[1]) {
288 case 'a':
289 pattern += ']';
290 break;
291 case 'b':
292 pattern += 'a]';
293 break;
294 default:
295 pattern += 'a-' + (parseInt(max[1], 16) - 1).toString(16) + ']';
296 break;
297 }
298 break;
299 case "hh":
300 pattern += '[' + min[1];
301 if (diff > 1) {
302 pattern += '-';
303 }
304 pattern += (parseInt(max[1], 16) - 1).toString(16) + ']';
305 break;
306 }
307 break;
308 }
309 pattern += '[0-9a-f]';
310 diff = parseInt(max[1], 16) - parseInt(min[1], 16);
311 min = '' + (parseInt(min, 16) + diff * 16).toString(16);
312 re.push(pattern);
313 } else {
314 diff = max[1] - min[1];
315 tmax = min[1] * 1 + diff - 1;
316 pattern = min[0];
317 switch (diff) {
318 case 1:
319 pattern += min[1];
320 break;
321 case 2:
322 pattern += '[' + min[1] + tmax + ']';
323 break;
324 default:
325 pattern += '[' + min[1] + '-' + tmax + ']';
326 break;
327 }
328 pattern += '[0-9]';
329 min = '' + (min * 1 + diff * 10);
330 re.push(pattern);
331 }
332 }
333 pattern = '';
334
335 //if digits are different, get to same
336 if (min[2] != max[2]) {
337 if (hex) {
338 pattern = min[0] + min[1];
339 diff = parseInt(max[2], 16) - parseInt(min[2], 16);
340 if (parseInt(min[2], 16) > 9) {
341 minV = 'h';
342 } else {
343 minV = 'd';
344 }
345 if (parseInt(max[2], 16) > 9) {
346 maxV = 'h';
347 } else {
348 maxV = 'd';
349 }
350 switch (minV + maxV) {
351 case "dd":
352 pattern += '[' + min[2];
353 if (diff > 1) {
354 pattern += '-';
355 }
356 pattern += max[2] + ']';
357 break;
358 case "dh":
359 diff = 9 - min[2];
360 //firs get up to 9
361 switch (diff) {
362 case 0:
363 pattern += '[9';
364 break;
365 case 1:
366 pattern += '[89';
367 break;
368 default:
369 pattern += '[' + min[2] + '-9';
370 break;
371 }
372 switch (max[2]) {
373 case 'a':
374 pattern += 'a]';
375 break;
376 case 'b':
377 pattern += 'ab]';
378 break;
379 default:
380 pattern += 'a-' + max[2] + ']';
381 break;
382 }
383
384 break;
385 case "hh":
386 pattern += '[' + min[2];
387 if (diff > 1) {
388 pattern += '-';
389 }
390 pattern += max[2] + ']';
391 break;
392 }
393 diff = parseInt(max[2], 16) - parseInt(min[2], 16);
394 min = '' + (parseInt(min, 16) + diff).toString(16);
395 re.push(pattern);
396 } else {
397 diff = max[2] - min[2];
398 pattern = min[0] + min[1];
399 switch (diff) {
400 case 0:
401 pattern += min[2];
402 break;
403 case 1:
404 pattern += '[' + min[2] + max[2] + ']';
405 break;
406 default:
407 pattern += '[' + min[2] + '-' + max[2] + ']';
408 break;
409 }
410 min = '' + (min * 1 + diff);
411 re.push(pattern);
412 }
413 }
414 pattern = '';
415
416 //last place is whole hundred
417 if (min[2] == '0' && max[2] == '0') {
418 pattern = max;
419 re.push(pattern);
420 }
421 pattern = '';
422
423 cnt = re.length;
424 if (cnt == 1) {
425 pattern = re[0];
426 } else {
427 pattern = re.join(')|(');
428 pattern = '((' + pattern + '))';
429 }
430 return pattern;
431}
432
433export { range }
\No newline at end of file