--- /dev/null
+'use strict';
+
+var splitString = require('split-string');
+var utils = module.exports;
+
+/**
+ * Module dependencies
+ */
+
+utils.extend = require('extend-shallow');
+utils.flatten = require('arr-flatten');
+utils.isObject = require('isobject');
+utils.fillRange = require('fill-range');
+utils.repeat = require('repeat-element');
+utils.unique = require('array-unique');
+
+utils.define = function(obj, key, val) {
+ Object.defineProperty(obj, key, {
+ writable: true,
+ configurable: true,
+ enumerable: false,
+ value: val
+ });
+};
+
+/**
+ * Returns true if the given string contains only empty brace sets.
+ */
+
+utils.isEmptySets = function(str) {
+ return /^(?:\{,\})+$/.test(str);
+};
+
+/**
+ * Returns true if the given string contains only empty brace sets.
+ */
+
+utils.isQuotedString = function(str) {
+ var open = str.charAt(0);
+ if (open === '\'' || open === '"' || open === '`') {
+ return str.slice(-1) === open;
+ }
+ return false;
+};
+
+/**
+ * Create the key to use for memoization. The unique key is generated
+ * by iterating over the options and concatenating key-value pairs
+ * to the pattern string.
+ */
+
+utils.createKey = function(pattern, options) {
+ var id = pattern;
+ if (typeof options === 'undefined') {
+ return id;
+ }
+ var keys = Object.keys(options);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ id += ';' + key + '=' + String(options[key]);
+ }
+ return id;
+};
+
+/**
+ * Normalize options
+ */
+
+utils.createOptions = function(options) {
+ var opts = utils.extend.apply(null, arguments);
+ if (typeof opts.expand === 'boolean') {
+ opts.optimize = !opts.expand;
+ }
+ if (typeof opts.optimize === 'boolean') {
+ opts.expand = !opts.optimize;
+ }
+ if (opts.optimize === true) {
+ opts.makeRe = true;
+ }
+ return opts;
+};
+
+/**
+ * Join patterns in `a` to patterns in `b`
+ */
+
+utils.join = function(a, b, options) {
+ options = options || {};
+ a = utils.arrayify(a);
+ b = utils.arrayify(b);
+
+ if (!a.length) return b;
+ if (!b.length) return a;
+
+ var len = a.length;
+ var idx = -1;
+ var arr = [];
+
+ while (++idx < len) {
+ var val = a[idx];
+ if (Array.isArray(val)) {
+ for (var i = 0; i < val.length; i++) {
+ val[i] = utils.join(val[i], b, options);
+ }
+ arr.push(val);
+ continue;
+ }
+
+ for (var j = 0; j < b.length; j++) {
+ var bval = b[j];
+
+ if (Array.isArray(bval)) {
+ arr.push(utils.join(val, bval, options));
+ } else {
+ arr.push(val + bval);
+ }
+ }
+ }
+ return arr;
+};
+
+/**
+ * Split the given string on `,` if not escaped.
+ */
+
+utils.split = function(str, options) {
+ var opts = utils.extend({sep: ','}, options);
+ if (typeof opts.keepQuotes !== 'boolean') {
+ opts.keepQuotes = true;
+ }
+ if (opts.unescape === false) {
+ opts.keepEscaping = true;
+ }
+ return splitString(str, opts, utils.escapeBrackets(opts));
+};
+
+/**
+ * Expand ranges or sets in the given `pattern`.
+ *
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object}
+ */
+
+utils.expand = function(str, options) {
+ var opts = utils.extend({rangeLimit: 10000}, options);
+ var segs = utils.split(str, opts);
+ var tok = { segs: segs };
+
+ if (utils.isQuotedString(str)) {
+ return tok;
+ }
+
+ if (opts.rangeLimit === true) {
+ opts.rangeLimit = 10000;
+ }
+
+ if (segs.length > 1) {
+ if (opts.optimize === false) {
+ tok.val = segs[0];
+ return tok;
+ }
+
+ tok.segs = utils.stringifyArray(tok.segs);
+ } else if (segs.length === 1) {
+ var arr = str.split('..');
+
+ if (arr.length === 1) {
+ tok.val = tok.segs[tok.segs.length - 1] || tok.val || str;
+ tok.segs = [];
+ return tok;
+ }
+
+ if (arr.length === 2 && arr[0] === arr[1]) {
+ tok.escaped = true;
+ tok.val = arr[0];
+ tok.segs = [];
+ return tok;
+ }
+
+ if (arr.length > 1) {
+ if (opts.optimize !== false) {
+ opts.optimize = true;
+ delete opts.expand;
+ }
+
+ if (opts.optimize !== true) {
+ var min = Math.min(arr[0], arr[1]);
+ var max = Math.max(arr[0], arr[1]);
+ var step = arr[2] || 1;
+
+ if (opts.rangeLimit !== false && ((max - min) / step >= opts.rangeLimit)) {
+ throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+ }
+ }
+
+ arr.push(opts);
+ tok.segs = utils.fillRange.apply(null, arr);
+
+ if (!tok.segs.length) {
+ tok.escaped = true;
+ tok.val = str;
+ return tok;
+ }
+
+ if (opts.optimize === true) {
+ tok.segs = utils.stringifyArray(tok.segs);
+ }
+
+ if (tok.segs === '') {
+ tok.val = str;
+ } else {
+ tok.val = tok.segs[0];
+ }
+ return tok;
+ }
+ } else {
+ tok.val = str;
+ }
+ return tok;
+};
+
+/**
+ * Ensure commas inside brackets and parens are not split.
+ * @param {Object} `tok` Token from the `split-string` module
+ * @return {undefined}
+ */
+
+utils.escapeBrackets = function(options) {
+ return function(tok) {
+ if (tok.escaped && tok.val === 'b') {
+ tok.val = '\\b';
+ return;
+ }
+
+ if (tok.val !== '(' && tok.val !== '[') return;
+ var opts = utils.extend({}, options);
+ var brackets = [];
+ var parens = [];
+ var stack = [];
+ var val = tok.val;
+ var str = tok.str;
+ var i = tok.idx - 1;
+
+ while (++i < str.length) {
+ var ch = str[i];
+
+ if (ch === '\\') {
+ val += (opts.keepEscaping === false ? '' : ch) + str[++i];
+ continue;
+ }
+
+ if (ch === '(') {
+ parens.push(ch);
+ stack.push(ch);
+ }
+
+ if (ch === '[') {
+ brackets.push(ch);
+ stack.push(ch);
+ }
+
+ if (ch === ')') {
+ parens.pop();
+ stack.pop();
+ if (!stack.length) {
+ val += ch;
+ break;
+ }
+ }
+
+ if (ch === ']') {
+ brackets.pop();
+ stack.pop();
+ if (!stack.length) {
+ val += ch;
+ break;
+ }
+ }
+ val += ch;
+ }
+
+ tok.split = false;
+ tok.val = val.slice(1);
+ tok.idx = i;
+ };
+};
+
+/**
+ * Returns true if the given string looks like a regex quantifier
+ * @return {Boolean}
+ */
+
+utils.isQuantifier = function(str) {
+ return /^(?:[0-9]?,[0-9]|[0-9],)$/.test(str);
+};
+
+/**
+ * Cast `val` to an array.
+ * @param {*} `val`
+ */
+
+utils.stringifyArray = function(arr) {
+ return [utils.arrayify(arr).join('|')];
+};
+
+/**
+ * Cast `val` to an array.
+ * @param {*} `val`
+ */
+
+utils.arrayify = function(arr) {
+ if (typeof arr === 'undefined') {
+ return [];
+ }
+ if (typeof arr === 'string') {
+ return [arr];
+ }
+ return arr;
+};
+
+/**
+ * Returns true if the given `str` is a non-empty string
+ * @return {Boolean}
+ */
+
+utils.isString = function(str) {
+ return str != null && typeof str === 'string';
+};
+
+/**
+ * Get the last element from `array`
+ * @param {Array} `array`
+ * @return {*}
+ */
+
+utils.last = function(arr, n) {
+ return arr[arr.length - (n || 1)];
+};
+
+utils.escapeRegex = function(str) {
+ return str.replace(/\\?([!^*?()[\]{}+?/])/g, '\\$1');
+};
projects / dotfiles / .git / blobdiff