pablinux/APP-SIGMA-WEB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NUEVA BUSQUEDA DE DATOS SRI

Browse Source
This commit is contained in:
PABLINUX
2023-04-11 10:50:28 -05:00
parent d9d7eb83cb
commit 6b4b3e263c
612 changed files with 11604 additions and 36692 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
node_modules/picomatch/CHANGELOG.md generated vendored
View File

@@ -32,6 +32,35 @@ Changelog entries are classified using the following labels _(from [keep-a-chang
</details>
## 2.3.1 (2022-01-02)
### Fixed
* Fixes bug when a pattern containing an expression after the closing parenthesis (`/!(*.d).{ts,tsx}`) was incorrectly converted to regexp ([9f241ef](https://github.com/micromatch/picomatch/commit/9f241ef)).
### Changed
* Some documentation improvements ([f81d236](https://github.com/micromatch/picomatch/commit/f81d236), [421e0e7](https://github.com/micromatch/picomatch/commit/421e0e7)).
## 2.3.0 (2021-05-21)
### Fixed
* Fixes bug where file names with two dots were not being matched consistently with negation extglobs containing a star ([56083ef](https://github.com/micromatch/picomatch/commit/56083ef))
## 2.2.3 (2021-04-10)
### Fixed
* Do not skip pattern seperator for square brackets ([fb08a30](https://github.com/micromatch/picomatch/commit/fb08a30)).
* Set negatedExtGlob also if it does not span the whole pattern ([032e3f5](https://github.com/micromatch/picomatch/commit/032e3f5)).
## 2.2.2 (2020-03-21)
### Fixed
* Correctly handle parts of the pattern after parentheses in the `scan` method ([e15b920](https://github.com/micromatch/picomatch/commit/e15b920)).
## 2.2.1 (2020-01-04)
* Fixes [#49](https://github.com/micromatch/picomatch/issues/49), so that braces with no sets or ranges are now propertly treated as literals.

58
node_modules/picomatch/README.md generated vendored
View File

@@ -1,18 +1,18 @@
<h1 align="center">Picomatch</h1>
<p align="center">
<a href="https://npmjs.org/package/picomatch">
<img src="https://img.shields.io/npm/v/picomatch.svg" alt="version">
</a>
<a href="https://github.com/micromatch/picomatch/actions?workflow=Tests">
<img src="https://github.com/micromatch/picomatch/workflows/Tests/badge.svg" alt="test status">
</a>
<a href="https://coveralls.io/github/micromatch/picomatch">
<img src="https://img.shields.io/coveralls/github/micromatch/picomatch/master.svg" alt="coverage status">
</a>
<a href="https://npmjs.org/package/picomatch">
<img src="https://img.shields.io/npm/dm/picomatch.svg" alt="downloads">
</a>
<a href="https://npmjs.org/package/picomatch">
<img src="https://img.shields.io/npm/v/picomatch.svg" alt="version">
</a>
<a href="https://github.com/micromatch/picomatch/actions?workflow=Tests">
<img src="https://github.com/micromatch/picomatch/workflows/Tests/badge.svg" alt="test status">
</a>
<a href="https://coveralls.io/github/micromatch/picomatch">
<img src="https://img.shields.io/coveralls/github/micromatch/picomatch/master.svg" alt="coverage status">
</a>
<a href="https://npmjs.org/package/picomatch">
<img src="https://img.shields.io/npm/dm/picomatch.svg" alt="downloads">
</a>
</p>
<br>
@@ -54,6 +54,7 @@ See the [library comparison](#library-comparisons) to other libraries.
* [.parse](#parse)
* [.scan](#scan)
* [.compileRe](#compilere)
* [.makeRe](#makere)
* [.toRegex](#toregex)
- [Options](#options)
* [Picomatch options](#picomatch-options)
@@ -234,27 +235,43 @@ console.log(result);
negated: true }
```
### [.compileRe](lib/picomatch.js#L249)
### [.compileRe](lib/picomatch.js#L245)
Create a regular expression from a glob pattern.
Compile a regular expression from the `state` object returned by the
[parse()](#parse) method.
**Params**
* `input` **{String}**: A glob pattern to convert to regex.
* `state` **{Object}**
* `options` **{Object}**
* `returnOutput` **{Boolean}**: Intended for implementors, this argument allows you to return the raw output from the parser.
* `returnState` **{Boolean}**: Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
* `returns` **{RegExp}**
### [.makeRe](lib/picomatch.js#L286)
Create a regular expression from a parsed glob pattern.
**Params**
* `state` **{String}**: The object returned from the `.parse` method.
* `options` **{Object}**
* `returnOutput` **{Boolean}**: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
* `returnState` **{Boolean}**: Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
* `returns` **{RegExp}**: Returns a regex created from the given pattern.
**Example**
```js
const picomatch = require('picomatch');
// picomatch.makeRe(input[, options]);
const state = picomatch.parse('*.js');
// picomatch.compileRe(state[, options]);
console.log(picomatch.makeRe('*.js'));
console.log(picomatch.compileRe(state));
//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
```
### [.toRegex](lib/picomatch.js#L317)
### [.toRegex](lib/picomatch.js#L321)
Create a regular expression from the given regex source string.
@@ -295,12 +312,11 @@ The following options may be used with the main `picomatch()` function or any of
| `expandRange` | `function` | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. |
| `failglob` | `boolean` | `false` | Throws an error if no matches are found. Based on the bash option of the same name. |
| `fastpaths` | `boolean` | `true` | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. |
| `flags` | `boolean` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
| `flags` | `string` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
| `ignore` | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. |
| `keepQuotes` | `boolean` | `false` | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. |
| `literalBrackets` | `boolean` | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
| `lookbehinds` | `boolean` | `true` | Support regex positive and negative lookbehinds. Note that you must be using Node 8.1.10 or higher to enable regex lookbehinds. |
| `matchBase` | `boolean` | `false` | Alias for `basename` |
| `maxLength` | `boolean` | `65536` | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
| `nobrace` | `boolean` | `false` | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. |
@@ -324,6 +340,8 @@ The following options may be used with the main `picomatch()` function or any of
| `unescape` | `boolean` | `undefined` | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. |
| `unixify` | `boolean` | `undefined` | Alias for `posixSlashes`, for backwards compatibility. |
picomatch has automatic detection for regex positive and negative lookbehinds. If the pattern contains a negative lookbehind, you must be using Node.js >= 8.10 or else picomatch will throw an error.
### Scan Options
In addition to the main [picomatch options](#picomatch-options), the following options may also be used with the [.scan](#scan) method.

BIN
node_modules/picomatch/lib/.DS_Store generated vendored
View File

Binary file not shown.

31
node_modules/picomatch/lib/parse.js generated vendored
View File

@@ -92,7 +92,7 @@ const parse = (input, options) => {
START_ANCHOR
} = PLATFORM_CHARS;
const globstar = (opts) => {
const globstar = opts => {
return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
};
@@ -142,12 +142,13 @@ const parse = (input, options) => {
const eos = () => state.index === len - 1;
const peek = state.peek = (n = 1) => input[state.index + n];
const advance = state.advance = () => input[++state.index];
const advance = state.advance = () => input[++state.index] || '';
const remaining = () => input.slice(state.index + 1);
const consume = (value = '', num = 0) => {
state.consumed += value;
state.index += num;
};
const append = token => {
state.output += token.output != null ? token.output : token.value;
consume(token.value);
@@ -203,7 +204,7 @@ const parse = (input, options) => {
}
}
if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
if (extglobs.length && tok.type !== 'paren') {
extglobs[extglobs.length - 1].inner += tok.value;
}
@@ -228,8 +229,6 @@ const parse = (input, options) => {
const output = (opts.capture ? '(' : '') + token.open;
increment('parens');
push({ type, value, output: state.output ? '' : ONE_CHAR });
push({ type: 'paren', extglob: true, value: advance(), output });
extglobs.push(token);
@@ -237,6 +236,7 @@ const parse = (input, options) => {
const extglobClose = token => {
let output = token.close + (opts.capture ? ')' : '');
let rest;
if (token.type === 'negate') {
let extglobStar = star;
@@ -249,7 +249,18 @@ const parse = (input, options) => {
output = token.close = `)$))${extglobStar}`;
}
if (token.prev.type === 'bos' && eos()) {
if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
// Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
// In this case, we need to parse the string and use it in the output of the original pattern.
// Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
//
// Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
const expression = parse(rest, { ...options, fastpaths: false }).output;
output = token.close = `)${expression})${extglobStar})`;
}
if (token.prev.type === 'bos') {
state.negatedExtglob = true;
}
}
@@ -358,9 +369,9 @@ const parse = (input, options) => {
}
if (opts.unescape === true) {
value = advance() || '';
value = advance();
} else {
value += advance() || '';
value += advance();
}
if (state.brackets === 0) {
@@ -585,7 +596,7 @@ const parse = (input, options) => {
const out = state.output.slice(0, brace.outputIndex);
const toks = state.tokens.slice(brace.tokensIndex);
brace.value = brace.output = '\\{';
value = output = `\\}`;
value = output = '\\}';
state.output = out;
for (const t of toks) {
state.output += (t.output || t.value);
@@ -1024,7 +1035,7 @@ parse.fastpaths = (input, options) => {
star = `(${star})`;
}
const globstar = (opts) => {
const globstar = opts => {
if (opts.noglobstar === true) return star;
return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
};

64
node_modules/picomatch/lib/picomatch.js generated vendored
View File

@@ -231,67 +231,71 @@ picomatch.parse = (pattern, options) => {
picomatch.scan = (input, options) => scan(input, options);
/**
* Create a regular expression from a glob pattern.
* Compile a regular expression from the `state` object returned by the
* [parse()](#parse) method.
*
* ```js
* const picomatch = require('picomatch');
* // picomatch.makeRe(input[, options]);
*
* console.log(picomatch.makeRe('*.js'));
* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
* ```
* @param {String} `input` A glob pattern to convert to regex.
* @param {Object} `state`
* @param {Object} `options`
* @return {RegExp} Returns a regex created from the given pattern.
* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
* @return {RegExp}
* @api public
*/
picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
if (returnOutput === true) {
return parsed.output;
return state.output;
}
const opts = options || {};
const prepend = opts.contains ? '' : '^';
const append = opts.contains ? '' : '$';
let source = `${prepend}(?:${parsed.output})${append}`;
if (parsed && parsed.negated === true) {
let source = `${prepend}(?:${state.output})${append}`;
if (state && state.negated === true) {
source = `^(?!${source}).*$`;
}
const regex = picomatch.toRegex(source, options);
if (returnState === true) {
regex.state = parsed;
regex.state = state;
}
return regex;
};
picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {
/**
* Create a regular expression from a parsed glob pattern.
*
* ```js
* const picomatch = require('picomatch');
* const state = picomatch.parse('*.js');
* // picomatch.compileRe(state[, options]);
*
* console.log(picomatch.compileRe(state));
* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
* ```
* @param {String} `state` The object returned from the `.parse` method.
* @param {Object} `options`
* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
* @return {RegExp} Returns a regex created from the given pattern.
* @api public
*/
picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
if (!input || typeof input !== 'string') {
throw new TypeError('Expected a non-empty string');
}
const opts = options || {};
let parsed = { negated: false, fastpaths: true };
let prefix = '';
let output;
if (input.startsWith('./')) {
input = input.slice(2);
prefix = parsed.prefix = './';
if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
parsed.output = parse.fastpaths(input, options);
}
if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
output = parse.fastpaths(input, options);
}
if (output === undefined) {
if (!parsed.output) {
parsed = parse(input, options);
parsed.prefix = prefix + (parsed.prefix || '');
} else {
parsed.output = output;
}
return picomatch.compileRe(parsed, options, returnOutput, returnState);

45
node_modules/picomatch/lib/scan.js generated vendored
View File

@@ -32,7 +32,8 @@ const depth = token => {
/**
* Quickly scans a glob pattern and returns an object with a handful of
* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
* `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
*
* ```js
* const pm = require('picomatch');
@@ -66,6 +67,7 @@ const scan = (input, options) => {
let braceEscaped = false;
let backslashes = false;
let negated = false;
let negatedExtglob = false;
let finished = false;
let braces = 0;
let prev;
@@ -177,6 +179,9 @@ const scan = (input, options) => {
isGlob = token.isGlob = true;
isExtglob = token.isExtglob = true;
finished = true;
if (code === CHAR_EXCLAMATION_MARK && index === start) {
negatedExtglob = true;
}
if (scanToEnd === true) {
while (eos() !== true && (code = advance())) {
@@ -231,13 +236,15 @@ const scan = (input, options) => {
isBracket = token.isBracket = true;
isGlob = token.isGlob = true;
finished = true;
if (scanToEnd === true) {
continue;
}
break;
}
}
if (scanToEnd === true) {
continue;
}
break;
}
if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
@@ -247,23 +254,24 @@ const scan = (input, options) => {
}
if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
while (eos() !== true && (code = advance())) {
if (code === CHAR_BACKWARD_SLASH) {
backslashes = token.backslashes = true;
code = advance();
continue;
}
isGlob = token.isGlob = true;
if (code === CHAR_RIGHT_PARENTHESES) {
isGlob = token.isGlob = true;
finished = true;
if (scanToEnd === true) {
if (scanToEnd === true) {
while (eos() !== true && (code = advance())) {
if (code === CHAR_LEFT_PARENTHESES) {
backslashes = token.backslashes = true;
code = advance();
continue;
}
break;
if (code === CHAR_RIGHT_PARENTHESES) {
finished = true;
break;
}
}
continue;
}
break;
}
if (isGlob === true) {
@@ -327,7 +335,8 @@ const scan = (input, options) => {
isGlob,
isExtglob,
isGlobstar,
negated
negated,
negatedExtglob
};
if (opts.tokens === true) {

153
node_modules/picomatch/package.json generated vendored
View File

@@ -1,53 +1,30 @@
{
"_args": [
[
"picomatch@^2.0.4",
"/home/pablinux/Projects/Node/app_sigma/node_modules/anymatch"
]
],
"_from": "picomatch@>=2.0.4 <3.0.0",
"_hasShrinkwrap": false,
"_id": "picomatch@2.2.1",
"_inCache": true,
"_installable": true,
"_location": "/picomatch",
"_nodeVersion": "13.5.0",
"_npmOperationalInternal": {
"host": "s3://npm-registry-packages",
"tmp": "tmp/picomatch_2.2.1_1578172787892_0.37797747768464274"
},
"_npmUser": {
"email": "github@sellside.com",
"name": "jonschlinkert"
},
"_npmVersion": "6.13.4",
"_phantomChildren": {},
"_requested": {
"name": "picomatch",
"raw": "picomatch@^2.0.4",
"rawSpec": "^2.0.4",
"scope": null,
"spec": ">=2.0.4 <3.0.0",
"type": "range"
},
"_requiredBy": [
"/anymatch",
"/readdirp"
],
"_resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.1.tgz",
"_shasum": "21bac888b6ed8601f831ce7816e335bc779f0a4a",
"_shrinkwrap": null,
"_spec": "picomatch@^2.0.4",
"_where": "/home/pablinux/Projects/Node/app_sigma/node_modules/anymatch",
"author": {
"name": "Jon Schlinkert",
"url": "https://github.com/jonschlinkert"
},
"name": "picomatch",
"description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
"version": "2.3.1",
"homepage": "https://github.com/micromatch/picomatch",
"author": "Jon Schlinkert (https://github.com/jonschlinkert)",
"funding": "https://github.com/sponsors/jonschlinkert",
"repository": "micromatch/picomatch",
"bugs": {
"url": "https://github.com/micromatch/picomatch/issues"
},
"dependencies": {},
"description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
"license": "MIT",
"files": [
"index.js",
"lib"
],
"main": "index.js",
"engines": {
"node": ">=8.6"
},
"scripts": {
"lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
"mocha": "mocha --reporter dot",
"test": "npm run lint && npm run mocha",
"test:ci": "npm run test:cover",
"test:cover": "nyc npm run mocha"
},
"devDependencies": {
"eslint": "^6.8.0",
"fill-range": "^7.0.1",
@@ -56,43 +33,11 @@
"nyc": "^15.0.0",
"time-require": "github:jonschlinkert/time-require"
},
"directories": {},
"dist": {
"fileCount": 11,
"integrity": "sha512-ISBaA8xQNmwELC7eOjqFKMESB2VIqt4PPDD0nsS95b/9dZXvVKOlz9keMSnoGGKcOHXfTvDD6WMaRoSc9UuhRA==",
"npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJeEQF1CRA9TVsSAnZWagAAFPUP/iMuLEJZn5i/5ZikfVC7\nKuODpS6DPrtfaWEc+j6WjLGhLyjt4XDvSGO/5CD1T1+lTM/Ch2XsnUji7MPq\nKcQecli695M0daO8LI9NbnN3omHsoWVOKGWqEAzML+rcvvfFCb0coCaMyoyN\n6E3Y0oxIRt4Wwzbo6VMq2NBy49K+f5hJidxpDENe+P9Vcu587tyG/21MPTcE\npLOiNCkGY7p+1TN7NxzhmDJZ5u8L21U2v11MnOzLp+umOfo1x0kEbar8r5vB\nb7Ux3G4tMyCHo15ts6XnsgzZcQaznjeClOX6Swv2jPW8nrcTN27/v+LeIVL2\ngW3pTqTadCd6xkorMfOYMI3fjrVtMERI+xkWFtqD7yOTyJ4jr1ofSSssvXBv\ncMTI2sq8008pbSCrM4jPqH/9zV4Vs3B9PWL+2NckiHxLD86z5zGt7GcWmF/Y\nBkXz647xqu/dEkrM+eLnPxqwq+vxJyEYcClbXJlU3KsJYa5DtXucqtMQyR0W\nD7f4QMiBPc/DHxiXcQn26zFushCNV6wRGNzHlUl2TzZqt71jaJ+ywvGOTEcm\nZTFbGPoB3lhsjBQItFyl6vbx9n0JhSOb6nD5nCjSLHCMFerWfdFMJwNlnClW\nPI1iOe9gRzLQdHdaMCIYS5/KpsttPTN7VgGmcSRwOQoLkihXTj4PMITRjwbG\nETnD\r\n=EKo9\r\n-----END PGP SIGNATURE-----\r\n",
"shasum": "21bac888b6ed8601f831ce7816e335bc779f0a4a",
"tarball": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.1.tgz",
"unpackedSize": 92535
},
"engines": {
"node": ">=8.6"
},
"funding": "https://github.com/sponsors/jonschlinkert",
"gitHead": "1d546ea22efa8ff3ca15b4848a2dffdb53aaef9a",
"homepage": "https://github.com/micromatch/picomatch",
"keywords": [
"glob",
"match",
"picomatch"
],
"license": "MIT",
"main": "index.js",
"maintainers": [
{
"name": "doowb",
"email": "brian.woodward@gmail.com"
},
{
"name": "jonschlinkert",
"email": "github@sellside.com"
},
{
"name": "mrmlnc",
"email": "dmalinochkin@rambler.ru"
}
],
"name": "picomatch",
"nyc": {
"reporter": [
"html",
@@ -100,27 +45,28 @@
"text-summary"
]
},
"optionalDependencies": {},
"readme": "ERROR: No README data found!",
"repository": {
"type": "git",
"url": "git+https://github.com/micromatch/picomatch.git"
},
"scripts": {
"lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
"mocha": "mocha --reporter dot",
"test": "npm run lint && npm run mocha",
"test:ci": "npm run lint && npm run test:cover",
"test:cover": "nyc npm run mocha"
},
"verb": {
"layout": "empty",
"lint": {
"reflinks": true
"toc": {
"render": true,
"method": "preWrite",
"maxdepth": 3
},
"layout": "empty",
"tasks": [
"readme"
],
"plugins": [
"gulp-format-md"
],
"lint": {
"reflinks": true
},
"related": {
"list": [
"braces",
"micromatch"
]
},
"reflinks": [
"braces",
"expand-brackets",
@@ -130,21 +76,6 @@
"minimatch",
"nanomatch",
"picomatch"
],
"related": {
"list": [
"braces",
"micromatch"
]
},
"tasks": [
"readme"
],
"toc": {
"maxdepth": 3,
"method": "preWrite",
"render": true
}
},
"version": "2.2.1"
]
}
}