aboutsummaryrefslogtreecommitdiff
path: root/node_modules/braces/lib
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/braces/lib')
-rw-r--r--node_modules/braces/lib/braces.js104
-rw-r--r--node_modules/braces/lib/compilers.js282
-rw-r--r--node_modules/braces/lib/parsers.js360
-rw-r--r--node_modules/braces/lib/utils.js343
4 files changed, 1089 insertions, 0 deletions
diff --git a/node_modules/braces/lib/braces.js b/node_modules/braces/lib/braces.js
new file mode 100644
index 0000000..baf6bf1
--- /dev/null
+++ b/node_modules/braces/lib/braces.js
@@ -0,0 +1,104 @@
+'use strict';
+
+var extend = require('extend-shallow');
+var Snapdragon = require('snapdragon');
+var compilers = require('./compilers');
+var parsers = require('./parsers');
+var utils = require('./utils');
+
+/**
+ * Customize Snapdragon parser and renderer
+ */
+
+function Braces(options) {
+ this.options = extend({}, options);
+}
+
+/**
+ * Initialize braces
+ */
+
+Braces.prototype.init = function(options) {
+ if (this.isInitialized) return;
+ this.isInitialized = true;
+ var opts = utils.createOptions({}, this.options, options);
+ this.snapdragon = this.options.snapdragon || new Snapdragon(opts);
+ this.compiler = this.snapdragon.compiler;
+ this.parser = this.snapdragon.parser;
+
+ compilers(this.snapdragon, opts);
+ parsers(this.snapdragon, opts);
+
+ /**
+ * Call Snapdragon `.parse` method. When AST is returned, we check to
+ * see if any unclosed braces are left on the stack and, if so, we iterate
+ * over the stack and correct the AST so that compilers are called in the correct
+ * order and unbalance braces are properly escaped.
+ */
+
+ utils.define(this.snapdragon, 'parse', function(pattern, options) {
+ var parsed = Snapdragon.prototype.parse.apply(this, arguments);
+ this.parser.ast.input = pattern;
+
+ var stack = this.parser.stack;
+ while (stack.length) {
+ addParent({type: 'brace.close', val: ''}, stack.pop());
+ }
+
+ function addParent(node, parent) {
+ utils.define(node, 'parent', parent);
+ parent.nodes.push(node);
+ }
+
+ // add non-enumerable parser reference
+ utils.define(parsed, 'parser', this.parser);
+ return parsed;
+ });
+};
+
+/**
+ * Decorate `.parse` method
+ */
+
+Braces.prototype.parse = function(ast, options) {
+ if (ast && typeof ast === 'object' && ast.nodes) return ast;
+ this.init(options);
+ return this.snapdragon.parse(ast, options);
+};
+
+/**
+ * Decorate `.compile` method
+ */
+
+Braces.prototype.compile = function(ast, options) {
+ if (typeof ast === 'string') {
+ ast = this.parse(ast, options);
+ } else {
+ this.init(options);
+ }
+ return this.snapdragon.compile(ast, options);
+};
+
+/**
+ * Expand
+ */
+
+Braces.prototype.expand = function(pattern) {
+ var ast = this.parse(pattern, {expand: true});
+ return this.compile(ast, {expand: true});
+};
+
+/**
+ * Optimize
+ */
+
+Braces.prototype.optimize = function(pattern) {
+ var ast = this.parse(pattern, {optimize: true});
+ return this.compile(ast, {optimize: true});
+};
+
+/**
+ * Expose `Braces`
+ */
+
+module.exports = Braces;
diff --git a/node_modules/braces/lib/compilers.js b/node_modules/braces/lib/compilers.js
new file mode 100644
index 0000000..a3b820e
--- /dev/null
+++ b/node_modules/braces/lib/compilers.js
@@ -0,0 +1,282 @@
+'use strict';
+
+var utils = require('./utils');
+
+module.exports = function(braces, options) {
+ braces.compiler
+
+ /**
+ * bos
+ */
+
+ .set('bos', function() {
+ if (this.output) return;
+ this.ast.queue = isEscaped(this.ast) ? [this.ast.val] : [];
+ this.ast.count = 1;
+ })
+
+ /**
+ * Square brackets
+ */
+
+ .set('bracket', function(node) {
+ var close = node.close;
+ var open = !node.escaped ? '[' : '\\[';
+ var negated = node.negated;
+ var inner = node.inner;
+
+ inner = inner.replace(/\\(?=[\\\w]|$)/g, '\\\\');
+ if (inner === ']-') {
+ inner = '\\]\\-';
+ }
+
+ if (negated && inner.indexOf('.') === -1) {
+ inner += '.';
+ }
+ if (negated && inner.indexOf('/') === -1) {
+ inner += '/';
+ }
+
+ var val = open + negated + inner + close;
+ var queue = node.parent.queue;
+ var last = utils.arrayify(queue.pop());
+
+ queue.push(utils.join(last, val));
+ queue.push.apply(queue, []);
+ })
+
+ /**
+ * Brace
+ */
+
+ .set('brace', function(node) {
+ node.queue = isEscaped(node) ? [node.val] : [];
+ node.count = 1;
+ return this.mapVisit(node.nodes);
+ })
+
+ /**
+ * Open
+ */
+
+ .set('brace.open', function(node) {
+ node.parent.open = node.val;
+ })
+
+ /**
+ * Inner
+ */
+
+ .set('text', function(node) {
+ var queue = node.parent.queue;
+ var escaped = node.escaped;
+ var segs = [node.val];
+
+ if (node.optimize === false) {
+ options = utils.extend({}, options, {optimize: false});
+ }
+
+ if (node.multiplier > 1) {
+ node.parent.count *= node.multiplier;
+ }
+
+ if (options.quantifiers === true && utils.isQuantifier(node.val)) {
+ escaped = true;
+
+ } else if (node.val.length > 1) {
+ if (isType(node.parent, 'brace') && !isEscaped(node)) {
+ var expanded = utils.expand(node.val, options);
+ segs = expanded.segs;
+
+ if (expanded.isOptimized) {
+ node.parent.isOptimized = true;
+ }
+
+ // if nothing was expanded, we probably have a literal brace
+ if (!segs.length) {
+ var val = (expanded.val || node.val);
+ if (options.unescape !== false) {
+ // unescape unexpanded brace sequence/set separators
+ val = val.replace(/\\([,.])/g, '$1');
+ // strip quotes
+ val = val.replace(/["'`]/g, '');
+ }
+
+ segs = [val];
+ escaped = true;
+ }
+ }
+
+ } else if (node.val === ',') {
+ if (options.expand) {
+ node.parent.queue.push(['']);
+ segs = [''];
+ } else {
+ segs = ['|'];
+ }
+ } else {
+ escaped = true;
+ }
+
+ if (escaped && isType(node.parent, 'brace')) {
+ if (node.parent.nodes.length <= 4 && node.parent.count === 1) {
+ node.parent.escaped = true;
+ } else if (node.parent.length <= 3) {
+ node.parent.escaped = true;
+ }
+ }
+
+ if (!hasQueue(node.parent)) {
+ node.parent.queue = segs;
+ return;
+ }
+
+ var last = utils.arrayify(queue.pop());
+ if (node.parent.count > 1 && options.expand) {
+ last = multiply(last, node.parent.count);
+ node.parent.count = 1;
+ }
+
+ queue.push(utils.join(utils.flatten(last), segs.shift()));
+ queue.push.apply(queue, segs);
+ })
+
+ /**
+ * Close
+ */
+
+ .set('brace.close', function(node) {
+ var queue = node.parent.queue;
+ var prev = node.parent.parent;
+ var last = prev.queue.pop();
+ var open = node.parent.open;
+ var close = node.val;
+
+ if (open && close && isOptimized(node, options)) {
+ open = '(';
+ close = ')';
+ }
+
+ // if a close brace exists, and the previous segment is one character
+ // don't wrap the result in braces or parens
+ var ele = utils.last(queue);
+ if (node.parent.count > 1 && options.expand) {
+ ele = multiply(queue.pop(), node.parent.count);
+ node.parent.count = 1;
+ queue.push(ele);
+ }
+
+ if (close && typeof ele === 'string' && ele.length === 1) {
+ open = '';
+ close = '';
+ }
+
+ if ((isLiteralBrace(node, options) || noInner(node)) && !node.parent.hasEmpty) {
+ queue.push(utils.join(open, queue.pop() || ''));
+ queue = utils.flatten(utils.join(queue, close));
+ }
+
+ if (typeof last === 'undefined') {
+ prev.queue = [queue];
+ } else {
+ prev.queue.push(utils.flatten(utils.join(last, queue)));
+ }
+ })
+
+ /**
+ * eos
+ */
+
+ .set('eos', function(node) {
+ if (this.input) return;
+
+ if (options.optimize !== false) {
+ this.output = utils.last(utils.flatten(this.ast.queue));
+ } else if (Array.isArray(utils.last(this.ast.queue))) {
+ this.output = utils.flatten(this.ast.queue.pop());
+ } else {
+ this.output = utils.flatten(this.ast.queue);
+ }
+
+ if (node.parent.count > 1 && options.expand) {
+ this.output = multiply(this.output, node.parent.count);
+ }
+
+ this.output = utils.arrayify(this.output);
+ this.ast.queue = [];
+ });
+
+};
+
+/**
+ * Multiply the segments in the current brace level
+ */
+
+function multiply(queue, n, options) {
+ return utils.flatten(utils.repeat(utils.arrayify(queue), n));
+}
+
+/**
+ * Return true if `node` is escaped
+ */
+
+function isEscaped(node) {
+ return node.escaped === true;
+}
+
+/**
+ * Returns true if regex parens should be used for sets. If the parent `type`
+ * is not `brace`, then we're on a root node, which means we should never
+ * expand segments and open/close braces should be `{}` (since this indicates
+ * a brace is missing from the set)
+ */
+
+function isOptimized(node, options) {
+ if (node.parent.isOptimized) return true;
+ return isType(node.parent, 'brace')
+ && !isEscaped(node.parent)
+ && options.expand !== true;
+}
+
+/**
+ * Returns true if the value in `node` should be wrapped in a literal brace.
+ * @return {Boolean}
+ */
+
+function isLiteralBrace(node, options) {
+ return isEscaped(node.parent) || options.optimize !== false;
+}
+
+/**
+ * Returns true if the given `node` does not have an inner value.
+ * @return {Boolean}
+ */
+
+function noInner(node, type) {
+ if (node.parent.queue.length === 1) {
+ return true;
+ }
+ var nodes = node.parent.nodes;
+ return nodes.length === 3
+ && isType(nodes[0], 'brace.open')
+ && !isType(nodes[1], 'text')
+ && isType(nodes[2], 'brace.close');
+}
+
+/**
+ * Returns true if the given `node` is the given `type`
+ * @return {Boolean}
+ */
+
+function isType(node, type) {
+ return typeof node !== 'undefined' && node.type === type;
+}
+
+/**
+ * Returns true if the given `node` has a non-empty queue.
+ * @return {Boolean}
+ */
+
+function hasQueue(node) {
+ return Array.isArray(node.queue) && node.queue.length;
+}
diff --git a/node_modules/braces/lib/parsers.js b/node_modules/braces/lib/parsers.js
new file mode 100644
index 0000000..8bf3e92
--- /dev/null
+++ b/node_modules/braces/lib/parsers.js
@@ -0,0 +1,360 @@
+'use strict';
+
+var Node = require('snapdragon-node');
+var utils = require('./utils');
+
+/**
+ * Braces parsers
+ */
+
+module.exports = function(braces, options) {
+ braces.parser
+ .set('bos', function() {
+ if (!this.parsed) {
+ this.ast = this.nodes[0] = new Node(this.ast);
+ }
+ })
+
+ /**
+ * Character parsers
+ */
+
+ .set('escape', function() {
+ var pos = this.position();
+ var m = this.match(/^(?:\\(.)|\$\{)/);
+ if (!m) return;
+
+ var prev = this.prev();
+ var last = utils.last(prev.nodes);
+
+ var node = pos(new Node({
+ type: 'text',
+ multiplier: 1,
+ val: m[0]
+ }));
+
+ if (node.val === '\\\\') {
+ return node;
+ }
+
+ if (node.val === '${') {
+ var str = this.input;
+ var idx = -1;
+ var ch;
+
+ while ((ch = str[++idx])) {
+ this.consume(1);
+ node.val += ch;
+ if (ch === '\\') {
+ node.val += str[++idx];
+ continue;
+ }
+ if (ch === '}') {
+ break;
+ }
+ }
+ }
+
+ if (this.options.unescape !== false) {
+ node.val = node.val.replace(/\\([{}])/g, '$1');
+ }
+
+ if (last.val === '"' && this.input.charAt(0) === '"') {
+ last.val = node.val;
+ this.consume(1);
+ return;
+ }
+
+ return concatNodes.call(this, pos, node, prev, options);
+ })
+
+ /**
+ * Brackets: "[...]" (basic, this is overridden by
+ * other parsers in more advanced implementations)
+ */
+
+ .set('bracket', function() {
+ var isInside = this.isInside('brace');
+ var pos = this.position();
+ var m = this.match(/^(?:\[([!^]?)([^\]]{2,}|\]-)(\]|[^*+?]+)|\[)/);
+ if (!m) return;
+
+ var prev = this.prev();
+ var val = m[0];
+ var negated = m[1] ? '^' : '';
+ var inner = m[2] || '';
+ var close = m[3] || '';
+
+ if (isInside && prev.type === 'brace') {
+ prev.text = prev.text || '';
+ prev.text += val;
+ }
+
+ var esc = this.input.slice(0, 2);
+ if (inner === '' && esc === '\\]') {
+ inner += esc;
+ this.consume(2);
+
+ var str = this.input;
+ var idx = -1;
+ var ch;
+
+ while ((ch = str[++idx])) {
+ this.consume(1);
+ if (ch === ']') {
+ close = ch;
+ break;
+ }
+ inner += ch;
+ }
+ }
+
+ return pos(new Node({
+ type: 'bracket',
+ val: val,
+ escaped: close !== ']',
+ negated: negated,
+ inner: inner,
+ close: close
+ }));
+ })
+
+ /**
+ * Empty braces (we capture these early to
+ * speed up processing in the compiler)
+ */
+
+ .set('multiplier', function() {
+ var isInside = this.isInside('brace');
+ var pos = this.position();
+ var m = this.match(/^\{((?:,|\{,+\})+)\}/);
+ if (!m) return;
+
+ this.multiplier = true;
+ var prev = this.prev();
+ var val = m[0];
+
+ if (isInside && prev.type === 'brace') {
+ prev.text = prev.text || '';
+ prev.text += val;
+ }
+
+ var node = pos(new Node({
+ type: 'text',
+ multiplier: 1,
+ match: m,
+ val: val
+ }));
+
+ return concatNodes.call(this, pos, node, prev, options);
+ })
+
+ /**
+ * Open
+ */
+
+ .set('brace.open', function() {
+ var pos = this.position();
+ var m = this.match(/^\{(?!(?:[^\\}]?|,+)\})/);
+ if (!m) return;
+
+ var prev = this.prev();
+ var last = utils.last(prev.nodes);
+
+ // if the last parsed character was an extglob character
+ // we need to _not optimize_ the brace pattern because
+ // it might be mistaken for an extglob by a downstream parser
+ if (last && last.val && isExtglobChar(last.val.slice(-1))) {
+ last.optimize = false;
+ }
+
+ var open = pos(new Node({
+ type: 'brace.open',
+ val: m[0]
+ }));
+
+ var node = pos(new Node({
+ type: 'brace',
+ nodes: []
+ }));
+
+ node.push(open);
+ prev.push(node);
+ this.push('brace', node);
+ })
+
+ /**
+ * Close
+ */
+
+ .set('brace.close', function() {
+ var pos = this.position();
+ var m = this.match(/^\}/);
+ if (!m || !m[0]) return;
+
+ var brace = this.pop('brace');
+ var node = pos(new Node({
+ type: 'brace.close',
+ val: m[0]
+ }));
+
+ if (!this.isType(brace, 'brace')) {
+ if (this.options.strict) {
+ throw new Error('missing opening "{"');
+ }
+ node.type = 'text';
+ node.multiplier = 0;
+ node.escaped = true;
+ return node;
+ }
+
+ var prev = this.prev();
+ var last = utils.last(prev.nodes);
+ if (last.text) {
+ var lastNode = utils.last(last.nodes);
+ if (lastNode.val === ')' && /[!@*?+]\(/.test(last.text)) {
+ var open = last.nodes[0];
+ var text = last.nodes[1];
+ if (open.type === 'brace.open' && text && text.type === 'text') {
+ text.optimize = false;
+ }
+ }
+ }
+
+ if (brace.nodes.length > 2) {
+ var first = brace.nodes[1];
+ if (first.type === 'text' && first.val === ',') {
+ brace.nodes.splice(1, 1);
+ brace.nodes.push(first);
+ }
+ }
+
+ brace.push(node);
+ })
+
+ /**
+ * Capture boundary characters
+ */
+
+ .set('boundary', function() {
+ var pos = this.position();
+ var m = this.match(/^[$^](?!\{)/);
+ if (!m) return;
+ return pos(new Node({
+ type: 'text',
+ val: m[0]
+ }));
+ })
+
+ /**
+ * One or zero, non-comma characters wrapped in braces
+ */
+
+ .set('nobrace', function() {
+ var isInside = this.isInside('brace');
+ var pos = this.position();
+ var m = this.match(/^\{[^,]?\}/);
+ if (!m) return;
+
+ var prev = this.prev();
+ var val = m[0];
+
+ if (isInside && prev.type === 'brace') {
+ prev.text = prev.text || '';
+ prev.text += val;
+ }
+
+ return pos(new Node({
+ type: 'text',
+ multiplier: 0,
+ val: val
+ }));
+ })
+
+ /**
+ * Text
+ */
+
+ .set('text', function() {
+ var isInside = this.isInside('brace');
+ var pos = this.position();
+ var m = this.match(/^((?!\\)[^${}[\]])+/);
+ if (!m) return;
+
+ var prev = this.prev();
+ var val = m[0];
+
+ if (isInside && prev.type === 'brace') {
+ prev.text = prev.text || '';
+ prev.text += val;
+ }
+
+ var node = pos(new Node({
+ type: 'text',
+ multiplier: 1,
+ val: val
+ }));
+
+ return concatNodes.call(this, pos, node, prev, options);
+ });
+};
+
+/**
+ * Returns true if the character is an extglob character.
+ */
+
+function isExtglobChar(ch) {
+ return ch === '!' || ch === '@' || ch === '*' || ch === '?' || ch === '+';
+}
+
+/**
+ * Combine text nodes, and calculate empty sets (`{,,}`)
+ * @param {Function} `pos` Function to calculate node position
+ * @param {Object} `node` AST node
+ * @return {Object}
+ */
+
+function concatNodes(pos, node, parent, options) {
+ node.orig = node.val;
+ var prev = this.prev();
+ var last = utils.last(prev.nodes);
+ var isEscaped = false;
+
+ if (node.val.length > 1) {
+ var a = node.val.charAt(0);
+ var b = node.val.slice(-1);
+
+ isEscaped = (a === '"' && b === '"')
+ || (a === "'" && b === "'")
+ || (a === '`' && b === '`');
+ }
+
+ if (isEscaped && options.unescape !== false) {
+ node.val = node.val.slice(1, node.val.length - 1);
+ node.escaped = true;
+ }
+
+ if (node.match) {
+ var match = node.match[1];
+ if (!match || match.indexOf('}') === -1) {
+ match = node.match[0];
+ }
+
+ // replace each set with a single ","
+ var val = match.replace(/\{/g, ',').replace(/\}/g, '');
+ node.multiplier *= val.length;
+ node.val = '';
+ }
+
+ var simpleText = last.type === 'text'
+ && last.multiplier === 1
+ && node.multiplier === 1
+ && node.val;
+
+ if (simpleText) {
+ last.val += node.val;
+ return;
+ }
+
+ prev.push(node);
+}
diff --git a/node_modules/braces/lib/utils.js b/node_modules/braces/lib/utils.js
new file mode 100644
index 0000000..4716671
--- /dev/null
+++ b/node_modules/braces/lib/utils.js
@@ -0,0 +1,343 @@
+'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');
+};
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 12:13:42 +0000