aboutsummaryrefslogtreecommitdiff
path: root/node_modules/braces
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/braces')
-rw-r--r--node_modules/braces/LICENSE2
-rw-r--r--node_modules/braces/README.md644
-rw-r--r--node_modules/braces/index.js545
-rw-r--r--node_modules/braces/package.json81
4 files changed, 804 insertions, 468 deletions
diff --git a/node_modules/braces/LICENSE b/node_modules/braces/LICENSE
index 39245ac1c..d32ab4426 100644
--- a/node_modules/braces/LICENSE
+++ b/node_modules/braces/LICENSE
@@ -1,6 +1,6 @@
The MIT License (MIT)
-Copyright (c) 2014-2016, Jon Schlinkert.
+Copyright (c) 2014-2018, Jon Schlinkert.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/node_modules/braces/README.md b/node_modules/braces/README.md
index 52fa7569b..f909bfba1 100644
--- a/node_modules/braces/README.md
+++ b/node_modules/braces/README.md
@@ -1,167 +1,488 @@
-# braces [![NPM version](https://img.shields.io/npm/v/braces.svg?style=flat)](https://www.npmjs.com/package/braces) [![NPM downloads](https://img.shields.io/npm/dm/braces.svg?style=flat)](https://npmjs.org/package/braces) [![Build Status](https://img.shields.io/travis/jonschlinkert/braces.svg?style=flat)](https://travis-ci.org/jonschlinkert/braces)
+# braces [![NPM version](https://img.shields.io/npm/v/braces.svg?style=flat)](https://www.npmjs.com/package/braces) [![NPM monthly downloads](https://img.shields.io/npm/dm/braces.svg?style=flat)](https://npmjs.org/package/braces) [![NPM total downloads](https://img.shields.io/npm/dt/braces.svg?style=flat)](https://npmjs.org/package/braces) [![Linux Build Status](https://img.shields.io/travis/micromatch/braces.svg?style=flat&label=Travis)](https://travis-ci.org/micromatch/braces) [![Windows Build Status](https://img.shields.io/appveyor/ci/micromatch/braces.svg?style=flat&label=AppVeyor)](https://ci.appveyor.com/project/micromatch/braces)
-Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces specification.
+> Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
## Install
Install with [npm](https://www.npmjs.com/):
```sh
-$ npm install braces --save
+$ npm install --save braces
```
-## Features
+## Why use braces?
+
+Brace patterns are great for matching ranges. Users (and implementors) shouldn't have to think about whether or not they will break their application (or yours) from accidentally defining an aggressive brace pattern. _Braces is the only library that offers a [solution to this problem](#performance)_.
-* Complete support for the braces part of the [Bash 4.3 Brace Expansion](www.gnu.org/software/bash/). Braces passes [all of the relevant unit tests](#bash-4-3-support) from the spec.
-* Expands comma-separated values: `a/{b,c}/d` => `['a/b/d', 'a/c/d']`
-* Expands alphabetical or numerical ranges: `{1..3}` => `['1', '2', '3']`
-* [Very fast](#benchmarks)
-* [Special characters](./patterns.md) can be used to generate interesting patterns.
+* **Safe(r)**: Braces isn't vulnerable to DoS attacks like [brace-expansion](https://github.com/juliangruber/brace-expansion), [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch) (a different bug than the [other regex DoS bug](https://medium.com/node-security/minimatch-redos-vulnerability-590da24e6d3c#.jew0b6mpc)).
+* **Accurate**: complete support for the [Bash 4.3 Brace Expansion](www.gnu.org/software/bash/) specification (passes all of the Bash braces tests)
+* **[fast and performant](#benchmarks)**: Starts fast, runs fast and [scales well](#performance) as patterns increase in complexity.
+* **Organized code base**: with parser and compiler that are eas(y|ier) to maintain and update when edge cases crop up.
+* **Well-tested**: thousands of test assertions. Passes 100% of the [minimatch](https://github.com/isaacs/minimatch) and [brace-expansion](https://github.com/juliangruber/brace-expansion) unit tests as well (as of the writing of this).
-## Example usage
+## Usage
+
+The main export is a function that takes one or more brace `patterns` and `options`.
```js
var braces = require('braces');
+braces(pattern[, options]);
+```
+
+By default, braces returns an optimized regex-source string. To get an array of brace patterns, use `brace.expand()`.
-braces('a/{x,y}/c{d}e')
-//=> ['a/x/cde', 'a/y/cde']
+The following section explains the difference in more detail. _(If you're curious about "why" braces does this by default, see [brace matching pitfalls](#brace-matching-pitfalls)_.
-braces('a/b/c/{x,y}')
-//=> ['a/b/c/x', 'a/b/c/y']
+### Optimized vs. expanded braces
-braces('a/{x,{1..5},y}/c{d}e')
-//=> ['a/x/cde', 'a/1/cde', 'a/y/cde', 'a/2/cde', 'a/3/cde', 'a/4/cde', 'a/5/cde']
+**Optimized**
+
+By default, patterns are optimized for regex and matching:
+
+```js
+console.log(braces('a/{x,y,z}/b'));
+//=> ['a/(x|y|z)/b']
```
-### Use case: fixtures
+**Expanded**
-> Use braces to generate test fixtures!
+To expand patterns the same way as Bash or [minimatch](https://github.com/isaacs/minimatch), use the [.expand](#expand) method:
+
+```js
+console.log(braces.expand('a/{x,y,z}/b'));
+//=> ['a/x/b', 'a/y/b', 'a/z/b']
+```
-**Example**
+Or use [options.expand](#optionsexpand):
```js
-var braces = require('./');
-var path = require('path');
-var fs = require('fs');
+console.log(braces('a/{x,y,z}/b', {expand: true}));
+//=> ['a/x/b', 'a/y/b', 'a/z/b']
+```
-braces('blah/{a..z}.js').forEach(function(fp) {
- if (!fs.existsSync(path.dirname(fp))) {
- fs.mkdirSync(path.dirname(fp));
- }
- fs.writeFileSync(fp, '');
-});
+## Features
+
+* [lists](#lists): Supports "lists": `a/{b,c}/d` => `['a/b/d', 'a/c/d']`
+* [sequences](#sequences): Supports alphabetical or numerical "sequences" (ranges): `{1..3}` => `['1', '2', '3']`
+* [steps](#steps): Supports "steps" or increments: `{2..10..2}` => `['2', '4', '6', '8', '10']`
+* [escaping](#escaping)
+* [options](#options)
+
+### Lists
+
+Uses [fill-range](https://github.com/jonschlinkert/fill-range) for expanding alphabetical or numeric lists:
+
+```js
+console.log(braces('a/{foo,bar,baz}/*.js'));
+//=> ['a/(foo|bar|baz)/*.js']
+
+console.log(braces.expand('a/{foo,bar,baz}/*.js'));
+//=> ['a/foo/*.js', 'a/bar/*.js', 'a/baz/*.js']
```
-See the [tests](./test/test.js) for more examples and use cases (also see the [bash spec tests](./test/bash-mm-adjusted.js));
+### Sequences
+
+Uses [fill-range](https://github.com/jonschlinkert/fill-range) for expanding alphabetical or numeric ranges (bash "sequences"):
-### Range expansion
+```js
+console.log(braces.expand('{1..3}')); // ['1', '2', '3']
+console.log(braces.expand('a{01..03}b')); // ['a01b', 'a02b', 'a03b']
+console.log(braces.expand('a{1..3}b')); // ['a1b', 'a2b', 'a3b']
+console.log(braces.expand('{a..c}')); // ['a', 'b', 'c']
+console.log(braces.expand('foo/{a..c}')); // ['foo/a', 'foo/b', 'foo/c']
+
+// supports padded ranges
+console.log(braces('a{01..03}b')); //=> [ 'a(0[1-3])b' ]
+console.log(braces('a{001..300}b')); //=> [ 'a(0{2}[1-9]|0[1-9][0-9]|[12][0-9]{2}|300)b' ]
+```
+
+### Steps
-Uses [expand-range](https://github.com/jonschlinkert/expand-range) for range expansion.
+Steps, or increments, may be used with ranges:
```js
-braces('a{1..3}b')
-//=> ['a1b', 'a2b', 'a3b']
+console.log(braces.expand('{2..10..2}'));
+//=> ['2', '4', '6', '8', '10']
-braces('a{5..8}b')
-//=> ['a5b', 'a6b', 'a7b', 'a8b']
+console.log(braces('{2..10..2}'));
+//=> ['(2|4|6|8|10)']
+```
+
+When the [.optimize](#optimize) method is used, or [options.optimize](#optionsoptimize) is set to true, sequences are passed to [to-regex-range](https://github.com/jonschlinkert/to-regex-range) for expansion.
-braces('a{00..05}b')
-//=> ['a00b', 'a01b', 'a02b', 'a03b', 'a04b', 'a05b']
+### Nesting
-braces('a{01..03}b')
-//=> ['a01b', 'a02b', 'a03b']
+Brace patterns may be nested. The results of each expanded string are not sorted, and left to right order is preserved.
-braces('a{000..005}b')
-//=> ['a000b', 'a001b', 'a002b', 'a003b', 'a004b', 'a005b']
+**"Expanded" braces**
-braces('a{a..e}b')
-//=> ['aab', 'abb', 'acb', 'adb', 'aeb']
+```js
+console.log(braces.expand('a{b,c,/{x,y}}/e'));
+//=> ['ab/e', 'ac/e', 'a/x/e', 'a/y/e']
-braces('a{A..E}b')
-//=> ['aAb', 'aBb', 'aCb', 'aDb', 'aEb']
+console.log(braces.expand('a/{x,{1..5},y}/c'));
+//=> ['a/x/c', 'a/1/c', 'a/2/c', 'a/3/c', 'a/4/c', 'a/5/c', 'a/y/c']
```
-Pass a function as the last argument to customize range expansions:
+**"Optimized" braces**
```js
-var range = braces('x{a..e}y', function (str, i) {
- return String.fromCharCode(str) + i;
-});
+console.log(braces('a{b,c,/{x,y}}/e'));
+//=> ['a(b|c|/(x|y))/e']
-console.log(range);
-//=> ['xa0y', 'xb1y', 'xc2y', 'xd3y', 'xe4y']
+console.log(braces('a/{x,{1..5},y}/c'));
+//=> ['a/(x|([1-5])|y)/c']
```
-See [expand-range](https://github.com/jonschlinkert/expand-range) for benchmarks, tests and the full list of range expansion features.
+### Escaping
-## Options
+**Escaping braces**
-### options.makeRe
+A brace pattern will not be expanded or evaluted if _either the opening or closing brace is escaped_:
-Type: `Boolean`
+```js
+console.log(braces.expand('a\\{d,c,b}e'));
+//=> ['a{d,c,b}e']
-Deafault: `false`
+console.log(braces.expand('a{d,c,b\\}e'));
+//=> ['a{d,c,b}e']
+```
-Return a regex-optimal string. If you're using braces to generate regex, this will result in dramatically faster performance.
+**Escaping commas**
-**Examples**
+Commas inside braces may also be escaped:
+
+```js
+console.log(braces.expand('a{b\\,c}d'));
+//=> ['a{b,c}d']
+
+console.log(braces.expand('a{d\\,c,b}e'));
+//=> ['ad,ce', 'abe']
+```
+
+**Single items**
+
+Following bash conventions, a brace pattern is also not expanded when it contains a single character:
+
+```js
+console.log(braces.expand('a{b}c'));
+//=> ['a{b}c']
+```
+
+## Options
+
+### options.maxLength
+
+**Type**: `Number`
-With the default settings (`{makeRe: false}`):
+**Default**: `65,536`
+
+**Description**: Limit the length of the input string. Useful when the input string is generated or your application allows users to pass a string, et cetera.
```js
-braces('{1..5}');
-//=> ['1', '2', '3', '4', '5']
+console.log(braces('a/{b,c}/d', { maxLength: 3 })); //=> throws an error
```
-With `{makeRe: true}`:
+### options.expand
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Generate an "expanded" brace pattern (this option is unncessary with the `.expand` method, which does the same thing).
```js
-braces('{1..5}', {makeRe: true});
-//=> ['[1-5]']
+console.log(braces('a/{b,c}/d', {expand: true}));
+//=> [ 'a/b/d', 'a/c/d' ]
+```
+
+### options.optimize
+
+**Type**: `Boolean`
+
+**Default**: `true`
+
+**Description**: Enabled by default.
-braces('{3..9..3}', {makeRe: true});
-//=> ['(3|6|9)']
+```js
+console.log(braces('a/{b,c}/d'));
+//=> [ 'a/(b|c)/d' ]
```
-### options.bash
+### options.nodupes
+
+**Type**: `Boolean`
+
+**Default**: `true`
+
+**Description**: Duplicates are removed by default. To keep duplicates, pass `{nodupes: false}` on the options
+
+### options.rangeLimit
+
+**Type**: `Number`
+
+**Default**: `250`
+
+**Description**: When `braces.expand()` is used, or `options.expand` is true, brace patterns will automatically be [optimized](#optionsoptimize) when the difference between the range minimum and range maximum exceeds the `rangeLimit`. This is to prevent huge ranges from freezing your application.
+
+You can set this to any number, or change `options.rangeLimit` to `Inifinity` to disable this altogether.
+
+**Examples**
+
+```js
+// pattern exceeds the "rangeLimit", so it's optimized automatically
+console.log(braces.expand('{1..1000}'));
+//=> ['([1-9]|[1-9][0-9]{1,2}|1000)']
-Type: `Boolean`
+// pattern does not exceed "rangeLimit", so it's NOT optimized
+console.log(braces.expand('{1..100}'));
+//=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100']
+```
-Default: `false`
+### options.transform
-Enables complete support for the Bash specification. The downside is a 20-25% speed decrease.
+**Type**: `Function`
-**Example**
+**Default**: `undefined`
-Using the default setting (`{bash: false}`):
+**Description**: Customize range expansion.
```js
-braces('a{b}c');
-//=> ['abc']
+var range = braces.expand('x{a..e}y', {
+ transform: function(str) {
+ return 'foo' + str;
+ }
+});
+
+console.log(range);
+//=> [ 'xfooay', 'xfooby', 'xfoocy', 'xfoody', 'xfooey' ]
```
-In bash (and minimatch), braces with one item are not expanded. To get the same result with braces, set `{bash: true}`:
+### options.quantifiers
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: In regular expressions, quanitifiers can be used to specify how many times a token can be repeated. For example, `a{1,3}` will match the letter `a` one to three times.
+
+Unfortunately, regex quantifiers happen to share the same syntax as [Bash lists](#lists)
+
+The `quantifiers` option tells braces to detect when [regex quantifiers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#quantifiers) are defined in the given pattern, and not to try to expand them as lists.
+
+**Examples**
```js
-braces('a{b}c', {bash: true});
-//=> ['a{b}c']
+var braces = require('braces');
+console.log(braces('a/b{1,3}/{x,y,z}'));
+//=> [ 'a/b(1|3)/(x|y|z)' ]
+console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true}));
+//=> [ 'a/b{1,3}/(x|y|z)' ]
+console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true, expand: true}));
+//=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ]
```
-### options.nodupes
+### options.unescape
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Strip backslashes that were used for escaping from the result.
+
+## What is "brace expansion"?
+
+Brace expansion is a type of parameter expansion that was made popular by unix shells for generating lists of strings, as well as regex-like matching when used alongside wildcards (globs).
-Type: `Boolean`
+In addition to "expansion", braces are also used for matching. In other words:
-Deafault: `true`
+* [brace expansion](#brace-expansion) is for generating new lists
+* [brace matching](#brace-matching) is for filtering existing lists
-Duplicates are removed by default. To keep duplicates, pass `{nodupes: false}` on the options
+<details>
+<summary><strong>More about brace expansion</strong> (click to expand)</summary>
-## Bash 4.3 Support
+There are two main types of brace expansion:
-> Better support for Bash 4.3 than minimatch
+1. **lists**: which are defined using comma-separated values inside curly braces: `{a,b,c}`
+2. **sequences**: which are defined using a starting value and an ending value, separated by two dots: `a{1..3}b`. Optionally, a third argument may be passed to define a "step" or increment to use: `a{1..100..10}b`. These are also sometimes referred to as "ranges".
-This project has comprehensive unit tests, including tests coverted from [Bash 4.3](www.gnu.org/software/bash/). Currently only 8 of 102 unit tests fail, and
+Here are some example brace patterns to illustrate how they work:
-## Run benchmarks
+**Sets**
+
+```
+{a,b,c} => a b c
+{a,b,c}{1,2} => a1 a2 b1 b2 c1 c2
+```
+
+**Sequences**
+
+```
+{1..9} => 1 2 3 4 5 6 7 8 9
+{4..-4} => 4 3 2 1 0 -1 -2 -3 -4
+{1..20..3} => 1 4 7 10 13 16 19
+{a..j} => a b c d e f g h i j
+{j..a} => j i h g f e d c b a
+{a..z..3} => a d g j m p s v y
+```
+
+**Combination**
+
+Sets and sequences can be mixed together or used along with any other strings.
+
+```
+{a,b,c}{1..3} => a1 a2 a3 b1 b2 b3 c1 c2 c3
+foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar
+```
+
+The fact that braces can be "expanded" from relatively simple patterns makes them ideal for quickly generating test fixtures, file paths, and similar use cases.
+
+## Brace matching
+
+In addition to _expansion_, brace patterns are also useful for performing regular-expression-like matching.
+
+For example, the pattern `foo/{1..3}/bar` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+```
+
+But not:
+
+```
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+Braces can also be combined with [glob patterns](https://github.com/jonschlinkert/micromatch) to perform more advanced wildcard matching. For example, the pattern `*/{1..3}/*` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+## Brace matching pitfalls
+
+Although brace patterns offer a user-friendly way of matching ranges or sets of strings, there are also some major disadvantages and potential risks you should be aware of.
+
+### tldr
+
+**"brace bombs"**
+
+* brace expansion can eat up a huge amount of processing resources
+* as brace patterns increase _linearly in size_, the system resources required to expand the pattern increase exponentially
+* users can accidentally (or intentially) exhaust your system's resources resulting in the equivalent of a DoS attack (bonus: no programming knowledge is required!)
+
+For a more detailed explanation with examples, see the [geometric complexity](#geometric-complexity) section.
+
+### The solution
+
+Jump to the [performance section](#performance) to see how Braces solves this problem in comparison to other libraries.
+
+### Geometric complexity
+
+At minimum, brace patterns with sets limited to two elements have quadradic or `O(n^2)` complexity. But the complexity of the algorithm increases exponentially as the number of sets, _and elements per set_, increases, which is `O(n^c)`.
+
+For example, the following sets demonstrate quadratic (`O(n^2)`) complexity:
+
+```
+{1,2}{3,4} => (2X2) => 13 14 23 24
+{1,2}{3,4}{5,6} => (2X2X2) => 135 136 145 146 235 236 245 246
+```
+
+But add an element to a set, and we get a n-fold Cartesian product with `O(n^c)` complexity:
+
+```
+{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248
+ 249 257 258 259 267 268 269 347 348 349 357
+ 358 359 367 368 369
+```
+
+Now, imagine how this complexity grows given that each element is a n-tuple:
+
+```
+{1..100}{1..100} => (100X100) => 10,000 elements (38.4 kB)
+{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB)
+```
+
+Although these examples are clearly contrived, they demonstrate how brace patterns can quickly grow out of control.
+
+**More information**
+
+Interested in learning more about brace expansion?
+
+* [linuxjournal/bash-brace-expansion](http://www.linuxjournal.com/content/bash-brace-expansion)
+* [rosettacode/Brace_expansion](https://rosettacode.org/wiki/Brace_expansion)
+* [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+
+</details>
+
+## Performance
+
+Braces is not only screaming fast, it's also more accurate the other brace expansion libraries.
+
+### Better algorithms
+
+Fortunately there is a solution to the ["brace bomb" problem](#brace-matching-pitfalls): _don't expand brace patterns into an array when they're used for matching_.
+
+Instead, convert the pattern into an optimized regular expression. This is easier said than done, and braces is the only library that does this currently.
+
+**The proof is in the numbers**
+
+Minimatch gets exponentially slower as patterns increase in complexity, braces does not. The following results were generated using `braces()` and `minimatch.braceExpand()`, respectively.
+
+| **Pattern** | **braces** | **[minimatch](https://github.com/isaacs/minimatch)** |
+| --- | --- | --- |
+| `{1..9007199254740991}`<sup class="footnote-ref"><a href="#fn1" id="fnref1">[1]</a></sup> | `298 B` (5ms 459μs) | N/A (freezes) |
+| `{1..1000000000000000}` | `41 B` (1ms 15μs) | N/A (freezes) |
+| `{1..100000000000000}` | `40 B` (890μs) | N/A (freezes) |
+| `{1..10000000000000}` | `39 B` (2ms 49μs) | N/A (freezes) |
+| `{1..1000000000000}` | `38 B` (608μs) | N/A (freezes) |
+| `{1..100000000000}` | `37 B` (397μs) | N/A (freezes) |
+| `{1..10000000000}` | `35 B` (983μs) | N/A (freezes) |
+| `{1..1000000000}` | `34 B` (798μs) | N/A (freezes) |
+| `{1..100000000}` | `33 B` (733μs) | N/A (freezes) |
+| `{1..10000000}` | `32 B` (5ms 632μs) | `78.89 MB` (16s 388ms 569μs) |
+| `{1..1000000}` | `31 B` (1ms 381μs) | `6.89 MB` (1s 496ms 887μs) |
+| `{1..100000}` | `30 B` (950μs) | `588.89 kB` (146ms 921μs) |
+| `{1..10000}` | `29 B` (1ms 114μs) | `48.89 kB` (14ms 187μs) |
+| `{1..1000}` | `28 B` (760μs) | `3.89 kB` (1ms 453μs) |
+| `{1..100}` | `22 B` (345μs) | `291 B` (196μs) |
+| `{1..10}` | `10 B` (533μs) | `20 B` (37μs) |
+| `{1..3}` | `7 B` (190μs) | `5 B` (27μs) |
+
+### Faster algorithms
+
+When you need expansion, braces is still much faster.
+
+_(the following results were generated using `braces.expand()` and `minimatch.braceExpand()`, respectively)_
+
+| **Pattern** | **braces** | **[minimatch](https://github.com/isaacs/minimatch)** |
+| --- | --- | --- |
+| `{1..10000000}` | `78.89 MB` (2s 698ms 642μs) | `78.89 MB` (18s 601ms 974μs) |
+| `{1..1000000}` | `6.89 MB` (458ms 576μs) | `6.89 MB` (1s 491ms 621μs) |
+| `{1..100000}` | `588.89 kB` (20ms 728μs) | `588.89 kB` (156ms 919μs) |
+| `{1..10000}` | `48.89 kB` (2ms 202μs) | `48.89 kB` (13ms 641μs) |
+| `{1..1000}` | `3.89 kB` (1ms 796μs) | `3.89 kB` (1ms 958μs) |
+| `{1..100}` | `291 B` (424μs) | `291 B` (211μs) |
+| `{1..10}` | `20 B` (487μs) | `20 B` (72μs) |
+| `{1..3}` | `5 B` (166μs) | `5 B` (27μs) |
+
+If you'd like to run these comparisons yourself, see [test/support/generate.js](test/support/generate.js).
+
+## Benchmarks
+
+### Running benchmarks
Install dev dependencies:
@@ -172,77 +493,148 @@ npm i -d && npm benchmark
### Latest results
```bash
-#1: escape.js
- brace-expansion.js x 114,934 ops/sec ±1.24% (93 runs sampled)
- braces.js x 342,254 ops/sec ±0.84% (90 runs sampled)
+Benchmarking: (8 of 8)
+ · combination-nested
+ · combination
+ · escaped
+ · list-basic
+ · list-multiple
+ · no-braces
+ · sequence-basic
+ · sequence-multiple
-#2: exponent.js
- brace-expansion.js x 12,359 ops/sec ±0.86% (96 runs sampled)
- braces.js x 20,389 ops/sec ±0.71% (97 runs sampled)
+# benchmark/fixtures/combination-nested.js (52 bytes)
+ brace-expansion x 4,756 ops/sec ±1.09% (86 runs sampled)
+ braces x 11,202,303 ops/sec ±1.06% (88 runs sampled)
+ minimatch x 4,816 ops/sec ±0.99% (87 runs sampled)
-#3: multiple.js
- brace-expansion.js x 114,469 ops/sec ±1.44% (94 runs sampled)
- braces.js x 401,621 ops/sec ±0.87% (91 runs sampled)
+ fastest is braces
-#4: nested.js
- brace-expansion.js x 102,769 ops/sec ±1.55% (92 runs sampled)
- braces.js x 314,088 ops/sec ±0.71% (98 runs sampled)
+# benchmark/fixtures/combination.js (51 bytes)
+ brace-expansion x 625 ops/sec ±0.87% (87 runs sampled)
+ braces x 11,031,884 ops/sec ±0.72% (90 runs sampled)
+ minimatch x 637 ops/sec ±0.84% (88 runs sampled)
-#5: normal.js
- brace-expansion.js x 157,577 ops/sec ±1.65% (91 runs sampled)
- braces.js x 1,115,950 ops/sec ±0.74% (94 runs sampled)
+ fastest is braces
-#6: range.js
- brace-expansion.js x 138,822 ops/sec ±1.71% (91 runs sampled)
- braces.js x 1,108,353 ops/sec ±0.85% (94 runs sampled)
-```
+# benchmark/fixtures/escaped.js (44 bytes)
+ brace-expansion x 163,325 ops/sec ±1.05% (87 runs sampled)
+ braces x 10,655,071 ops/sec ±1.22% (88 runs sampled)
+ minimatch x 147,495 ops/sec ±0.96% (88 runs sampled)
-## Related projects
+ fastest is braces
-You might also be interested in these projects:
+# benchmark/fixtures/list-basic.js (40 bytes)
+ brace-expansion x 99,726 ops/sec ±1.07% (83 runs sampled)
+ braces x 10,596,584 ops/sec ±0.98% (88 runs sampled)
+ minimatch x 100,069 ops/sec ±1.17% (86 runs sampled)
-* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. See… [more](https://www.npmjs.com/package/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range)
-* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or multiplier to… [more](https://www.npmjs.com/package/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range)
-* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/jonschlinkert/micromatch)
+ fastest is braces
-## Contributing
+# benchmark/fixtures/list-multiple.js (52 bytes)
+ brace-expansion x 34,348 ops/sec ±1.08% (88 runs sampled)
+ braces x 9,264,131 ops/sec ±1.12% (88 runs sampled)
+ minimatch x 34,893 ops/sec ±0.87% (87 runs sampled)
-Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/braces/issues/new).
+ fastest is braces
-## Building docs
+# benchmark/fixtures/no-braces.js (48 bytes)
+ brace-expansion x 275,368 ops/sec ±1.18% (89 runs sampled)
+ braces x 9,134,677 ops/sec ±0.95% (88 runs sampled)
+ minimatch x 3,755,954 ops/sec ±1.13% (89 runs sampled)
-Generate readme and API documentation with [verb](https://github.com/verbose/verb):
+ fastest is braces
-```sh
-$ npm install verb && npm run docs
+# benchmark/fixtures/sequence-basic.js (41 bytes)
+ brace-expansion x 5,492 ops/sec ±1.35% (87 runs sampled)
+ braces x 8,485,034 ops/sec ±1.28% (89 runs sampled)
+ minimatch x 5,341 ops/sec ±1.17% (87 runs sampled)
+
+ fastest is braces
+
+# benchmark/fixtures/sequence-multiple.js (51 bytes)
+ brace-expansion x 116 ops/sec ±0.77% (77 runs sampled)
+ braces x 9,445,118 ops/sec ±1.32% (84 runs sampled)
+ minimatch x 109 ops/sec ±1.16% (76 runs sampled)
+
+ fastest is braces
```
-Or, if [verb](https://github.com/verbose/verb) is installed globally:
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
```sh
-$ verb
+$ npm install && npm test
```
-## Running tests
+</details>
-Install dev dependencies:
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
```sh
-$ npm install -d && npm test
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
```
-## Author
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [expand-brackets](https://www.npmjs.com/package/expand-brackets): Expand POSIX bracket expressions (character classes) in glob patterns. | [homepage](https://github.com/jonschlinkert/expand-brackets "Expand POSIX bracket expressions (character classes) in glob patterns.")
+* [extglob](https://www.npmjs.com/package/extglob): Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… [more](https://github.com/micromatch/extglob) | [homepage](https://github.com/micromatch/extglob "Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob patterns.")
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/micromatch/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
+* [nanomatch](https://www.npmjs.com/package/nanomatch): Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash… [more](https://github.com/micromatch/nanomatch) | [homepage](https://github.com/micromatch/nanomatch "Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 188 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 4 | [doowb](https://github.com/doowb) |
+| 1 | [es128](https://github.com/es128) |
+| 1 | [eush77](https://github.com/eush77) |
+| 1 | [hemanth](https://github.com/hemanth) |
+
+### Author
**Jon Schlinkert**
+* [linkedin/in/jonschlinkert](https://linkedin.com/in/jonschlinkert)
* [github/jonschlinkert](https://github.com/jonschlinkert)
-* [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+* [twitter/jonschlinkert](https://twitter.com/jonschlinkert)
-## License
+### License
-Copyright © 2016, [Jon Schlinkert](https://github.com/jonschlinkert).
-Released under the [MIT license](https://github.com/jonschlinkert/braces/blob/master/LICENSE).
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
***
-_This file was generated by [verb](https://github.com/verbose/verb), v0.9.0, on May 21, 2016._ \ No newline at end of file
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on February 17, 2018._
+
+<hr class="footnotes-sep">
+<section class="footnotes">
+<ol class="footnotes-list">
+<li id="fn1" class="footnote-item">this is the largest safe integer allowed in JavaScript. <a href="#fnref1" class="footnote-backref">↩</a>
+
+</li>
+</ol>
+</section> \ No newline at end of file
diff --git a/node_modules/braces/index.js b/node_modules/braces/index.js
index 3b4c58d7a..048e1c233 100644
--- a/node_modules/braces/index.js
+++ b/node_modules/braces/index.js
@@ -1,399 +1,318 @@
-/*!
- * braces <https://github.com/jonschlinkert/braces>
- *
- * Copyright (c) 2014-2015, Jon Schlinkert.
- * Licensed under the MIT license.
- */
-
'use strict';
/**
* Module dependencies
*/
-var expand = require('expand-range');
-var repeat = require('repeat-element');
-var tokens = require('preserve');
+var toRegex = require('to-regex');
+var unique = require('array-unique');
+var extend = require('extend-shallow');
/**
- * Expose `braces`
+ * Local dependencies
*/
-module.exports = function(str, options) {
- if (typeof str !== 'string') {
- throw new Error('braces expects a string');
- }
- return braces(str, options);
-};
+var compilers = require('./lib/compilers');
+var parsers = require('./lib/parsers');
+var Braces = require('./lib/braces');
+var utils = require('./lib/utils');
+var MAX_LENGTH = 1024 * 64;
+var cache = {};
/**
- * Expand `{foo,bar}` or `{1..5}` braces in the
- * given `string`.
+ * Convert the given `braces` pattern into a regex-compatible string. By default, only one string is generated for every input string. Set `options.expand` to true to return an array of patterns (similar to Bash or minimatch. Before using `options.expand`, it's recommended that you read the [performance notes](#performance)).
*
- * @param {String} `str`
- * @param {Array} `arr`
- * @param {Object} `options`
- * @return {Array}
+ * ```js
+ * var braces = require('braces');
+ * console.log(braces('{a,b,c}'));
+ * //=> ['(a|b|c)']
+ *
+ * console.log(braces('{a,b,c}', {expand: true}));
+ * //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
*/
-function braces(str, arr, options) {
- if (str === '') {
- return [];
- }
-
- if (!Array.isArray(arr)) {
- options = arr;
- arr = [];
- }
-
- var opts = options || {};
- arr = arr || [];
-
- if (typeof opts.nodupes === 'undefined') {
- opts.nodupes = true;
- }
-
- var fn = opts.fn;
- var es6;
-
- if (typeof opts === 'function') {
- fn = opts;
- opts = {};
- }
-
- if (!(patternRe instanceof RegExp)) {
- patternRe = patternRegex();
- }
-
- var matches = str.match(patternRe) || [];
- var m = matches[0];
-
- switch(m) {
- case '\\,':
- return escapeCommas(str, arr, opts);
- case '\\.':
- return escapeDots(str, arr, opts);
- case '\/.':
- return escapePaths(str, arr, opts);
- case ' ':
- return splitWhitespace(str);
- case '{,}':
- return exponential(str, opts, braces);
- case '{}':
- return emptyBraces(str, arr, opts);
- case '\\{':
- case '\\}':
- return escapeBraces(str, arr, opts);
- case '${':
- if (!/\{[^{]+\{/.test(str)) {
- return arr.concat(str);
- } else {
- es6 = true;
- str = tokens.before(str, es6Regex());
- }
- }
-
- if (!(braceRe instanceof RegExp)) {
- braceRe = braceRegex();
- }
+function braces(pattern, options) {
+ var key = utils.createKey(String(pattern), options);
+ var arr = [];
- var match = braceRe.exec(str);
- if (match == null) {
- return [str];
+ var disabled = options && options.cache === false;
+ if (!disabled && cache.hasOwnProperty(key)) {
+ return cache[key];
}
- var outter = match[1];
- var inner = match[2];
- if (inner === '') { return [str]; }
-
- var segs, segsLength;
-
- if (inner.indexOf('..') !== -1) {
- segs = expand(inner, opts, fn) || inner.split(',');
- segsLength = segs.length;
-
- } else if (inner[0] === '"' || inner[0] === '\'') {
- return arr.concat(str.split(/['"]/).join(''));
-
- } else {
- segs = inner.split(',');
- if (opts.makeRe) {
- return braces(str.replace(outter, wrap(segs, '|')), opts);
- }
-
- segsLength = segs.length;
- if (segsLength === 1 && opts.bash) {
- segs[0] = wrap(segs[0], '\\');
+ if (Array.isArray(pattern)) {
+ for (var i = 0; i < pattern.length; i++) {
+ arr.push.apply(arr, braces.create(pattern[i], options));
}
+ } else {
+ arr = braces.create(pattern, options);
}
- var len = segs.length;
- var i = 0, val;
-
- while (len--) {
- var path = segs[i++];
-
- if (/(\.[^.\/])/.test(path)) {
- if (segsLength > 1) {
- return segs;
- } else {
- return [str];
- }
- }
-
- val = splice(str, outter, path);
-
- if (/\{[^{}]+?\}/.test(val)) {
- arr = braces(val, arr, opts);
- } else if (val !== '') {
- if (opts.nodupes && arr.indexOf(val) !== -1) { continue; }
- arr.push(es6 ? tokens.after(val) : val);
- }
+ if (options && options.nodupes === true) {
+ arr = unique(arr);
}
- if (opts.strict) { return filter(arr, filterEmpty); }
+ if (!disabled) {
+ cache[key] = arr;
+ }
return arr;
}
/**
- * Expand exponential ranges
+ * Expands a brace pattern into an array. This method is called by the main [braces](#braces) function when `options.expand` is true. Before using this method it's recommended that you read the [performance notes](#performance)) and advantages of using [.optimize](#optimize) instead.
*
- * `a{,}{,}` => ['a', 'a', 'a', 'a']
+ * ```js
+ * var braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
*/
-function exponential(str, options, fn) {
- if (typeof options === 'function') {
- fn = options;
- options = null;
- }
-
- var opts = options || {};
- var esc = '__ESC_EXP__';
- var exp = 0;
- var res;
-
- var parts = str.split('{,}');
- if (opts.nodupes) {
- return fn(parts.join(''), opts);
- }
-
- exp = parts.length - 1;
- res = fn(parts.join(esc), opts);
- var len = res.length;
- var arr = [];
- var i = 0;
-
- while (len--) {
- var ele = res[i++];
- var idx = ele.indexOf(esc);
-
- if (idx === -1) {
- arr.push(ele);
-
- } else {
- ele = ele.split('__ESC_EXP__').join('');
- if (!!ele && opts.nodupes !== false) {
- arr.push(ele);
-
- } else {
- var num = Math.pow(2, exp);
- arr.push.apply(arr, repeat(ele, num));
- }
- }
- }
- return arr;
-}
+braces.expand = function(pattern, options) {
+ return braces.create(pattern, extend({}, options, {expand: true}));
+};
/**
- * Wrap a value with parens, brackets or braces,
- * based on the given character/separator.
+ * Expands a brace pattern into a regex-compatible, optimized string. This method is called by the main [braces](#braces) function by default.
*
- * @param {String|Array} `val`
- * @param {String} `ch`
- * @return {String}
+ * ```js
+ * var braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
*/
-function wrap(val, ch) {
- if (ch === '|') {
- return '(' + val.join(ch) + ')';
- }
- if (ch === ',') {
- return '{' + val.join(ch) + '}';
- }
- if (ch === '-') {
- return '[' + val.join(ch) + ']';
- }
- if (ch === '\\') {
- return '\\{' + val + '\\}';
- }
-}
+braces.optimize = function(pattern, options) {
+ return braces.create(pattern, options);
+};
/**
- * Handle empty braces: `{}`
+ * Processes a brace pattern and returns either an expanded array (if `options.expand` is true), a highly optimized regex-compatible string. This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * var braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
*/
-function emptyBraces(str, arr, opts) {
- return braces(str.split('{}').join('\\{\\}'), arr, opts);
-}
+braces.create = function(pattern, options) {
+ if (typeof pattern !== 'string') {
+ throw new TypeError('expected a string');
+ }
-/**
- * Filter out empty-ish values
- */
+ var maxLength = (options && options.maxLength) || MAX_LENGTH;
+ if (pattern.length >= maxLength) {
+ throw new Error('expected pattern to be less than ' + maxLength + ' characters');
+ }
-function filterEmpty(ele) {
- return !!ele && ele !== '\\';
-}
+ function create() {
+ if (pattern === '' || pattern.length < 3) {
+ return [pattern];
+ }
-/**
- * Handle patterns with whitespace
- */
+ if (utils.isEmptySets(pattern)) {
+ return [];
+ }
-function splitWhitespace(str) {
- var segs = str.split(' ');
- var len = segs.length;
- var res = [];
- var i = 0;
+ if (utils.isQuotedString(pattern)) {
+ return [pattern.slice(1, -1)];
+ }
- while (len--) {
- res.push.apply(res, braces(segs[i++]));
- }
- return res;
-}
+ var proto = new Braces(options);
+ var result = !options || options.expand !== true
+ ? proto.optimize(pattern, options)
+ : proto.expand(pattern, options);
-/**
- * Handle escaped braces: `\\{foo,bar}`
- */
+ // get the generated pattern(s)
+ var arr = result.output;
-function escapeBraces(str, arr, opts) {
- if (!/\{[^{]+\{/.test(str)) {
- return arr.concat(str.split('\\').join(''));
- } else {
- str = str.split('\\{').join('__LT_BRACE__');
- str = str.split('\\}').join('__RT_BRACE__');
- return map(braces(str, arr, opts), function(ele) {
- ele = ele.split('__LT_BRACE__').join('{');
- return ele.split('__RT_BRACE__').join('}');
- });
- }
-}
+ // filter out empty strings if specified
+ if (options && options.noempty === true) {
+ arr = arr.filter(Boolean);
+ }
-/**
- * Handle escaped dots: `{1\\.2}`
- */
+ // filter out duplicates if specified
+ if (options && options.nodupes === true) {
+ arr = unique(arr);
+ }
-function escapeDots(str, arr, opts) {
- if (!/[^\\]\..+\\\./.test(str)) {
- return arr.concat(str.split('\\').join(''));
- } else {
- str = str.split('\\.').join('__ESC_DOT__');
- return map(braces(str, arr, opts), function(ele) {
- return ele.split('__ESC_DOT__').join('.');
+ Object.defineProperty(arr, 'result', {
+ enumerable: false,
+ value: result
});
- }
-}
-/**
- * Handle escaped dots: `{1\\.2}`
- */
+ return arr;
+ }
-function escapePaths(str, arr, opts) {
- str = str.split('\/.').join('__ESC_PATH__');
- return map(braces(str, arr, opts), function(ele) {
- return ele.split('__ESC_PATH__').join('\/.');
- });
-}
+ return memoize('create', pattern, options, create);
+};
/**
- * Handle escaped commas: `{a\\,b}`
+ * Create a regular expression from the given string `pattern`.
+ *
+ * ```js
+ * var braces = require('braces');
+ *
+ * console.log(braces.makeRe('id-{200..300}'));
+ * //=> /^(?:id-(20[0-9]|2[1-9][0-9]|300))$/
+ * ```
+ * @param {String} `pattern` The pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
*/
-function escapeCommas(str, arr, opts) {
- if (!/\w,/.test(str)) {
- return arr.concat(str.split('\\').join(''));
- } else {
- str = str.split('\\,').join('__ESC_COMMA__');
- return map(braces(str, arr, opts), function(ele) {
- return ele.split('__ESC_COMMA__').join(',');
- });
+braces.makeRe = function(pattern, options) {
+ if (typeof pattern !== 'string') {
+ throw new TypeError('expected a string');
}
-}
-/**
- * Regex for common patterns
- */
+ var maxLength = (options && options.maxLength) || MAX_LENGTH;
+ if (pattern.length >= maxLength) {
+ throw new Error('expected pattern to be less than ' + maxLength + ' characters');
+ }
-function patternRegex() {
- return /\${|( (?=[{,}])|(?=[{,}]) )|{}|{,}|\\,(?=.*[{}])|\/\.(?=.*[{}])|\\\.(?={)|\\{|\\}/;
-}
+ function makeRe() {
+ var arr = braces(pattern, options);
+ var opts = extend({strictErrors: false}, options);
+ return toRegex(arr, opts);
+ }
+
+ return memoize('makeRe', pattern, options, makeRe);
+};
/**
- * Braces regex.
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * var braces = require('braces');
+ * var ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * // { type: 'root',
+ * // errors: [],
+ * // input: 'a/{b,c}/d',
+ * // nodes:
+ * // [ { type: 'bos', val: '' },
+ * // { type: 'text', val: 'a/' },
+ * // { type: 'brace',
+ * // nodes:
+ * // [ { type: 'brace.open', val: '{' },
+ * // { type: 'text', val: 'b,c' },
+ * // { type: 'brace.close', val: '}' } ] },
+ * // { type: 'text', val: '/d' },
+ * // { type: 'eos', val: '' } ] }
+ * ```
+ * @param {String} `pattern` Brace pattern to parse
+ * @param {Object} `options`
+ * @return {Object} Returns an AST
+ * @api public
*/
-function braceRegex() {
- return /.*(\\?\{([^}]+)\})/;
-}
+braces.parse = function(pattern, options) {
+ var proto = new Braces(options);
+ return proto.parse(pattern, options);
+};
/**
- * es6 delimiter regex.
+ * Compile the given `ast` or string with the given `options`.
+ *
+ * ```js
+ * var braces = require('braces');
+ * var ast = braces.parse('a/{b,c}/d');
+ * console.log(braces.compile(ast));
+ * // { options: { source: 'string' },
+ * // state: {},
+ * // compilers:
+ * // { eos: [Function],
+ * // noop: [Function],
+ * // bos: [Function],
+ * // brace: [Function],
+ * // 'brace.open': [Function],
+ * // text: [Function],
+ * // 'brace.close': [Function] },
+ * // output: [ 'a/(b|c)/d' ],
+ * // ast:
+ * // { ... },
+ * // parsingErrors: [] }
+ * ```
+ * @param {Object|String} `ast` AST from [.parse](#parse). If a string is passed it will be parsed first.
+ * @param {Object} `options`
+ * @return {Object} Returns an object that has an `output` property with the compiled string.
+ * @api public
*/
-function es6Regex() {
- return /\$\{([^}]+)\}/;
-}
-
-var braceRe;
-var patternRe;
+braces.compile = function(ast, options) {
+ var proto = new Braces(options);
+ return proto.compile(ast, options);
+};
/**
- * Faster alternative to `String.replace()` when the
- * index of the token to be replaces can't be supplied
+ * Clear the regex cache.
+ *
+ * ```js
+ * braces.clearCache();
+ * ```
+ * @api public
*/
-function splice(str, token, replacement) {
- var i = str.indexOf(token);
- return str.substr(0, i) + replacement
- + str.substr(i + token.length);
-}
+braces.clearCache = function() {
+ cache = braces.cache = {};
+};
/**
- * Fast array map
+ * Memoize a generated regex or function. A unique key is generated
+ * from the method name, pattern, and user-defined options. Set
+ * options.memoize to false to disable.
*/
-function map(arr, fn) {
- if (arr == null) {
- return [];
+function memoize(type, pattern, options, fn) {
+ var key = utils.createKey(type + ':' + pattern, options);
+ var disabled = options && options.cache === false;
+ if (disabled) {
+ braces.clearCache();
+ return fn(pattern, options);
}
- var len = arr.length;
- var res = new Array(len);
- var i = -1;
-
- while (++i < len) {
- res[i] = fn(arr[i], i, arr);
+ if (cache.hasOwnProperty(key)) {
+ return cache[key];
}
+ var res = fn(pattern, options);
+ cache[key] = res;
return res;
}
/**
- * Fast array filter
+ * Expose `Braces` constructor and methods
+ * @type {Function}
*/
-function filter(arr, cb) {
- if (arr == null) return [];
- if (typeof cb !== 'function') {
- throw new TypeError('braces: filter expects a callback function.');
- }
+braces.Braces = Braces;
+braces.compilers = compilers;
+braces.parsers = parsers;
+braces.cache = cache;
- var len = arr.length;
- var res = arr.slice();
- var i = 0;
+/**
+ * Expose `braces`
+ * @type {Function}
+ */
- while (len--) {
- if (!cb(arr[len], i++)) {
- res.splice(len, 1);
- }
- }
- return res;
-}
+module.exports = braces;
diff --git a/node_modules/braces/package.json b/node_modules/braces/package.json
index ab6bcdc38..96cbb2b75 100644
--- a/node_modules/braces/package.json
+++ b/node_modules/braces/package.json
@@ -1,44 +1,70 @@
{
"name": "braces",
- "description": "Fastest brace expansion for node.js, with the most complete support for the Bash 4.3 braces specification.",
- "version": "1.8.5",
- "homepage": "https://github.com/jonschlinkert/braces",
+ "description": "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.",
+ "version": "2.3.2",
+ "homepage": "https://github.com/micromatch/braces",
"author": "Jon Schlinkert (https://github.com/jonschlinkert)",
- "repository": "jonschlinkert/braces",
+ "contributors": [
+ "Brian Woodward (https://twitter.com/doowb)",
+ "Elan Shanker (https://github.com/es128)",
+ "Eugene Sharygin (https://github.com/eush77)",
+ "hemanth.hm (http://h3manth.com)",
+ "Jon Schlinkert (http://twitter.com/jonschlinkert)"
+ ],
+ "repository": "micromatch/braces",
"bugs": {
- "url": "https://github.com/jonschlinkert/braces/issues"
+ "url": "https://github.com/micromatch/braces/issues"
},
"license": "MIT",
"files": [
- "index.js"
+ "index.js",
+ "lib"
],
"main": "index.js",
"engines": {
"node": ">=0.10.0"
},
"scripts": {
- "test": "mocha"
+ "test": "mocha",
+ "benchmark": "node benchmark"
},
"dependencies": {
- "expand-range": "^1.8.1",
- "preserve": "^0.2.0",
- "repeat-element": "^1.1.2"
+ "arr-flatten": "^1.1.0",
+ "array-unique": "^0.3.2",
+ "extend-shallow": "^2.0.1",
+ "fill-range": "^4.0.0",
+ "isobject": "^3.0.1",
+ "repeat-element": "^1.1.2",
+ "snapdragon": "^0.8.1",
+ "snapdragon-node": "^2.0.1",
+ "split-string": "^3.0.2",
+ "to-regex": "^3.0.1"
},
"devDependencies": {
- "benchmarked": "^0.1.5",
- "brace-expansion": "^1.1.3",
- "chalk": "^1.1.3",
- "gulp-format-md": "^0.1.8",
- "minimatch": "^3.0.0",
- "minimist": "^1.2.0",
- "mocha": "^2.4.5",
- "should": "^8.3.1"
+ "ansi-cyan": "^0.1.1",
+ "benchmarked": "^2.0.0",
+ "brace-expansion": "^1.1.8",
+ "cross-spawn": "^5.1.0",
+ "gulp": "^3.9.1",
+ "gulp-eslint": "^4.0.0",
+ "gulp-format-md": "^1.0.0",
+ "gulp-istanbul": "^1.1.2",
+ "gulp-mocha": "^3.0.1",
+ "gulp-unused": "^0.2.1",
+ "is-windows": "^1.0.1",
+ "minimatch": "^3.0.4",
+ "mocha": "^3.2.0",
+ "noncharacters": "^1.1.0",
+ "text-table": "^0.2.0",
+ "time-diff": "^0.3.1",
+ "yargs-parser": "^8.0.0"
},
"keywords": [
"alpha",
"alphabetical",
"bash",
"brace",
+ "braces",
"expand",
"expansion",
"filepath",
@@ -58,25 +84,24 @@
"sh"
],
"verb": {
- "plugins": [
- "gulp-format-md"
- ],
- "reflinks": [
- "verb"
- ],
"toc": false,
"layout": "default",
+ "tasks": [
+ "readme"
+ ],
"lint": {
"reflinks": true
},
- "tasks": [
- "readme"
+ "plugins": [
+ "gulp-format-md"
],
"related": {
"list": [
+ "expand-brackets",
+ "extglob",
+ "fill-range",
"micromatch",
- "expand-range",
- "fill-range"
+ "nanomatch"
]
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-02 15:42:00 +0000