1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 | const 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 |
|
37 | re = [];
|
38 |
|
39 |
|
40 |
|
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 |
|
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 |
|
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 |
|
98 | if (min[0] != max[0]) {
|
99 | if (min[1] != '0') {
|
100 | if (hex) {
|
101 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
433 | export { range } |
\ | No newline at end of file |