/*!
|
* to-regex-range <https://github.com/jonschlinkert/to-regex-range>
|
*
|
* Copyright (c) 2015, 2017, Jon Schlinkert.
|
* Released under the MIT License.
|
*/
|
|
'use strict';
|
|
var repeat = require('repeat-string');
|
var isNumber = require('is-number');
|
var cache = {};
|
|
function toRegexRange(min, max, options) {
|
if (isNumber(min) === false) {
|
throw new RangeError('toRegexRange: first argument is invalid.');
|
}
|
|
if (typeof max === 'undefined' || min === max) {
|
return String(min);
|
}
|
|
if (isNumber(max) === false) {
|
throw new RangeError('toRegexRange: second argument is invalid.');
|
}
|
|
options = options || {};
|
var relax = String(options.relaxZeros);
|
var shorthand = String(options.shorthand);
|
var capture = String(options.capture);
|
var key = min + ':' + max + '=' + relax + shorthand + capture;
|
if (cache.hasOwnProperty(key)) {
|
return cache[key].result;
|
}
|
|
var a = Math.min(min, max);
|
var b = Math.max(min, max);
|
|
if (Math.abs(a - b) === 1) {
|
var result = min + '|' + max;
|
if (options.capture) {
|
return '(' + result + ')';
|
}
|
return result;
|
}
|
|
var isPadded = padding(min) || padding(max);
|
var positives = [];
|
var negatives = [];
|
|
var tok = {min: min, max: max, a: a, b: b};
|
if (isPadded) {
|
tok.isPadded = isPadded;
|
tok.maxLen = String(tok.max).length;
|
}
|
|
if (a < 0) {
|
var newMin = b < 0 ? Math.abs(b) : 1;
|
var newMax = Math.abs(a);
|
negatives = splitToPatterns(newMin, newMax, tok, options);
|
a = tok.a = 0;
|
}
|
|
if (b >= 0) {
|
positives = splitToPatterns(a, b, tok, options);
|
}
|
|
tok.negatives = negatives;
|
tok.positives = positives;
|
tok.result = siftPatterns(negatives, positives, options);
|
|
if (options.capture && (positives.length + negatives.length) > 1) {
|
tok.result = '(' + tok.result + ')';
|
}
|
|
cache[key] = tok;
|
return tok.result;
|
}
|
|
function siftPatterns(neg, pos, options) {
|
var onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
|
var onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
|
var intersected = filterPatterns(neg, pos, '-?', true, options) || [];
|
var subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
|
return subpatterns.join('|');
|
}
|
|
function splitToRanges(min, max) {
|
min = Number(min);
|
max = Number(max);
|
|
var nines = 1;
|
var stops = [max];
|
var stop = +countNines(min, nines);
|
|
while (min <= stop && stop <= max) {
|
stops = push(stops, stop);
|
nines += 1;
|
stop = +countNines(min, nines);
|
}
|
|
var zeros = 1;
|
stop = countZeros(max + 1, zeros) - 1;
|
|
while (min < stop && stop <= max) {
|
stops = push(stops, stop);
|
zeros += 1;
|
stop = countZeros(max + 1, zeros) - 1;
|
}
|
|
stops.sort(compare);
|
return stops;
|
}
|
|
/**
|
* Convert a range to a regex pattern
|
* @param {Number} `start`
|
* @param {Number} `stop`
|
* @return {String}
|
*/
|
|
function rangeToPattern(start, stop, options) {
|
if (start === stop) {
|
return {pattern: String(start), digits: []};
|
}
|
|
var zipped = zip(String(start), String(stop));
|
var len = zipped.length, i = -1;
|
|
var pattern = '';
|
var digits = 0;
|
|
while (++i < len) {
|
var numbers = zipped[i];
|
var startDigit = numbers[0];
|
var stopDigit = numbers[1];
|
|
if (startDigit === stopDigit) {
|
pattern += startDigit;
|
|
} else if (startDigit !== '0' || stopDigit !== '9') {
|
pattern += toCharacterClass(startDigit, stopDigit);
|
|
} else {
|
digits += 1;
|
}
|
}
|
|
if (digits) {
|
pattern += options.shorthand ? '\\d' : '[0-9]';
|
}
|
|
return { pattern: pattern, digits: [digits] };
|
}
|
|
function splitToPatterns(min, max, tok, options) {
|
var ranges = splitToRanges(min, max);
|
var len = ranges.length;
|
var idx = -1;
|
|
var tokens = [];
|
var start = min;
|
var prev;
|
|
while (++idx < len) {
|
var range = ranges[idx];
|
var obj = rangeToPattern(start, range, options);
|
var zeros = '';
|
|
if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
|
if (prev.digits.length > 1) {
|
prev.digits.pop();
|
}
|
prev.digits.push(obj.digits[0]);
|
prev.string = prev.pattern + toQuantifier(prev.digits);
|
start = range + 1;
|
continue;
|
}
|
|
if (tok.isPadded) {
|
zeros = padZeros(range, tok);
|
}
|
|
obj.string = zeros + obj.pattern + toQuantifier(obj.digits);
|
tokens.push(obj);
|
start = range + 1;
|
prev = obj;
|
}
|
|
return tokens;
|
}
|
|
function filterPatterns(arr, comparison, prefix, intersection, options) {
|
var res = [];
|
|
for (var i = 0; i < arr.length; i++) {
|
var tok = arr[i];
|
var ele = tok.string;
|
|
if (options.relaxZeros !== false) {
|
if (prefix === '-' && ele.charAt(0) === '0') {
|
if (ele.charAt(1) === '{') {
|
ele = '0*' + ele.replace(/^0\{\d+\}/, '');
|
} else {
|
ele = '0*' + ele.slice(1);
|
}
|
}
|
}
|
|
if (!intersection && !contains(comparison, 'string', ele)) {
|
res.push(prefix + ele);
|
}
|
|
if (intersection && contains(comparison, 'string', ele)) {
|
res.push(prefix + ele);
|
}
|
}
|
return res;
|
}
|
|
/**
|
* Zip strings (`for in` can be used on string characters)
|
*/
|
|
function zip(a, b) {
|
var arr = [];
|
for (var ch in a) arr.push([a[ch], b[ch]]);
|
return arr;
|
}
|
|
function compare(a, b) {
|
return a > b ? 1 : b > a ? -1 : 0;
|
}
|
|
function push(arr, ele) {
|
if (arr.indexOf(ele) === -1) arr.push(ele);
|
return arr;
|
}
|
|
function contains(arr, key, val) {
|
for (var i = 0; i < arr.length; i++) {
|
if (arr[i][key] === val) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
function countNines(min, len) {
|
return String(min).slice(0, -len) + repeat('9', len);
|
}
|
|
function countZeros(integer, zeros) {
|
return integer - (integer % Math.pow(10, zeros));
|
}
|
|
function toQuantifier(digits) {
|
var start = digits[0];
|
var stop = digits[1] ? (',' + digits[1]) : '';
|
if (!stop && (!start || start === 1)) {
|
return '';
|
}
|
return '{' + start + stop + '}';
|
}
|
|
function toCharacterClass(a, b) {
|
return '[' + a + ((b - a === 1) ? '' : '-') + b + ']';
|
}
|
|
function padding(str) {
|
return /^-?(0+)\d/.exec(str);
|
}
|
|
function padZeros(val, tok) {
|
if (tok.isPadded) {
|
var diff = Math.abs(tok.maxLen - String(val).length);
|
switch (diff) {
|
case 0:
|
return '';
|
case 1:
|
return '0';
|
default: {
|
return '0{' + diff + '}';
|
}
|
}
|
}
|
return val;
|
}
|
|
/**
|
* Expose `toRegexRange`
|
*/
|
|
module.exports = toRegexRange;
|
